rpms/metacity
6
0
Fork 0
Code Issues Pull Requests Releases Activity

remove unused patches

Browse Source
This commit is contained in:
Colin Walters 2008-03-31 14:41:18 +00:00
parent 60bcedf811
commit c6249b13fe
4 changed files with 0 additions and 1181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

905
metacity-2.16.0-currenttime-fixes.patch
View File

@ -1,905 +0,0 @@
--- 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;
}

152
metacity-2.16.0-losing-focus.patch
View File

@ -1,152 +0,0 @@
Index: src/display.c
===================================================================
RCS file: /cvs/gnome/metacity/src/display.c,v
retrieving revision 1.288
diff -p -u -r1.288 display.c
--- src/display.c 21 Aug 2006 18:38:21 -0000 1.288
+++ src/display.c 9 Sep 2006 18:55:33 -0000
@@ -3323,7 +3323,7 @@ meta_display_begin_grab_op (MetaDisplay
else
display->grab_have_keyboard =
- meta_screen_grab_all_keys (screen);
+ meta_screen_grab_all_keys (screen, timestamp);
if (!display->grab_have_keyboard)
{
@@ -3618,9 +3618,9 @@ meta_display_end_grab_op (MetaDisplay *d
meta_topic (META_DEBUG_WINDOW_OPS,
"Ungrabbing all keys timestamp %lu\n", timestamp);
if (display->grab_window)
- meta_window_ungrab_all_keys (display->grab_window);
+ meta_window_ungrab_all_keys (display->grab_window, timestamp);
else
- meta_screen_ungrab_all_keys (display->grab_screen);
+ meta_screen_ungrab_all_keys (display->grab_screen, timestamp);
}
#ifdef HAVE_XSYNC
Index: src/keybindings.c
===================================================================
RCS file: /cvs/gnome/metacity/src/keybindings.c,v
retrieving revision 1.132
diff -p -u -r1.132 keybindings.c
--- src/keybindings.c 21 Aug 2006 19:06:25 -0000 1.132
+++ src/keybindings.c 9 Sep 2006 18:55:33 -0000
@@ -1208,18 +1208,17 @@ grab_status_to_string (int status)
static gboolean
grab_keyboard (MetaDisplay *display,
- Window xwindow)
+ Window xwindow,
+ Time timestamp)
{
int result;
int grab_status;
- Time timestamp;
/* Grab the keyboard, so we get key releases and all key
* presses
*/
meta_error_trap_push_with_return (display);
- timestamp = meta_display_get_current_time (display);
grab_status = XGrabKeyboard (display->xdisplay,
xwindow, True,
GrabModeAsync, GrabModeAsync,
@@ -1251,12 +1250,8 @@ grab_keyboard (MetaDisplay *display,
}
static void
-ungrab_keyboard (MetaDisplay *display)
+ungrab_keyboard (MetaDisplay *display, Time timestamp)
{
- Time timestamp;
-
- timestamp = meta_display_get_current_time (display);
-
meta_error_trap_push (display);
meta_topic (META_DEBUG_KEYBINDINGS,
@@ -1267,7 +1262,7 @@ ungrab_keyboard (MetaDisplay *display)
}
gboolean
-meta_screen_grab_all_keys (MetaScreen *screen)
+meta_screen_grab_all_keys (MetaScreen *screen, Time timestamp)
{
gboolean retval;
@@ -1279,7 +1274,7 @@ meta_screen_grab_all_keys (MetaScreen *s
meta_topic (META_DEBUG_KEYBINDINGS,
"Grabbing all keys on RootWindow\n");
- retval = grab_keyboard (screen->display, screen->xroot);
+ retval = grab_keyboard (screen->display, screen->xroot, timestamp);
if (retval)
screen->all_keys_grabbed = TRUE;
else
@@ -1289,11 +1284,11 @@ meta_screen_grab_all_keys (MetaScreen *s
}
void
-meta_screen_ungrab_all_keys (MetaScreen *screen)
+meta_screen_ungrab_all_keys (MetaScreen *screen, Time timestamp)
{
if (screen->all_keys_grabbed)
{
- ungrab_keyboard (screen->display);
+ ungrab_keyboard (screen->display, timestamp);
screen->all_keys_grabbed = FALSE;
screen->keys_grabbed = FALSE;
@@ -1328,7 +1323,7 @@ meta_window_grab_all_keys (MetaWindow *
meta_topic (META_DEBUG_KEYBINDINGS,
"Grabbing all keys on window %s\n", window->desc);
- retval = grab_keyboard (window->display, grabwindow);
+ retval = grab_keyboard (window->display, grabwindow, timestamp);
if (retval)
{
window->keys_grabbed = FALSE;
@@ -1340,11 +1335,11 @@ meta_window_grab_all_keys (MetaWindow *
}
void
-meta_window_ungrab_all_keys (MetaWindow *window)
+meta_window_ungrab_all_keys (MetaWindow *window, Time timestamp)
{
if (window->all_keys_grabbed)
{
- ungrab_keyboard (window->display);
+ ungrab_keyboard (window->display, timestamp);
window->grab_on_frame = FALSE;
window->all_keys_grabbed = FALSE;
Index: src/keybindings.h
===================================================================
RCS file: /cvs/gnome/metacity/src/keybindings.h,v
retrieving revision 1.8
diff -p -u -r1.8 keybindings.h
--- src/keybindings.h 21 Aug 2006 18:38:21 -0000 1.8
+++ src/keybindings.h 9 Sep 2006 18:55:33 -0000
@@ -29,13 +29,16 @@ void meta_display_init_keys
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);
-void meta_screen_ungrab_all_keys (MetaScreen *screen);
+gboolean meta_screen_grab_all_keys (MetaScreen *screen,
+ Time timestamp);
+void meta_screen_ungrab_all_keys (MetaScreen *screen,
+ Time timestamp);
void meta_window_grab_keys (MetaWindow *window);
void meta_window_ungrab_keys (MetaWindow *window);
gboolean meta_window_grab_all_keys (MetaWindow *window,
Time timestamp);
-void meta_window_ungrab_all_keys (MetaWindow *window);
+void meta_window_ungrab_all_keys (MetaWindow *window,
+ Time timestamp);
void meta_display_process_key_event (MetaDisplay *display,
MetaWindow *window,
XEvent *event);

12
metacity-2.18.5-dont-deref-null-pointer.patch
View File

@ -1,12 +0,0 @@
diff -up metacity-2.18.5/src/session.c.dont-deref-null-pointer metacity-2.18.5/src/session.c
--- metacity-2.18.5/src/session.c.dont-deref-null-pointer 2007-09-11 15:41:23.000000000 -0400
+++ metacity-2.18.5/src/session.c 2007-09-11 15:41:34.000000000 -0400
@@ -1824,8 +1824,6 @@ warn_about_lame_clients_and_finish_inter
display_iter = display_iter->next;
}
- /* don't need to free displays */
- displays = NULL;
if (lame == NULL)
{

112
metacity-2.20.1-dont-move-windows.patch
View File

@ -1,112 +0,0 @@
--- metacity-2.20.1/src/core/window.c 2007-11-17 15:11:01.000000000 -0500
+++ metacity-2.20.1.patched/src/core/window.c 2007-11-28 11:43:28.000000000 -0500
@@ -74,6 +74,9 @@
static void meta_window_show (MetaWindow *window);
static void meta_window_hide (MetaWindow *window);
+static void meta_window_set_demands_attention_internal (MetaWindow *window,
+ MetaWorkspace *workspace);
+
static void meta_window_save_rect (MetaWindow *window);
static void meta_window_move_resize_internal (MetaWindow *window,
@@ -2793,7 +2796,7 @@
"last_user_time (%u) is more recent; ignoring "
" _NET_ACTIVE_WINDOW message.\n",
window->display->last_user_time);
- meta_window_set_demands_attention(window);
+ meta_window_set_demands_attention_internal (window, workspace);
return;
}
@@ -2813,8 +2816,21 @@
/* Get window on current or given workspace */
if (workspace == NULL)
workspace = window->screen->active_workspace;
- if (!meta_window_located_on_workspace (window, workspace))
- meta_window_change_workspace (window, 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_internal (window, workspace);
+ 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);
@@ -7982,34 +7998,49 @@
void
meta_window_set_demands_attention (MetaWindow *window)
{
+ meta_window_set_demands_attention_internal (window, NULL);
+}
+
+static void
+meta_window_set_demands_attention_internal (MetaWindow *window,
+ MetaWorkspace *workspace)
+{
MetaRectangle candidate_rect, other_rect;
GList *stack = window->screen->stack->sorted;
MetaWindow *other_window;
- gboolean obscured = FALSE;
+ gboolean obscured;
+ if (!workspace)
+ workspace = window->screen->active_workspace;
+
+ /* We count windows not located on the current workspace as obscured */
+ obscured = !meta_window_located_on_workspace (window, workspace);
+
/* Does the window have any other window on this workspace
* overlapping it?
*/
+ if (!obscured)
+ {
+ meta_window_get_outer_rect (window, &candidate_rect);
- meta_window_get_outer_rect (window, &candidate_rect);
-
- /* The stack is sorted with the top windows first. */
+ /* 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)
+ while (stack != NULL && stack->data != window)
{
- meta_window_get_outer_rect (other_window, &other_rect);
-
- if (meta_rectangle_overlap (&candidate_rect, &other_rect))
+ other_window = stack->data;
+ stack = stack->next;
+
+ if (other_window->on_all_workspaces ||
+ window->on_all_workspaces ||
+ other_window->workspace == window->workspace)
{
- obscured = TRUE;
- break;
+ meta_window_get_outer_rect (other_window, &other_rect);
+
+ if (meta_rectangle_overlap (&candidate_rect, &other_rect))
+ {
+ obscured = TRUE;
+ break;
+ }
}
}
}