--- 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 #include -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; }