2.8.6 ==

2.8.6
==

This is a stable release for Gnome 2.8.1.

Thanks to the Ken Harris, Kjartan Maraas, and the tireless efforts of
Elijah Newren for fixes in this release.

Fixes
  * Ensure the correct window is focused when minimizing (Elijah)
  * Fix keynav with mouse focus (Elijah)
  * Fix several race conditions in window focusing (Elijah)
  * Focus the top window when lowering by frame click (Ken)
  * Fix some compiler warnings (Kjartan)
  * Fix some valgrind-reported errors (Elijah)
  * Fix some potential issues with autoraising windows (Elijah)

Translations
  * en_CA(Adam Weinberger), it(Luca Ferretti)

COMPLIANCE

@@ -48,15 +48,12 @@ standard is available at http://freedesktop.org/Standards/wm-spec/
 
 + _NET_NUMBER_OF_DESKTOPS (1.3)
 
-- _NET_DESKTOP_GEOMETRY (-)
-  Metacity does not implement large desktops.  Regardless, according
-  to the specification, metacity SHOULD set this property to the
-  screen size, and update it if the screen size changes because of a
-  RandR change.
++ _NET_DESKTOP_GEOMETRY (1.3)
+  Metacity does not implement large desktops, so this is kept set to
+  the screen size.
 
-- _NET_DESKTOP_VIEWPORT (-)
-  Metacity does not implement viewports.  However, according to the
-  specification, metacity MUST set this property to (0,0)
++ _NET_DESKTOP_VIEWPORT (1.3)
+  Metacity does not implement viewports, so this is a constant (0,0).
 
 + _NET_CURRENT_DESKTOP (1.3)
 
@@ -82,15 +79,16 @@ standard is available at http://freedesktop.org/Standards/wm-spec/
 
 + _NET_CLOSE_WINDOW (1.3)
 
-- _NET_MOVERESIZE_WINDOW (-)
-  Metacity does not support this message.  The specification states
-  that metacity should treat this message like a ConfigureRequest.
-  Not hard to implement; just hasn't been done.
+- _NET_MOVERESIZE_WINDOW (1.3)
+  Metacity supports this message, but the specification is unclear on
+  the layout of the detail value, and as such it is #if 0'd in the code
 
 + _NET_WM_MOVERESIZE (1.3)
 
-- _NET_RESTACK_WINDOW (-)
-  Metacity does not currently support this message.
+- _NET_RESTACK_WINDOW (1.3)
+  Metacity will raise or lower windows in response to this message,
+  but the sibling restack modes are not supported, and it is currently
+  #if 0'd in the code.
 
 + _NET_REQUEST_FRAME_EXTENTS (1.3)  
 
@@ -114,14 +112,14 @@ standard is available at http://freedesktop.org/Standards/wm-spec/
 + _NET_WM_WINDOW_TYPE (1.3)
 
 / _NET_WM_STATE (1.3)
+  This property is read and updated according to the specification,
+  but see caveat below.
   Metacity does not recognize separate vertical and horizontal
   maximization states.  Currently metacity will do a two-dimensional
   maximization if either property is set.
   See: http://bugzilla.gnome.org/show_bug.cgi?id=113601
   Metacity doesn't implement viewports so _NET_WM_STATE_STICKY is
   unimplemented.
-  _NET_WM_STATE_DEMANDS_ATTENTION is neither read nor updated by
-  metacity.  Metacity should unset it on window activation.
 
 + _NET_WM_ALLOWED_ACTIONS (1.3)
   Metacity keeps this hint up to date.  The code is somewhat crufty
@@ -141,11 +139,11 @@ standard is available at http://freedesktop.org/Standards/wm-spec/
 
 + _NET_WM_HANDLED_ICONS (1.3)
   Metacity does not read or set this property.  However, metacity
-  never managed iconified windows, and so has no need to do so.
+  never manages iconified windows, and so has no need to do so.
 
-- _NET_WM_USER_TIME (-)
-  Metacity does not read or set this property.  The EWMH does not
-  require it to do so, but it should support it.
++ _NET_WM_USER_TIME (1.3)
+  Metacity uses this property to prevent applications from stealing
+  focus if supported by the toolkit.
 
 + _NET_FRAME_EXTENTS (1.3)
   If set in response to a _NET_REQUEST_FRAME_EXTENTS message received

ChangeLog

@@ -1,3 +1,767 @@
+2004-10-11  Rob Adams  <readams@readams.net>
+
+	* NEWS, README: Metacity 2.8.6 (stable release)
+
+2004-10-08  Elijah Newren  <newren@math.utah.edu>
+
+	Fix middle-frame-click-to-lower focus inconsistency (#154601)
+
+	* src/core.c (meta_core_user_lower_and_unfocus): focus the default
+	window in all focus modes, not just click-to-focus (EnterNotify
+	events will not handle this case for sloppy and mouse focus)
+
+	* src/display.c (event_callback): replace window->has_focus with
+	window == display->expected_focus_window to avoid a race issue
+
+2004-10-08  Elijah Newren  <newren@math.utah.edu>
+
+        Alter the meaning of expected_focus_window; doesn't affect
+	current operation but assists in fixing some other bugs
+	(#154598)
+	
+	* src/display.c (meta_display_focus_the_no_focus_window): set the
+	expected_focus_window to NULL.
+
+	* src/window.c (meta_window_notify_focus): don't NULL the
+	expected_focus_window when that window receives a FocusIn event
+
+2004-10-04  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c (event_callback): if the root window gets focused,
+	set the focus to the default window; this fixes the
+	"focus-follows-mouse" behavior seen for click-to-focus mode after
+	cancelling log out (fixes #153220)
+
+2004-10-04  Elijah Newren  <newren@math.utah.edu>
+
+	Fix a variety of issues with autoraise (#134206)
+
+	* src/display.h: (struct _MetaDisplay): add an autoraise_window
+	parameter
+
+	* src/display.[hc] (meta_display_focus_the_no_focus_window): new
+	function, (meta_display_queue_autoraise_callback): new function,
+	(meta_display_remove_autoraise_callback): new function
+
+	* src/display.c (meta_display_open): intialize
+	display->autoraise_window too, (meta_display_close): remove any
+	pending autoraise callback, (window_raise_with_delay_callback):
+	clear out auto_raise->display->autoraise_window too,
+	(event_callback): call meta_display_queue_autoraise_callback
+	instead of having the code inline, call
+	meta_display_focus_the_no_focus_window to handle focusing that
+	window
+
+	* src/window.c (meta_window_focus): If there's a window with an
+	autoraise timeout that isn't the window being focused, remove the
+	autoraise timeout
+
+	* src/workspace.c (meta_workspace_focus_default_window): If no
+	autoraise timeout is queued for the given window then queue one
+	now, call meta_display_focus_the_no_focus_window to handle
+	focusing that window, (meta_workspace_focus_mru_window): call
+	meta_display_focus_the_no_focus_window to handle focusing that
+	window
+
+2004-10-04  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c (event_callback): When no window becomes focused,
+	focus the default window instead of punting to the
+	no_focus_window.  Also, change the warning to a verbose
+	message--this will happen frequently due to brain-damage in the X
+	protocol.  (see #125492)
+
+2004-10-04  Elijah Newren  <newren@math.utah.edu>
+
+	Fix a variety of focus race conditions in all focus modes, or at
+	least make them harder to trigger (fixes #152000)
+
+	* src/core.[ch] (meta_core_user_lower_and_unfocus): add a
+	timestamp parameter; pass it along to
+	meta_workspace_focus_default_window
+
+	* src/display.[ch] (meta_display_get_current_time_roundtrip): new
+	function
+
+	* src/display.c (event_callback): pass a timestamp to the
+	meta_workspace_activate and meta_workspace_focus_default_window
+	function calls
+
+	* src/frames.c (meta_frames_button_press_event): pass a timestamp
+	to meta_core_user_lower_and_unfocus
+
+	* src/keybindings.c (handle_activate_workspace): pass a timestamp
+	to meta_workspace_activate, (process_workspace_switch_grab): pass
+	a timestamp to meta_workspace_focus_default_window and
+	meta_workspace_activate, (handle_toggle_desktop): pass a timestamp
+	to meta_workspace_focus_default_window,
+	(do_handle_move_to_workspace): pass a timestamp to
+	meta_workspace_activate_with_focus, (handle_workspace_switch):
+	meta_workspace_activate
+
+	* src/screen.c (meta_screen_new): pass a timestamp to
+	meta_workspace_activate
+
+	* src/window.c (meta_window_free): pass a timestamp to
+	meta_workspace_focus_default_window, (idle_calc_showing): don't
+	increment the focus sentinel here, (meta_window_minimize): pass a
+	timestamp to meta_workspace_focus_default_window,
+	(meta_window_client_message), pass a timestamp to
+	meta_workspace_focus_default_window
+
+	* src/workspace.h (meta_workspace_activate): add timestamp
+	parameter, (meta_workspace_activate_with_focus): add timestamp
+	parameter, (meta_workspace_focus_default_window): add timestamp
+	parameter
+
+	* src/workspace.c (meta_workspace_focus_mru_window): make this
+	function take a timestamp and use it for meta_window_focus or
+	XSetInputFocus, (meta_workspace_activate_with_focus): make this
+	function take a timestamp and pass it along to meta_window_focus
+	and meta_workspace_focus_default_window,
+	(meta_workspace_activate): make this function take a timestamp and
+	pass it to meta_workspace_activate_with_focus),
+	(meta_workspace_focus_default_window): make this function take a
+	timestamp, warn if its 0 but try to handle that case sanely, and
+	pass the timestamp on to meta_window_focus or
+	meta_workspace_focus_mru_window or XSetInputFocus
+
+2004-09-22  Elijah Newren  <newren@math.utah.edu>
+
+	* src/keybindings.c (process_workspace_switch_grab): Focus the
+	default window after the user dismisses the workspace switcher
+	popup (fixes #123803; note that an alternate fix was made
+	independently by David Baron for sloppy and mouse focus users)
+
+2004-09-22  Elijah Newren  <newren@math.utah.edu>
+
+	Fix some uninitialized variable errors reported by valgrind (see
+	#153338)
+
+	* src/display.c (meta_display_open): initialize
+	display->grab_resize_timeout_id, and display->grab_have_keyboard
+
+	* src/ui.c (meta_ui_create_frame_window): initialize attrs.width
+	and attrs.height
+
+2004-09-17  Elijah Newren  <newren@math.utah.edu>
+
+	* src/workspace.c (meta_workspace_focus_mru_window): Don't focus a
+	window that is minimized (fixes #147947)
+
+2004-09-17  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* src/bell.c: (meta_bell_flash_screen):
+	* src/compositor.c:
+	* src/effects.c: (meta_effects_draw_box_animation):
+	* src/fixedtip.c: (meta_fixed_tip_show):
+	* src/frame.c: (find_argb_visual):
+	* src/frames.c: (unsigned_long_hash), (meta_frames_manage_window),
+	(meta_frames_apply_shapes):
+	* src/iconcache.c: (find_largest_sizes), (find_best_size):
+	* src/keybindings.c: (meta_spawn_command_line_async_on_screen):
+	* src/main.c: (main):
+	* src/menu.c: (meta_window_menu_new):
+	* src/prefs.c: (meta_prefs_get_visual_bell),
+	(meta_prefs_bell_is_audible), (meta_prefs_get_visual_bell_type),
+	(meta_prefs_get_action_double_click_titlebar),
+	(meta_prefs_get_auto_raise), (meta_prefs_get_auto_raise_delay),
+	(meta_prefs_get_reduced_resources):
+	* src/screen.c: (meta_create_offscreen_window):
+	* src/tabpopup.c: (meta_ui_tab_popup_get_selected):
+	* src/theme-parser.c: (meta_theme_load):
+	* src/theme.c: (meta_gtk_widget_get_font_desc):
+	* src/tools/metacity-mag.c: (mouse_press), (begin_area_grab):
+	* src/util.c: (meta_unsigned_long_hash): A load of fixes of issues
+	reported by sparse. Closes bug #152849
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c (event_callback): Remove some redundant code
+	regarding focusing the default window (#152117)
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Patch from Ken Harris in #135786 to focus a new default window
+	when lowering via middle-click on the frame.
+
+	* src/core.[hc], src/frames.c: rename meta_core_user_lower to
+	meta_core_user_lower_and_unfocus
+
+	* src/core.c (meta_core_user_lower_and_unfocus): if in
+	click-to-focus mode then also move the window to the back of the
+	mru list and focus the new default window for the active workspace
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Focus the no_focus_window if no suitable window is in the mru list
+	(should fix the almost contrived extra issue found in #147475)
+
+	* doc/how-to-get-focus-right.txt: We no longer need to lie about
+	only focusing panels upon explicit request.
+
+	* src/workspace.c: (meta_workspace_focus_top_window): removed this
+	function--it was more code than needed and was unreliable anyway,
+	(meta_workspace_focus_mru_window): if a suitable window isn't in
+	the mru list, focus the no_focus_window instead of calling
+	focus_top_window.
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Prevent focus inconsistencies by only providing one focus method
+	(fixes #151990)
+
+	* src/screen.c (meta_screen_show_desktop): remove call to
+	meta_workspace_focus_top_window (it was merely focusing a window
+	that was going to be hidden anyway, and likely the one that
+	already had focus)
+
+	* src/workspace.[hc]: remove meta_workspace_focus_mru_window and
+	meta_workspace_focus_top_window from workspace.h, make them static
+	functions in workspace.c
+	
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Remove race condition for focus window choice on window close
+	followed by rapid mouse movement in sloppy and mouse focus modes
+	(partially fixes #152000)
+
+	* src/window.c (meta_window_free): Don't increment the focus
+	sentinel for windows being freed, (idle_calc_showing): don't
+	increment the focus sentinel for windows being minimized
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Fix unwanted loss of focus to the mouse window when using keynav
+	(fixes #101190)
+
+	* src/display.c (event_callback): Ignore EnterNotify events with
+	xcrossing.mode of either NotifyGrab or NotifyUngrab
+
+2004-09-15  Elijah Newren  <newren@math.utah.edu>
+
+	Focus correct window after minimizing via the tasklist (fixes
+	#128200; see also #107681)
+
+	* src/display.h (struct _MetaDisplay): track the
+	previously_focused_window
+
+	* src/display.c (meta_display_open): initialize
+	previously_focused_window
+
+	* src/window.c (meta_window_free): clear the
+	previously_focused_window if it's being freed,
+	(meta_window_client_message): if we get a request to minimize the
+	previously_focused_window and the focus_window is a dock or the
+	desktop, focus the default window, (meta_window_notify_focus):
+	update the previously_focused_window
+
+2004-09-13  Rob Adams  <readams@readams.net>
+
+	* configure.in: post-release increment
+
+2004-09-13  Rob Adams  <readams@readams.net>
+
+	* configure.in: bump version number
+
+	* NEWS: 2.8.5 release
+
+	* README: 2.8.5 release
+
+2004-09-14  Gora Mohanty  <gmohanty@cvs.gnome.org>
+
+	* configure.in: Added 'or' to ALL_LINGUAS.
+   
+2004-09-07  Elijah Newren  <newren@math.utah.edu>
+
+	Add a new write-up on making window focus consistent (see #152004)
+
+	* doc/how-to-get-focus-right.txt: New document
+
+	* rationales.txt: Remove references to focus bugs, instead point
+	to doc/how-to-get-focus-right.txt
+
+2004-09-06  Elijah Newren  <newren@math.utah.edu>
+
+	* rationales.txt: Add bugs regarding window focus
+
+2004-08-29  Elijah Newren  <newren@math.utah.edu>
+
+	* NEWS: 2.8.4 release
+
+2004-08-29  Elijah Newren  <newren@math.utah.edu>
+
+	* src/window.c (window_takes_focus_on_map): Disable
+	focus-stealing-prevention for now; there are still some issues and
+	hard code freeze is tomorrow...so this will have to wait until
+	Gnome 2.10.
+
+2004-08-27  Havoc Pennington  <hp@redhat.com>
+
+	* src/compositor.c (meta_compositor_new): disable NameWindowPixmap
+	stuff always for now, it seemed kind of busted
+	(paint_screen): don't grab the server during repaint, adds to the
+	speed, though only slightly.
+
+	* src/frames.c (meta_frames_set_window_background): factor out all
+	the set_background stuff to one function; disable setting
+	background to transparent, because it breaks existing themes. We
+	need to add a flag in the theme XML file to say "start me with a
+	transparent background"
+
+2004-08-27  Elijah Newren  <newren@math.utah.edu>
+
+	Prevent an assertion failure that can occur after increasing the
+	number of workspaces; also fix a warning and stacking order when a
+	window is denied focus (fixes #150615)
+
+	* src/window.c (meta_window_stack_just_below): the position of the
+	window should be set equal to that of the one we want to be below,
+	not 1 lower than that number
+
+	* src/workspace.c (maybe_add_to_list): new function to add
+	on_all_workspace windows to an mru_list, (meta_workspace_new):
+	call maybe_add_to_list for all windows on the screen in order to
+	initialize the mru_list
+
+2004-08-26  Havoc Pennington  <hp@redhat.com>
+
+	* src/frame.c: delete extra copy of find_argb_visual so things
+	compile
+
+	* src/compositor.c (HAS_NAME_WINDOW_PIXMAP): copy the
+	XCompositeNameWindowPixmap() stuff from xcompmgr, though I can't
+	say I really know what it's supposed to help with (painting the
+	window border?)
+
+2004-08-26  Havoc Pennington  <hp@redhat.com>
+
+	* src/frame.c, src/theme.c: couple of cosmetic tweaks from
+	resolving my local patch with the bugzilla patch from the 8-19
+	entry below
+
+2004-08-26  Havoc Pennington  <hp@redhat.com>
+
+	* configure.in: move the have_xrender variable initialization up
+	in the file since it can be set as part of composite check
+
+2004-08-19  Havoc Pennington  <hp@redhat.com>
+
+	Fixes from Rich Wareham
+
+	* src/display.h (struct _MetaDisplay): add render extension check
+	to the display
+
+	* src/display.c: check for render
+
+	* configure.in: don't build compositing manager by default, don't
+	want any nasty surprises; check for render separately from
+	compositing manager
+
+	* src/frame.c: use an ARGB visual when available for the window 
+	frame, so we can be all cool-ass
+
+2004-08-25  Elijah Newren  <newren@math.utah.edu>
+
+	Make dialogs that Metacity shows follow focus-stealing-prevention
+	conventions. (fixes one issue in #149028; see comments 47-54)
+
+	* src/delete.c (delete_ping_reply_func,
+	delete_ping_timeout_func): Make callback functions take a
+	timestamp arg, (delete_ping_timeout_func): pass the timestamp to
+	metacity-dialog
+
+	* src/display.c (meta_display_ping_timeout): add a timestamp to
+	the call to the ping_timeout_func, (meta_display_ping_window,
+	process_pong_message): add a timestamp to the call to the
+	ping_reply_func
+
+	* src/display.h (MetaWindowPingFunc typedef): add a timestamp to
+	this function typedef
+
+	* src/keybindings.c (error_on_command): require a timestamp and
+	pass the timestamp on to metacity-dialog, (handle_run_command):
+	pass a timestamp to error_on_command
+
+	* src/metacity-dialog.c (copy_of_gdk_x11_window_set_user_time):
+	new function (temporary; only for use while using gtk+-2.4),
+	(kill_window_question, warn_about_no_sm_support,
+	error_about_command): make these functions take a timestamp and
+	call copy_of_gdk_x11_window_set_user_time, (main): require the
+	first two args to the program to be "--timestamp <timestamp>"
+
+	* src/session.c (warn_about_lame_clients_and_finish_inter): pass a
+	timestamp of 0 to metacity-dialog to prevent focus (it's a popup
+	not generated by and kind of user request).
+
+Fri Aug 20 12:54:12 2004  Soeren Sandmann  <sandmann@daimi.au.dk>
+
+	* src/display.c (meta_display_end_grab_op): Move wireframe code
+	before grab is released to prevent endless loops with fullscreen
+	windows.
+
+2004-08-18  Havoc Pennington  <hp@redhat.com>
+
+	* src/display.h (struct _MetaDisplay): track the last_xor_rect
+	separately from the current window size, and then use that to 
+	paint the wireframe including the frame, and taking into 
+	account shaded windows.
+
+	* src/window.c (meta_window_get_xor_rect): new function to compute
+	the xor rect; it is not really 100% right, because it uses the
+	frame dimensions from the window at the start of the move/resize.
+	But probably won't break in practice.
+
+2004-08-17  Christian Rose  <menthos@menthos.com>
+
+	* configure.in: Added "bs" to ALL_LINGUAS.
+
+2004-08-16  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* configure.in: Added nb to ALL_LINGUAS.
+
+2004-08-15  Rob Adams  <readams@readams.net>
+
+	* configure.in: Bump version to 2.8.4
+
+2004-08-15  Rob Adams  <readams@readams.net>
+
+	* NEWS: 2.8.3 release
+
+2004-08-15  Rob Adams  <readams@readams.net>
+
+	* src/windows.c (meta_window_update_struts): use height and
+	top/bottom struts to compute gap (copy/paste bug).
+
+2004-08-15  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_update_struts): Allow struts larger
+	than 1/2 the screen width/height, as long as there's a minimum
+	sized gap between them.  Patch from Bill Haneman <billh@gnome.org>
+	for bug #144126.
+	
+2004-08-13 Gurban M. Tewekgeli  <gmtavakkoli@yahoo.com>
+	* po/tk.po: Added Turkmen translation.
+	* configure.in: Added "tk" to ALL_LINGUAS.
+
+Mon Aug  9 05:38:33 2004  Soeren Sandmann  <sandmann@daimi.au.dk>
+
+	* src/effects.c (graphics_sync): New function. 
+	* src/effects.c (effects_draw_box_animation_timeout): Use it here
+	to synchronize with the hardware between each frame.
+
+2004-08-08  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_move_resize_internal): Add #ifdef
+	around XSYNC code; fixes compile problem if XSYNC is disabled.
+	Path for #149314 from Peter O'Shea and independently Mike Castle.
+
+Sun Aug  8 14:20:00 2004  Soeren Sandmann  <sandmann@daimi.au.dk>
+
+	* src/frame.c (meta_frame_set_screen_cursor): Flush after setting
+	cursor. (Rest of #149413).
+
+2004-08-07  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c (event_callback): activating the current workspace
+	should be a no-op.  This prevents a race condition in focus window
+	choice when activating a window via the taskbar.  Fix for #149589.
+
+2004-08-07  Elijah Newren  <newren@math.utah.edu>
+
+	* src/window.c, src/window.h: Revert Rob's 2004-07-31 patch that
+	ignored net_wm_user_time when unminimizing a window
+
+	* src/window.c (meta_window_activate): If a nonzero timestamp is
+	passed, update the window's net_wm_user_time accordingly.  (see
+	comments 102-108 of bug 118372)
+
+2004-08-07  Rob Adams  <readams@readams.net>
+
+	Remove some extraneous items that could sometimes appear in the
+	window menu.  Fix for #144493.
+	
+	* src/menu.c (menuitems): Change the second separator to key on
+	whether there are any workspaces.
+	(meta_window_menu_new): use NULL label instead of 0 op to identify
+	separator
+
+	* src/window.c (meta_window_show_menu): Change the conditions on
+	the directions to take into account "holes" in the workspace
+	layout and also only set META_MENU_OP_WORKSPACES when there's more
+	than one workspace.
+	
+2004-08-07  Havoc Pennington  <hp@redhat.com>
+
+	* src/screen.c (meta_screen_set_cursor): add XFlush() after
+	setting cursor, #149413
+
+2004-08-06  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c (event_callback): Focusing a window upon unshowing
+	the desktop in various ways (panel applet or keybinding) was
+	inconsistent for sloppy and click focus modes.  Fix this by
+	calling meta_workspace_focus_default_window after unshowing the
+	desktop via a _NET_SHOWING_DESKTOP message.  (resolves #149543)
+
+2004-08-06  Elijah Newren  <newren@math.utah.edu>
+
+	* src/workspace.c (meta_workspace_focus_default_window): prevent
+	keyboard from "getting locked" upon workspace switch, by making
+	sure that the no_focus_window has focus if no other window does.
+	(fixes #147475)
+
+2004-08-05  Elijah Newren  <newren@math.utah.edu>
+
+	Have newly mapped windows that are denied focus appear after the
+	focused window in the alt-tab list.  This allows one to switch to
+	such a window with a single alt-tab press.  (fixes #149366)
+	
+	* src/window.c (ensure_mru_position_after): new function,
+	(meta_window_show): If newly mapped window is denied focus, call
+	ensure_mru_position_after to make the window appear after the
+	focus window in the mru list.
+
+2004-08-05  Elijah Newren  <newren@math.utah.edu>
+
+	* src/window.c (meta_window_stick): prepend window to mru list
+	instead of appending, since making the window sticky should imply
+	that it is the most recently used, not the least recently.  (fixes
+	#149369)
+
+2004-08-04  Elijah Newren  <newren@math.utah.edu>
+
+	* configure.in: post-release version bump (2.8.3) that I forgot to
+	do yesterday.
+
+2004-08-03  Elijah Newren  <newren@math.utah.edu>
+
+	Released 2.8.2
+
+	* NEWS, README: update
+
+2004-08-02  Elijah Newren  <newren@math.utah.edu>
+
+	Fix some bugs (reported in #120100) regarding the focus window
+	when using the workspace switcher.
+	
+	* src/display.c (event_callback): When switching workspaces due to
+	a _NET_CURRENT_DESKTOP message, make sure to focus the default
+	window as well.
+
+	* src/workspace.c (meta_workspace_focus_default_window,
+	meta_workspace_focus_mru_window): Make DOCK or DESKTOP windows
+	have lower priority than others when choosing a window to focus.
+	(For the former function, this means don't focus them at all; for
+	the latter, this means only focus them (via the
+	meta_workspace_focus_top_window call) if no other mru window can
+	be found.)
+
+2004-07-31  Rob Adams  <readams@readams.net>
+
+	Fix bug that caused windows to not be focused on unminimizing
+	because of user time support.
+	
+	* src/window.c (meta_window_new_with_attrs): initialize
+	focus_despite_user_time bit
+	(window_takes_focus_on_map): focus if focus_despite_user_time
+	despite user time, interestingly enough
+	(meta_window_show): reset focus_despite_user_time after showing
+
+	* src/window.h (_MetaWindow): add focus_despite_user_time bit
+
+2004-07-31  Rob Adams  <readams@readams.net>
+
+	Fix some support for EWMH hints, and fix USER_TIME support to
+	include the DEMANDS_ATTENTION hint.  Also includes some code for
+	implementing _NET_RESTACK_WINDOW and _NET_MOVERESIZE_WINDOW, but
+	this is disabled pending feature thaw.
+	
+	* COMPLIANCE: update with new information
+
+	* src/display.c (meta_display_open): add new hints to list
+
+	* src/display.h (_MetaDisplay): Add new atoms to struct
+
+	* src/screen.c (set_supported_hint): update the list of support
+	hints.
+	(set_desktop_viewport_hint): new function sets the viewport hint
+	to (0,0) as required by the spec for WMs with no viewport support.
+	(set_desktop_geometry_hint): new function to set the desktop size
+	hint to the size of the display, since we don't implement large
+	desktop support, as required by the spec.
+	(meta_screen_resize): update the geometry hint on screen resize
+
+	* src/window.c (meta_window_new_with_attrs): Initialize
+	demands_attention state
+	(set_net_wm_state): Set demands_attention hint in the window state
+	(meta_window_show): If we don't pop up a window because of
+	USER_TIME, set DEMANDS_ATTENTION on the window.
+	(meta_window_focus): When a window receives focus, remove
+	DEMANDS_ATTENTION hint
+	(meta_window_client_message): Allow other apps to set
+	DEMANDS_ATTENTION on a window.  Also, if the _NET_ACTIVE_WINDOW
+	hint includes a timestamp, use it.
+	(update_net_wm_state): Read DEMANDS_ATTENTION state also
+
+	* src/window.h (_MetaWindow): add wm_state_demands_attention bit.
+	
+2004-07-22  Rob Adams  <readams@readams.net>
+
+	* src/metacity.schemas.in: Add trailing quotes to keybinding
+	explanation text.  Patch from Emil Soleyman-Zomalan.
+
+Fri Jun 25 17:41:53 2004  Soeren Sandmann  <sandmann@daimi.au.dk>
+
+	* configure.in: Require startup-notification 0.7
+
+2004-06-25  Rob Adams  <readams@readams.net>
+
+	* COMPLIANCE: indicate that _NET_WM_USER_TIME is now supported
+
+2004-06-24  Elijah Newren  <newren@math.utah.edu>
+
+	* src/keybindings.c: (handle_toggle_desktop): Choose correct
+	window to focus when "un-showing" the desktop.  Fixes #144900.
+
+2004-06-24  Elijah Newren  <newren@math.utah.edu>
+
+	Make choice of focus window be consistent for each focus mode.
+	Fixes #135810.
+
+	* src/delete.c: (meta_window_delete): In some #if 0'ed code,
+	replace meta_workspace_focus_mru_window with
+	meta_workspace_focus_default_window (just in case the code becomes
+	un-#if 0'ed out).
+
+	* src/screen.c, src/screen.h: Change
+	meta_screen_focus_mouse_window to meta_screen_get_mouse_window,
+	and don't focus the window when found but rather return it.
+
+	* src/window.c: (meta_window_free, meta_window_minimize): replace
+	meta_workspace_focus_mru_window with
+	meta_workspace_focus_default_window.
+
+	* src/workspace.c: (meta_workspace_focus_default_window): Focus
+	appropriately for the given focus method:
+	   click-to-focus: focus MRU window (== toplevel window)
+	   sloppy focus:   focus the window under the pointer if there is
+	                   such a window, otherwise focus the mru window
+	   mouse focus:    focus the window under the pointer if there is
+	                   such a window, otherwise don't focus anything
+
+2004-06-24  Elijah Newren  <newren@math.utah.edu>
+
+	* src/window.c: Avoid a race condition on the choice of window to
+	focus after the previously focused window gets closed or
+	minimized.  Fixes #131582.
+
+2004-06-24  Elijah Newren  <newren@math.utah.edu>
+
+	* src/metacity.schemas.in: make naming for "move a window"/"move
+	the window"/"move window" more consistent.  Patch from Michael
+	Terry for #142235.
+
+2004-06-24  Elijah Newren  <newren@math.utah.edu>
+
+	* src/session.c: Change meta_warning to meta_topic on failure to
+	connect to a session manager.  Fixes #136218.
+
+2004-06-17  Elijah Newren  <newren@math.utah.edu>
+
+	Add support for _NET_WM_USER_TIME
+	
+	* src/display.c:
+	(meta_display_open): Add _NET_WM_USER_TIME to atom_names[],
+	(event_callback): Manually set _NET_WM_USER_TIME upon KeyPress
+	(doesn't work since keyboard isn't grabbed) and ButtonPress (does
+	work), this is just a fallback for applications that don't update
+	this themselves.
+
+	* src/display.h: (struct _MetaDisplay): Add atom_net_wm_user_time field
+	
+	* src/screen.c: (meta_screen_apply_startup_properties): Check for
+	TIMESTAMP provided from startup sequence as well.
+	
+	* src/stack.c: 
+	s/meta_window_set_stack_position/meta_window_set_stack_position_no_sync/,
+	(meta_window_set_stack_position): New function which calls the
+	meta_window_set_stack_position_no_sync function followed immediately
+	by calling meta_stack_sync_to_server.
+
+	* src/window-props.c: 
+	(init_net_wm_user_time), (reload_net_wm_user_time): new functions,
+	(reload_wm_hints): also load atom_net_wm_user_time
+	
+	* src/window.c:
+	new XSERVER_TIME_IS_LATER macro (accounts for timestamp wraparound),
+	(meta_window_new_with_attrs): add timestamp attributes,
+	(window_takes_focus_on_map): use TIMESTAMP from startup
+	notification and _NET_WM_USER_TIME to decide whether to focus new
+	windows,
+	(meta_window_show): if app doesn't take focus on map, place it
+	just below the focused window in the stack
+	(process_property_notify): check for changes to _NET_WM_USRE_TIME,
+	(meta_window_stack_just_below): new function
+	
+	* src/window.h:
+	(_MetaWindow struct): new fields for initial_timestamp,
+	initial_timestamp_set, net_wm_user_time_set, and net_wm_user_time,
+	(meta_window_stack_just_below): new function
+
+2004-06-21  Anders Carlsson  <andersca@gnome.org>
+
+	* src/common.h:
+	* src/menu.c: (menu_closed), (activate_cb):
+	* src/window.c: (menu_callback):
+	Add a timestamp argument to menu functions and
+	use it in meta_window_delete.
+	
+2004-06-21  Anders Carlsson  <andersca@gnome.org>
+
+	* src/window.c: (meta_window_client_message):
+	Get the timestamp from the client message.
+
+Sat Jun 19 02:21:08 2004  Soeren Sandmann  <sandmann@daimi.au.dk>
+
+	Fix bug 143333, support for update counter spec, and 109362,
+	schedule compensation events when events are ignored.
+	
+	* src/display.c (meta_display_open): Add _NET_WM_SYNC_REQUEST and
+	_NET_WM_SYNC_REQUEST_COUNTER atoms. Remove the old
+	METACITY_SYNC_COUNTER stuff.
+	(meta_display_begin_op): Setup the sync counter
+
+	* src/xprops.c, src/xprops.h, src/window-props.c, src/display.h:
+	Add new atoms.
+	
+	* src/window.c (send_sync_request): new function.
+	(meta_window_move_resize_internal): send a sync request before
+	resizing.
+	(check_move_resize_frequence): Rework logic to also check the SYNC
+	case. If an event is ignored return the remaining time.
+	(update_resize_timeout): Timeout that gets called when a
+	compensation event is scheduled.
+	(uddate_resize): schedule compensation events when an event is
+	ignored.
+	(meta_window_handle_mouse_grap_op_event): When an alarm is
+	received and sync was turned off, turn it back on.
+	
+	* src/window.h (struct MetaWindow)  Add some variables
+
+2004-06-16  Havoc Pennington  <hp@redhat.com>
+
+	* configure.in: bump version, add the UNSTABLE note
+
+	* Branch off GNOME 2.6, we are now officially unstable
+
+2004-06-04  Jeff Waugh  <jdub@perkypants.org>
+
+	* src/metacity.schemas.in: Set titlebar_uses_system_font = false. The
+	previous default was almost violent in its lack of appreciation for
+	human beings. In fact, this entire setting should probably be removed, but
+	for now, let's just fix the default. Permission granted by Havoc.
+
 2004-05-04  Elijah Newren  <newren@math.utah.edu>
 
 	* configure.in: 2.8.1

NEWS

@@ -1,3 +1,137 @@
+2.8.6
+==
+
+This is a stable release for Gnome 2.8.1.
+
+Thanks to the Ken Harris, Kjartan Maraas, and the tireless efforts of
+Elijah Newren for fixes in this release.
+
+Fixes
+  * Ensure the correct window is focused when minimizing (Elijah)
+  * Fix keynav with mouse focus (Elijah)
+  * Fix several race conditions in window focusing (Elijah)
+  * Focus the top window when lowering by frame click (Ken)
+  * Fix some compiler warnings (Kjartan)
+  * Fix some valgrind-reported errors (Elijah)
+  * Fix some potential issues with autoraising windows (Elijah)
+
+Translations
+  * en_CA(Adam Weinberger), it(Luca Ferretti)
+
+2.8.5
+==
+
+This is a stable release for Gnome 2.8.  Only translations and some
+new developer documentation were added since the last unstable release.
+This release boasts improved standards-compliance and a number of 
+bug fixes since the last stable release.
+
+Translations
+
+  * ar(Abdulaziz Al-Arfaj), cs(Miloslav Trmac), cy(Dafydd Harries),
+    en_GB(David Lodge), fr(Christophe Merlet (RedFox)), 
+    nn(<28>smund Skj<6B>veland), or(Gora Mohanty), 
+    pr_BR(Gustavo Noronha Silva), ro(Mugurel Tudor), 
+    th(Paisa Seeluangsawat), tr(Baris Cicek), zh_TW(Woodman Tuen)
+
+2.8.4
+==
+
+This release features a number of bug fixes, and also the disabling of
+the focus-stealing-prevention code (we're entering hard code freeze in
+Gnome so it's too late to fix the remaining issues, especially since
+it requires several patches to modules other than Metacity).
+
+Thanks to Havoc Pennington, Soeren Sandmann, Elijah Newren, and Rich
+Wareham for fixes in this release
+
+Fixes
+  * track the last_xor_rect, for wireframe painting (Havoc)
+  * Move wireframe code before grab is released to prevent endless
+    loops with fullscreen windows. (Soeren)
+  * Make dialogs that Metacity shows follow focus-stealing-prevention
+    conventions. (Elijah; part of #149028)
+  * add render extension check to the display, don't build the
+    compositing manager by default, use an ARGB visual when available
+    for the window frame (Rich Wareham; various tweaks added later by
+    Havoc)
+  * move the have_xrender variable initialization up in the file since
+    it can be set as part of composite check (Havoc)
+  * make argb stuff compile, add some code from xcompmgr (Havoc)
+  * fix an assertion failure that would occur after increasing the
+    number of workspaces; fix stacking order when a window is denied
+    focus (Elijah; #150615)
+  * disable some compositor code that wasn't working, don't grab the
+    server during repaint, various set_background fixes and
+    refactoring (Havoc)
+
+Translations
+  * az(Metin Amiroff), bs(Kemal Sanjta), ca(Jordi Mallach), 
+    el(Kostas Papadimas), es(Francisco Javier F. Serrador), 
+    eu(I<><49>aki Larra<72><61>aga Murgoitio), fi(Pauli Virtanen),
+    nb(Kjartan Maraas), sq(Laurent Dhima), uk(Maxim Dziumanenko)
+
+
+2.8.3
+==
+
+Some important bug fixes in this release, including somy a11y bugs,
+and a compile issue on Solaris.
+
+Thanks to Rob Adams, Bill Haneman, Peter O'Shea, Mike Castle, Soeren
+Sandman, Elijah Newren, and Havoc Pennington for fixes in this
+release.
+
+Fixes
+  * Adjust the MRU list when preventing focus stealing (Elijah)
+  * Ensure that we maintain a focus window when switching workspaces
+    in mouse focus mode (Elijah)
+  * Some improvements in the showing desktop mode, and window
+    activation (Elijah)
+  * Make sure cursors changes are handled correctly (Havoc, Soeren)
+  * Some fixes to the window menu (Rob)
+  * Fix a compile issue on Solaris (Peter, Mike)
+  * Allow struts to go past the middle of the screen, provided there's
+    a gap between them, fixing an issue with gnome magnifier (Bill)
+
+Translations
+  * fi (Pauli Virtanen), ja (Takeshi AIHANA), ko (Young-Ho, Cha), 
+    pl (Gnome PL Team), ru (Dmitry G. Mastrukov), sr (Danilo <20>Ł<EFBFBD>egan),
+    tk (Gurban M. Tewekgeli), zh_CN (Funda Wang)
+
+2.8.2
+===
+
+Many bugfixes and better support for the freedesktop.org EWMH spec.
+
+Thanks to Rob Adams, Anders Carlsson, Elijah Newren, Soeren Sandmann,
+Emil Soleyman-Zomalan, Michael Terry, and Jeff Waugh for fixes in this
+release.
+
+  - set titlebar_uses_system_font = false (it was ugly)
+  - make naming for "move a window"/"move the window"/"move window"
+    more consistent (fixes #142235)
+  - Add trailing quotes to keybinding explanation text.
+  - support for EWMH update counter spec & add compensation events
+    when events are ignored. (fixes #143333 and #109362)
+  - Fix focus bugs: remove race condition on window close/minimize
+    (#131582), make focus choice consistent for each focus mode
+    (#135810), choose correct focus window when "un-showing the
+    desktop (#144900), make sure correct window is focused when using
+    the workspace switcher (#120100).
+  - Use meta_topic instead of meta_warning when failing to connect to
+    a session manager; reduces metacity verbosity. (fixes #136218)
+  - Make meta_window_delete take a timestamp, and be sure to pass it
+    one.
+  - Add support for EWMH _NET_WM_USER_TIME spec.  This enables part of
+    preventing focus stealing.  (bug #118372) Also fix bug with
+    windows not being focused on unminimizing caused by original
+    patch.  (also bug #118372)
+  - Fix some support for EWMH hints, and fix USER_TIME support to
+    include the DEMANDS_ATTENTION hint.  Also includes some code for
+    implementing _NET_RESTACK_WINDOW and _NET_MOVERESIZE_WINDOW, but
+    this is disabled pending feature thaw.
+
 2.8.1
 ===
 

README

@@ -6,9 +6,9 @@ on UNIX keyboards.
 The first release of Metacity was version 2.3. Metacity has no need for
 your petty hangups about version numbers.
 
-The stable releases so far are 2.4.x, 2.6.x, 2.8.x
+The stable releases so far are 2.4.x, 2.6.x, 2.8.0, 2.8.1, 2.8.1.x, 2.8.5-6
 
-Unstable branches are 2.3.x, 2.5.x
+Unstable branches are 2.3.x, 2.5.x, 2.8.2-4)
 
 COMPILING METACITY
 ===

configure.in

@@ -3,9 +3,10 @@ AC_INIT(src/display.c)
 
 AM_CONFIG_HEADER(config.h)
 
-# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 
-# releases on a branch add a 4th version like 2.4.21.1
-AM_INIT_AUTOMAKE(metacity, 2.8.1)
+# we'll hold the 2.8.x versioning for GNOME 2.8, it was also used
+# for GNOME 2.6, then after GNOME 2.8 we'll have the numbers synced
+# with GNOME
+AM_INIT_AUTOMAKE(metacity, 2.8.6)
 
 # Honor aclocal flags
 ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"
@@ -129,12 +130,14 @@ AC_ARG_ENABLE(compositor,   [  --disable-compositor             disable metacity
 
 AC_ARG_ENABLE(xsync,       [  --disable-xsync             disable metacity's use of the XSync extension],,enable_xsync=auto)
 
+AC_ARG_ENABLE(render,       [  --disable-render             disable metacity's use of the RENDER extension],,enable_render=auto)
+
 AC_ARG_ENABLE(shape,       [  --disable-shape             disable metacity's use of the shaped window extension],,enable_shape=auto)
 
 ## try definining HAVE_BACKTRACE
 AC_CHECK_HEADERS(execinfo.h, [AC_CHECK_FUNCS(backtrace)])
 
-ALL_LINGUAS="am ar az be bg bn ca cs cy da de el en_CA en_GB es et eu fa fi fr ga gl gu he hi hr hu id is it ja ko lt lv mk ml mn ms nl nn no pa pl pt pt_BR ro ru sl sk sq sr sr@Latn sv ta th tr uk vi wa zh_CN zh_TW"
+ALL_LINGUAS="am ar az be bg bn bs ca cs cy da de el en_CA en_GB es et eu fa fi fr ga gl gu he hi hr hu id is it ja ko lt lv mk ml mn ms nb nl nn no or pa pl pt pt_BR ro ru sl sk sq sr sr@Latn sv ta th tk tr uk vi wa zh_CN zh_TW"
 AM_GLIB_GNU_GETTEXT
 
 ## here we get the flags we'll actually use
@@ -151,7 +154,7 @@ else
    AC_MSG_ERROR("Pango 1.2.0 or greater based on Xft2 is required")
 fi
 
-STARTUP_NOTIFICATION_VERSION=0.4
+STARTUP_NOTIFICATION_VERSION=0.7
 AC_MSG_CHECKING([Startup notification library >= $STARTUP_NOTIFICATION_VERSION])
 if $PKG_CONFIG --atleast-version $STARTUP_NOTIFICATION_VERSION libstartup-notification-1.0; then
    have_startup_notification=yes
@@ -177,6 +180,10 @@ else
   echo "Building without libstartup-notification"
 fi
 
+## init this, it gets set either in the compositor check below 
+## or the render-specific check later
+have_xrender=no
+
 XCOMPOSITE_VERSION=1.0
 AC_MSG_CHECKING([Xcomposite >= $XCOMPOSITE_VERSION])
 if $PKG_CONFIG --atleast-version $XCOMPOSITE_VERSION xcomposite; then
@@ -190,7 +197,8 @@ if test x$enable_compositor = xyes; then
    have_xcomposite=yes
    echo "CompositeExt support forced on"
 elif test x$enable_compositor = xauto; then
-   true
+   echo "Not building compositing manager by default now, must enable explicitly to get it. And it doesn't work, so don't bother unless you want to hack on it..."
+   have_xcomposite=no
 else
    have_xcomposite=no
 fi
@@ -199,10 +207,43 @@ if test x$have_xcomposite = xyes; then
   echo "Building with CompositeExt"
   METACITY_PC_MODULES="$METACITY_PC_MODULES xcomposite >= $XCOMPOSITE_VERSION xfixes xrender xdamage"
   AC_DEFINE(HAVE_COMPOSITE_EXTENSIONS, , [Building with compositing manager support])
+
+  ## force on render also
+  have_xrender=yes
 else
   echo "Building without compositing manager"
 fi
 
+## if no compositor, still possibly enable render
+if test x$have_xcomposite = xno; then
+  XRENDER_VERSION=0.0
+  AC_MSG_CHECKING([xrender >= $XRENDER_VERSION])
+  if $PKG_CONFIG --atleast-version $XRENDER_VERSION xrender; then
+     have_xrender=yes
+  else
+     have_xrender=no
+  fi
+  AC_MSG_RESULT($have_xrender)
+
+  if test x$enable_render = xyes; then
+     have_xrender=yes
+     echo "Render support forced on"
+  elif test x$enable_render = xauto; then
+     true
+  else
+     have_xrender=no
+  fi
+
+  if test x$have_xrender = xyes; then
+     echo "Building with Render"
+     METACITY_PC_MODULES="$METACITY_PC_MODULES xrender >= $XRENDER_VERSION"
+  fi
+fi ## have_composite
+
+if test x$have_xrender = xyes; then
+  AC_DEFINE(HAVE_RENDER, , [Building with Render extension support])
+fi
+
 PKG_CHECK_MODULES(METACITY, $METACITY_PC_MODULES)
 
 AC_PATH_XTRA
@@ -437,6 +478,7 @@ metacity-$VERSION:
 	Shape extension:          ${found_shape}
 	Resize-and-rotate:        ${found_randr}
 	Xsync:                    ${found_xsync}
+	Render:                   ${have_xrender}
         Deprecated config dialog: ${enable_config_dialog}
 "
-#echo "This is the UNSTABLE branch of metacity, use 2.8.x for stable (gnome-2-6 branch in CVS)"
+# echo "This is the UNSTABLE branch of metacity, use 2.8.1.x for stable (gnome-2-6 branch in CVS)"

doc/how-to-get-focus-right.txt

@@ -0,0 +1,196 @@
+To make choice of focus window consistent for each focus method, a
+number of guidelines should be followed.  (For purposes of discussion
+here, I'm excluding things like the panel and the desktop from
+"windows".  It is technically incorrect to do this, but I'm lazy and
+"windows" is shorter than something like "normal windows".  See the
+end of the discussion for how these special cases are handled.)  The
+basics are easy:
+
+Focus method  Behavior
+    click     When a user clicks on a window, focus it
+   sloppy     When an EnterNotify is received, focus the window
+    mouse     Same as sloppy, but also defocus on LeaveNotify
+
+Note that these choices (along with the choice that clicking on a
+window raises it for the click focus method) introduces the following
+invariants for focus from mouse activity:
+
+Focus method  Invariant
+    click     The window on top is focused
+   sloppy     If the mouse is in a window, then it is focused; if the
+              mouse is not in a window, then the most recently used
+              window is focused.
+    mouse     If the mouse is in a window, then it is focused; otherwise,
+              the designated "no_focus_window" is focused
+
+However, there are a number of cases where the current focus window
+becomes invalid and another should be chosen.  Some examples are when
+a focused window is closed or minimized, or when the user changes
+workspaces.  In these cases, there needs to be a rule consistent with
+the above about the new window to choose.
+
+Focus method  Behavior
+    click     Focus the most recently used window (same as the window
+              on top)
+   sloppy     Focus the window containing the pointer if there is such
+              a window, otherwise focus the most recently used window.
+    mouse     Focus the window containing the pointer if there is one,
+              otherwise focus the designated "no_focus_window".
+
+Also, sometimes a new window will be mapped (e.g. unminimizing a
+window or launching a new application).  Most users want to interact
+with new windows right away, so these should typically be focused.
+This does conflict with the invariants for sloppy and mouse focus
+modes, so this wouldn't be true for a strict-pointer-focus mode.  For
+all other modes (non-strict-pointer-focus modes), there are only two
+cases in which a new window shouldn't be focused:
+
+  1) If the window takes a while to launch and the user starts
+     interacting with a different application, the new window should
+     not take focus.
+  2) If the window that will appear was not launched by the user
+     (error dialogs, instant messaging windows, etc.), then the window
+     should not take focus when it appears.
+
+To handle these cases, Metacity compares timestamps of the event that
+caused the launch and the timestamp of the last interaction with the
+focused window.  (Case 2 is handled by providing a special timestamp
+of 0 for the launch time, which ensures that the window that appears
+doesn't get focus)
+
+If the newly launched window isn't focused, some things should be done
+to alert the user that there is a window to work with:
+  1) The _NET_WM_DEMANDS_ATTENTION hint should be set
+  2) If the new window isn't modal for the focused window, it should
+     appear below the focused window so that it doesn't obscure the
+     focused window that the user is interacting with.
+  3) If the new window is modal to the focused window, the currently
+     focused window should lose focus but the modal window should
+     appear on top.
+
+Additionally, the user may decide to use the keyboard instead of the mouse
+to navigate between windows (referred to as "keynav").  This poses no
+problems for click-to-focus (because the same invariant can be
+maintained), but for sloppy and mouse focus it means that EnterNotify
+and LeaveNotify events should be ignored (they can be generated
+without using the mouse, for example, by grabs).
+
+Finally, windows of type WM_DOCK or WM_DESKTOP (e.g. the desktop and
+the panel) present a special case.  For all focus modes, we only focus
+these windows if the user clicks on them or uses Ctrl-Alt-Tab to
+navigate to them.
+
+
+
+
+To read more about the bugs that inspired these choices:
+  - When a focused window becomes invalid and another should be chosen
+    http://bugzilla.gnome.org/show_bug.cgi?id=135810
+  - When a new window is mapped
+    http://bugzilla.gnome.org/show_bug.cgi?id=118372
+    Also, the EWMH spec, especially the parts relating to _NET_WM_USER_TIME
+  - Modal vs. non-modal dialogs that get denied focus when mapped
+    http://bugzilla.gnome.org/show_bug.cgi?id=151996
+  - Ignoring EnterNotify and LeaveNotify events during keynav
+    http://bugzilla.gnome.org/show_bug.cgi?id=101190
+  - Not focusing panels
+    http://bugzilla.gnome.org/show_bug.cgi?id=120100 (maybe a different bug?)
+
+There were many bugs which had to be fixed to get all the above
+working; they helped form these policies and/or show the difficulties
+in implementing this policy (my apologies in advance for producing a
+list heavily lopsided to what I've done; it's just that these bugs are
+the ones I'm the most familiar with):
+  bug  72314  ignore LeaveNotify events from grabs
+  bug  82921  focus windows on map
+  bug  87531  only show focus for sticky windows on active workspace (pager)
+  bug  94545  focus window on workspace switch is non-deterministic
+  bug  95747  should ignore EnterNotify events with NotifyInferior detail set
+  bug  97635  sticky windows always keep focus when switching workspaces
+  bug 102665  a window unminimized from the tasklist should be focused
+  bug 108643  focus in MRU order instead of stack order
+  bug 110970  moving a window to another workspace loses focus
+  bug 112031  closing a dialog can result in a strange focus window
+  bug 115650  add _NET_WM_USER_TIME support to gtk+ (see also 150502)
+  bug 120100  panel shouldn't be focused after workspace applet usage
+  bug 123803  need final EnterNotify after workspace switch (see also 124798)
+  bug 124981  focus clicked window in pager only if on current workspace
+  bug 128200  focus correct window on libwnck window minimize (see 107681 too)
+  bug 131582  fix race condition on window minimize/close
+  bug 133120  wrong window focused when changing workspaces
+  bug 135024  _NET_ACTIVE_WINDOW messages need timestamps
+  bug 135786  middle-clicking on focused window to lower it should defocus too
+  bug 136581  window minimization vs. activation for mouse focus
+  bug 144900  fix focus choice on "un-showing" the desktop
+  bug 147475  don't lock keyboard on workspace change
+  bug 148364  DEMANDS_ATTENTION support for metacity & libwnck (and other stuff)
+  bug 149028  focus-stealing-prevention for metacity-dialog (and other stuff)
+  bug 149366  windows denied focus on map occur in wrong order in alt-tab list
+  bug 149543  consistent focus window when unshowing desktop
+  bug 149589  race in focus choice from libwnck messages
+  bug 150271  make sure "run application" dialog gets focused
+  bug 150668  update gtk+ _NET_ACTIVE_WINDOW support
+  bug 151245  application startup notification forwarding (partially rejected)
+  bug 151984  Soeren's idea--backup timestamp when startup notification not used
+  bug 151990  prevent focus inconsistencies by only providing one focus method
+  bug 151996  modal dialogs denied focus should not be lowered
+  bug 152000  fix race on window close followed by rapid mouse movement
+
+
+Addendum on sloppy and mouse focus
+  You may occasionally hear people refer to sloppy or mouse focus
+  modes as inherently buggy.  This is what they mean by that:
+
+  1) Keynav doesn't maintain the same invariants as mouse navigation
+     for these focus modes; switching back and forth between
+     navigation methods, therefore, may appear to have
+     inconsistencies.  Examples:
+     a) If the user uses Alt-Tab to change the window with focus, then
+        starts to move the mouse, at that moment the window where the
+        mouse is does not have focus.
+     b) Users expect that a workspace they previously used will not
+        change when the return to it.  This means things like window
+        position and stacking order, but also the focus window.
+        Unfortunately, using the original focus window (which would be
+        the most recently used window on that workspace) will
+        sometimes conflict with the invariants for mouse and sloppy
+        focus modes.  Users are much more surprised by the invariant
+        being broken than by having the focus window changed (see bug
+        94545 and probably others), so we maintain the invariant.
+        This only matters when using Ctrl-Alt-Arrow to switch
+        workspaces instead of clicking in the workspace switcher, so
+        this really is a keynav vs mouse issue.  Either that, or a
+        windows-are-being-mapped exception.  ;-)
+     c) Opening a menu, then moving the mouse to a different window,
+        and then pressing escape to dismiss the menu will result in
+        the window containing the mouse not being focused.  This is
+        actually correct behavior (because pressing escape shows that
+        the user is using key navigation to interact with the window
+        containing the menu) but is one of those hard-to-get-right
+        keynav and mouse focus mixture cases.  (See bug 101190 for
+        more details)
+  2) The sloppy/mouse invariants are often not strictly maintained;
+     for example, we provide an exception to the invariant for newly
+     mapped windows.  (Most find that not allowing this exception is
+     confusing)
+  3) There are an awful lot of little cases to handle to get any focus
+     mode right, even for click-to-focus.  Since mouse and sloppy
+     focus have sometimes been hard to even determine what correct
+     behavior is, it is much harder to get them completely right.
+     Plus mouse and sloppy focus users are a minority, decreasing the
+     motivation of window manager implementors to get those focus
+     modes right.
+  4) Because of -1-, -2-, and -3-, implementations are often buggy or
+     inconsistent and people form their opinions from usage of these
+     implementations.
+  5) Sloppy focus suffers from a bit of a discoverability problem (for
+     example, I have seen a scientist sit down to a computer for which
+     sloppy focus was in use and take a few minutes before figuring
+     out how window activation worked; granted the layout of the
+     windows in that situation was a bit unusual but it still
+     illustrates that sloppy focus is harder than it should be to
+     figure out).  Mouse focus solves this problem; however, people
+     that have experience with other computing environments are
+     accustomed to being able to move their mouse outside the window
+     they are working with and still continue interacting with that
+     window, which conflicts with mouse focus.

po/ChangeLog

@@ -1,3 +1,269 @@
+2004-09-26  Adam Weinberger  <adamw@gnome.org>
+
+	* en_CA.po: Updated Canadian English translation.
+
+2004-09-19  Alessio Frusciante  <algol@firenze.linux.it>
+
+	* it.po: Updated Italian translation by
+	Luca Ferretti <elle.uca@infinito.it>.
+
+2004-09-14  Gora Mohanty  <gmohanty@cvs.gnome.org>
+                                                                                
+        * or.po: Updated Oriya translation.
+    
+2004-09-12  Paisa Seeluangsawat  <paisa@users.sf.net>
+
+	* th.po: Updated Thai translation.
+
+2004-09-12  Dafydd Harries  <daf@muse.19inch.net>
+
+	* cy.po: Updated Welsh translation.
+
+2004-09-11  Abel Cheung  <maddog@linuxhall.org>
+
+	* zh_TW.po: Updated traditional Chinese translation by GNOME HK Team.
+
+2004-09-10  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2004-09-08  Abel Cheung  <maddog@linux.org.hk>
+
+	* zh_TW.po: Updated traditional Chinese translation by GNOME HK Team.
+
+2004-09-08  Raphael Higino  <raphaelh@cvs.gnome.org>
+
+	* pt_BR.po: Updated Brazilian Portuguese translation.
+
+2004-09-08  Arafat Medini  <lumina@arabeyes.org>
+
+	* ar.po: Updated Arabic translation
+
+2004-09-07  Mugurel Tudor  <mugurelu@go.ro>
+
+	* ro.po: Updated Romanian translation.
+
+2004-09-05  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Updated Czech translation.
+
+2004-09-03  Baris Cicek <baris@teamforce.name.tr>
+
+	* tr.po: Updated Turkish Translation
+	
+2004-08-31  Åsmund Skjæveland <aasmunds@fys.uio.no>
+
+	* nn.po: Updated Norwegian Nynorsk translation.
+
+2004-08-29  Kostas Papadimas <pkst@gnome.org>
+
+	* el.po: Updated  Greek translation.
+
+2004-08-28  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation.
+
+2004-08-26  Iñaki Larrañaga  <dooteo@euskalgnu.org>
+	
+	* eu.po:  Updated Basque translation.
+
+2004-08-23  Maxim Dziumanenko <mvd@mylinux.com.ua>
+
+	* uk.po: Updated Ukrainian translation.
+
+2004-08-21  Jordi Mallach  <jordi@sindominio.net>
+
+	* ca.po: Updated Catalan translation.
+
+2004-08-20  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-08-18  Pauli Virtanen  <pauli.virtanen@hut.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2004-08-18  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-08-17  Christian Rose  <menthos@menthos.com>
+
+	* bs.po: Added Bosnian translation by
+	Kemal Sanjta <gomez@lugzdk.ba>.
+
+2004-08-17  Metin Amiroff  <metin@karegen.com>
+
+	* az.po: Translation updated.
+
+2004-08-16  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* nb.po: Added this here.
+
+2004-08-15  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2004-08-13  Tommi Vainikainen  <thv@iki.fi>
+
+	* fi.po: Unified some fields in po headers for Finnish team.
+
+2004-08-13  Gurban M. Tewekgeli  <gmtavakkoli@yahoo.com>
+
+	* tk.po: Added Turkmen translation.
+
+2004-08-11  Dmitry G. Mastrukov  <dmitry@taurussoft.org>
+
+	* ru.po: Updated Russian translation
+	from Russian team <gnome-cyr@gnome.org>.
+
+2004-08-10  Artur Flinta  <aflinta@cvs.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2004-08-07  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2004-08-06  Funda Wang  <fundawang@linux.net.cn>
+
+	* zh_CN.po: Updated Simplified Chinese translation.
+
+2004-08-06  Takeshi AIHANA <aihana@gnome.gr.jp>
+
+	* ja.po: Updated Japanese translation.
+
+2004-08-03  Vincent van Adrighem  <adrighem@gnome.org>
+
+	* nl.po: Translation updated by Michiel Sikkes.
+
+2004-08-02  Duarte Loreto <happyguy_pt@hotmail.com>
+
+	* pt.po: Updated Portuguese translation.
+
+2004-08-02  Adam Weinberger  <adamw@gnome.org>
+
+	* en_CA.po: Updated Canadian English translation.
+
+2004-08-01  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* no.po: Updated Norwegian translation.
+
+2004-07-30  Martin Willemoes Hansen  <mwh@sysrq.dk>
+
+	* da.po: Reviewed and updated fuzzy messages.
+
+2004-07-30  Kartik Mistry  <kartik_m@magnet-i.com>
+
+	* gu.po: Updated and added Gujarati translation.
+
+2004-07-29  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2004-07-28  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-07-27  Alexander Shopov  <ash@contact.bg>
+
+	* bg.po: Updated Bulgarian translation by
+	Rostislav "zbrox" Raykov <zbrox@i-space.org>
+
+2004-07-27  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-07-25  Christian Rose  <menthos@menthos.com>
+
+	* sv.po: Updated Swedish translation.
+
+2004-07-25  Christian Neumair  <chris@gnome-de.org>
+
+	* de.po: Updated German translation.
+
+2004-07-25  David Lodge  <dave@cirt.net>
+
+	* en_GB.po: Added British translation.
+
+2004-07-24  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation. 
+
+2004-07-23  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Updated Czech translation.
+
+2004-07-23  Žygimantas Beručka  <uid0@akl.lt>
+
+	* lt.po: Updated Lithuanian translation.
+
+2004-07-22  Gustavo Maciel Dias Vieira  <gustavo@sagui.org>
+
+	* pt_BR.po: Updated Brazilian Portuguese translation done by
+	Goedson Teixeira Paixao <goedson@debian.org>.
+
+2004-07-21  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+        * hi.po: Updated Hindi translation.
+
+2004-07-14  Christian Rose  <menthos@menthos.com>
+
+	* sv.po: Updated Swedish translation.
+
+2004-07-12  Åsmund Skjæveland  <aasmunds@fys.uio.no>
+
+	* nn.po: Updated Norwegian Nynorsk translation.
+
+2004-07-08  Alexander Shopov  <ash@contact.bg>
+
+	* bg.po: Updated Bulgarian translation by
+	Vladimir "Kaladan" Petkov <vpetkov@i-space.org>
+		
+2004-07-07  Laszlo Dvornik  <ldvornik@cvs.gnome.org>
+
+	* hu.po: Updated Hungarian translation.
+
+2004-07-06  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation.
+
+2004-07-05  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-07-04  Vincent van Adrighem  <adrighem@gnome.org>
+
+	* nl.po: Translation updated by Tino Meinen.
+
+2004-07-02  Christian Neumair  <chris@gnome-de.org>
+
+	* de.po: Updated German translation.
+
+2004-06-29  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Translation updated.
+
+2004-06-28  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Translation updated.
+
+2004-06-25  Gareth Owen  <gowen72@yahoo.com>
+
+	* en_GB.po: Updated British English translation
+
+2004-06-26  Funda Wang  <fundawang@linux.net.cn>
+
+	* zh_CN.po: Updated Simplified Chinese translation.
+
+2004-06-25  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Updated Czech translation.
+
+2004-05-31  Alexander Shopov  <ash@contact.bg>
+	* bg.po: Updated Bulgarian translation by
+	Vladimir Petkov <vpetkov@i-space.org>
+
 2004-04-23  Dafydd Harries  <daf@muse.19inch.net>
 
 	* ca.po: Updated Catalan translation from Jordi Mallach.

rationales.txt

@@ -2,9 +2,7 @@
 History
 ====
 
-Focus windows on map: see
-  http://bugzilla.gnome.org/show_bug.cgi?id=118372
-  http://bugzilla.gnome.org/show_bug.cgi?id=82921
+Focus issues: see doc/how-to-get-focus-right.txt
 
 Keep panel always on top: http://bugzilla.gnome.org/show_bug.cgi?id=81551
 Edge flipping: http://bugzilla.gnome.org/show_bug.cgi?id=82917
@@ -30,14 +28,12 @@ raise windows on click:
   http://bugzilla.gnome.org/show_bug.cgi?id=115072
   http://bugzilla.gnome.org/show_bug.cgi?id=115753
 
-Some discussion of how pointer focus is inherently a bit buggy because
-of the "sometimes focus window that isn't under the mouse" heuristics:
-  http://bugzilla.gnome.org/show_bug.cgi?id=124798
-  (there are some other bugs that may have better explanation)
-
 Tracking bugs
 ====
 
 session management: http://bugzilla.gnome.org/show_bug.cgi?id=107063
 
 revise theme format: http://bugzilla.gnome.org/show_bug.cgi?id=102547
+
+bugs in focus-stealing-prevention: 
+  http://bugzilla.gnome.org/show_bug.cgi?id=149028

src/bell.c

@@ -34,7 +34,7 @@ meta_bell_flash_screen (MetaDisplay *display,
   
   if (screen->flash_window == None)
     {
-      Visual *visual = CopyFromParent;
+      Visual *visual = (Visual *)CopyFromParent;
       XSetWindowAttributes xswa;
       int depth = CopyFromParent;
       xswa.save_under = True;

src/common.h

@@ -72,6 +72,7 @@ typedef struct _MetaWindowMenu MetaWindowMenu;
 typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu,
                                      Display        *xdisplay,
                                      Window          client_xwindow,
+				     Time	     timestamp,
                                      MetaMenuOp      op,
                                      int             workspace,
                                      gpointer        data);

src/compositor.c

@@ -1,7 +1,7 @@
 /* Metacity compositing manager */
 
 /* 
- * Copyright (C) 2003 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
  * Copyright (C) 2003 Keith Packard
  * 
  * This program is free software; you can redistribute it and/or
@@ -32,6 +32,10 @@
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xrender.h>
 
+#if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 2
+#define HAVE_NAME_WINDOW_PIXMAP 1
+#endif
+
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 
 #define SHADOW_OFFSET 3
@@ -62,13 +66,17 @@ typedef struct
   
   Picture         picture;
   XserverRegion   border_size;
+
+#if HAVE_NAME_WINDOW_PIXMAP
+  Pixmap          pixmap;
+#endif
   
   unsigned int managed : 1;
   unsigned int damaged : 1;
   unsigned int viewable : 1;
 
   unsigned int screen_index : 8;
-  
+
 #endif  
 } MetaCompositorWindow;
 
@@ -82,8 +90,6 @@ struct MetaCompositor
   int damage_event_base;
   int fixes_error_base;
   int fixes_event_base;
-  int render_error_base;
-  int render_event_base;
   
   GHashTable *window_hash;
 
@@ -94,7 +100,9 @@ struct MetaCompositor
   guint have_composite : 1;
   guint have_damage : 1;
   guint have_fixes : 1;
-  guint have_render : 1;
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  guint have_name_window_pixmap : 1;
+#endif
 };
 
 #ifdef HAVE_COMPOSITE_EXTENSIONS
@@ -102,13 +110,20 @@ static void
 meta_compositor_window_free (MetaCompositorWindow *cwindow)
 {
   g_assert (cwindow->damage != None);
-
+  
+  meta_error_trap_push (cwindow->compositor->display);
   /* This seems to cause an error if the window
    * is destroyed?
    */
-  meta_error_trap_push (cwindow->compositor->display);
   XDamageDestroy (cwindow->compositor->display->xdisplay,
                   cwindow->damage);
+
+#if HAVE_NAME_WINDOW_PIXMAP
+  /* Free our window pixmap name */
+  if (cwindow->pixmap != None)
+    XFreePixmap (cwindow->compositor->display->xdisplay,
+                 cwindow->pixmap);
+#endif
   meta_error_trap_pop (cwindow->compositor->display, FALSE);
   
   g_free (cwindow);
@@ -143,7 +158,21 @@ meta_compositor_new (MetaDisplay *display)
       compositor->composite_error_base = 0;
     }
   else
-    compositor->have_composite = TRUE;
+    {
+      int composite_major, composite_minor;
+      
+      compositor->have_composite = TRUE;
+
+#if HAVE_NAME_WINDOW_PIXMAP
+      XCompositeQueryVersion (display->xdisplay,
+                              &composite_major, &composite_minor);
+
+#if 0
+      if (composite_major > 0 || composite_minor >= 2)
+	compositor->have_name_window_pixmap = TRUE;
+#endif
+#endif
+    }
 
   meta_topic (META_DEBUG_COMPOSITOR, "Composite extension event base %d error base %d\n",
               compositor->composite_event_base,
@@ -176,25 +205,11 @@ meta_compositor_new (MetaDisplay *display)
   meta_topic (META_DEBUG_COMPOSITOR, "Fixes extension event base %d error base %d\n",
               compositor->fixes_event_base,
               compositor->fixes_error_base);
-
-  if (!XRenderQueryExtension (display->xdisplay,
-                              &compositor->render_event_base,
-                              &compositor->render_error_base))
-    {
-      compositor->render_event_base = 0;
-      compositor->render_error_base = 0;
-    }
-  else
-    compositor->have_render = TRUE;
-
-  meta_topic (META_DEBUG_COMPOSITOR, "Render extension event base %d error base %d\n",
-              compositor->render_event_base,
-              compositor->render_error_base);
   
   if (!(compositor->have_composite &&
         compositor->have_fixes &&
-        compositor->have_render &&
-        compositor->have_damage))
+        compositor->have_damage &&
+        META_DISPLAY_HAS_RENDER (compositor->display)))
     {
       meta_topic (META_DEBUG_COMPOSITOR, "Failed to find all extensions needed for compositing manager, disabling compositing manager\n");
       g_assert (!compositor->enabled);
@@ -270,6 +285,31 @@ window_extents (MetaCompositorWindow *cwindow)
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 
 #ifdef HAVE_COMPOSITE_EXTENSIONS
+static void
+window_get_paint_bounds (MetaCompositorWindow *cwindow,
+                         int *x,
+                         int *y,
+                         int *w,
+                         int *h)
+{
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (cwindow->pixmap != None)
+    {
+      *x = cwindow->x;
+      *y = cwindow->y;
+      *w = cwindow->width + cwindow->border_width * 2;
+      *h = cwindow->height + cwindow->border_width * 2;
+    }
+  else
+#endif
+    {
+      *x = cwindow->x + cwindow->border_width;
+      *y = cwindow->y + cwindow->border_width;
+      *w = cwindow->width;
+      *h = cwindow->height;
+    }
+}
+
 static void
 paint_screen (MetaCompositor *compositor,
               MetaScreen     *screen,
@@ -286,7 +326,7 @@ paint_screen (MetaCompositor *compositor,
   meta_topic (META_DEBUG_COMPOSITOR, "Repainting screen %d root 0x%lx\n",
               screen->number, screen->xroot);
 
-  meta_display_grab (screen->display);
+  /* meta_display_grab (screen->display); */
   
   xdisplay = screen->display->xdisplay;
   
@@ -378,20 +418,24 @@ paint_screen (MetaCompositor *compositor,
            meta_grab_op_is_moving (compositor->display->grab_op)))
         {
           /* Draw window transparent while resizing */
+          int x, y, w, h;
+
+          window_get_paint_bounds (cwindow, &x, &y, &w, &h);
+          
           XRenderComposite (xdisplay,
                             PictOpOver, /* PictOpOver for alpha, PictOpSrc without */
                             cwindow->picture,
                             screen->trans_picture,
                             buffer_picture,
                             0, 0, 0, 0,
-                            cwindow->x + cwindow->border_width,
-                            cwindow->y + cwindow->border_width,
-                            cwindow->width,
-                            cwindow->height);
+                            x, y, w, h);
         }
       else
         {
           /* Draw window normally */
+          int x, y, w, h;
+          
+          window_get_paint_bounds (cwindow, &x, &y, &w, &h);
           
           /* superlame drop shadow */
           XRenderFillRectangle (xdisplay, PictOpOver,
@@ -407,10 +451,7 @@ paint_screen (MetaCompositor *compositor,
                             None,
                             buffer_picture,
                             0, 0, 0, 0,
-                            cwindow->x + cwindow->border_width,
-                            cwindow->y + cwindow->border_width,
-                            cwindow->width,
-                            cwindow->height);
+                            x, y, w, h);
         }
 
     next:
@@ -439,7 +480,7 @@ paint_screen (MetaCompositor *compositor,
   XRenderFreePicture (xdisplay, buffer_picture);
   XFreeGC (xdisplay, gc);
 
-  meta_display_ungrab (screen->display);
+  /* meta_display_ungrab (screen->display); */
 
   XSync (screen->display->xdisplay, False);
 }
@@ -1088,18 +1129,35 @@ meta_compositor_add_window (MetaCompositor    *compositor,
   cwindow->height = attrs->height;
   cwindow->border_width = attrs->border_width;
 
+#if HAVE_NAME_WINDOW_PIXMAP
+  if (compositor->have_name_window_pixmap)
+    {
+      meta_error_trap_push (compositor->display);
+      cwindow->pixmap = XCompositeNameWindowPixmap (compositor->display->xdisplay,
+                                                    cwindow->xwindow);
+      meta_error_trap_pop (compositor->display, FALSE);
+    }
+#endif
+  
   /* viewable == mapped for the root window, since root can't be unmapped */
   cwindow->viewable = (attrs->map_state == IsViewable);
+  /* FIXME this assertion can fail somehow... */
   g_assert (attrs->map_state != IsUnviewable);
   
   pa.subwindow_mode = IncludeInferiors;
 
   if (attrs->class != InputOnly)
-    {
+    {      
       format = XRenderFindVisualFormat (compositor->display->xdisplay,
                                         attrs->visual);
       cwindow->picture = XRenderCreatePicture (compositor->display->xdisplay,
-                                               xwindow,
+#if HAVE_NAME_WINDOW_PIXMAP
+                                               cwindow->pixmap != None ?
+                                               cwindow->pixmap :
+                                               cwindow->xwindow,
+#else
+                                               cwindow->xwindow,
+#endif
                                                format,
                                                CPSubwindowMode,
                                                &pa);
@@ -1299,7 +1357,3 @@ meta_compositor_damage_window (MetaCompositor *compositor,
                                    window_extents (cwindow));
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 }
-
-
-
-

src/core.c

@@ -236,8 +236,9 @@ meta_core_user_raise (Display *xdisplay,
 }
 
 void
-meta_core_user_lower (Display *xdisplay,
-                      Window   frame_xwindow)
+meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                  Window   frame_xwindow,
+                                  Time     timestamp)
 {
   MetaDisplay *display;
   MetaWindow *window;
@@ -249,6 +250,38 @@ meta_core_user_lower (Display *xdisplay,
     meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
   
   meta_window_lower (window);
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+    {
+      /* Move window to the back of the focusing workspace's MRU list.
+       * Do extra sanity checks to avoid possible race conditions.
+       * (Borrowed from window.c.)
+       */
+      if (window->screen->active_workspace &&
+          meta_window_visible_on_workspace (window, 
+                                            window->screen->active_workspace))
+        {
+          GList* link;
+          link = g_list_find (window->screen->active_workspace->mru_list, 
+                              window);
+          g_assert (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_remove_link (window->screen->active_workspace->mru_list,
+                                link);
+          g_list_free (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_append (window->screen->active_workspace->mru_list, 
+                           window);
+        }
+    }
+
+  /* focus the default window, if needed */
+  if (window->has_focus)
+    meta_workspace_focus_default_window (window->screen->active_workspace,
+                                         NULL,
+                                         timestamp);
 }
 
 void

src/core.h

@@ -60,8 +60,9 @@ void meta_core_user_resize  (Display *xdisplay,
 
 void meta_core_user_raise   (Display *xdisplay,
                              Window   frame_xwindow);
-void meta_core_user_lower   (Display *xdisplay,
-                             Window   frame_xwindow);
+void meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                       Window   frame_xwindow,
+                                       Time     timestamp);
 
 void meta_core_user_focus   (Display *xdisplay,
                              Window   frame_xwindow,

src/delete.c

@@ -38,6 +38,7 @@ static void meta_window_present_delete_dialog (MetaWindow *window);
 static void
 delete_ping_reply_func (MetaDisplay *display,
                         Window       xwindow,
+                        Time         timestamp,
                         void        *user_data)
 {
   meta_topic (META_DEBUG_PING,
@@ -290,14 +291,16 @@ io_from_ping_dialog (GIOChannel   *channel,
 static void
 delete_ping_timeout_func (MetaDisplay *display,
                           Window       xwindow,
+                          Time         timestamp,
                           void        *user_data)
 {
   MetaWindow *window = user_data;
   GError *err;
   int child_pid;
   int outpipe;
-  char *argv[7];
+  char *argv[9];
   char numbuf[32];
+  char timestampbuf[32];
   char *window_id_str;
   GIOChannel *channel;
   
@@ -314,14 +317,17 @@ delete_ping_timeout_func (MetaDisplay *display,
   window_id_str = g_strdup_printf ("0x%lx", window->xwindow);
 
   sprintf (numbuf, "%d", window->screen->number);
+  sprintf (timestampbuf, "%lu", timestamp);
   
   argv[0] = METACITY_LIBEXECDIR"/metacity-dialog";
   argv[1] = "--screen";
   argv[2] = numbuf;
-  argv[3] = "--kill-window-question";
-  argv[4] = window->title;
-  argv[5] = window_id_str;
-  argv[6] = NULL;
+  argv[3] = "--timestamp";
+  argv[4] = timestampbuf;
+  argv[5] = "--kill-window-question";
+  argv[6] = window->title;
+  argv[7] = window_id_str;
+  argv[8] = NULL;
   
   err = NULL;
   if (!g_spawn_async_with_pipes ("/",
@@ -396,10 +402,10 @@ meta_window_delete (MetaWindow  *window,
        * I don't know how to avoid that though.
        */
       meta_topic (META_DEBUG_FOCUS,
-                  "Focusing MRU window because focus window %s was deleted/killed\n",
+                  "Focusing default window because focus window %s was deleted/killed\n",
                   window->desc);
-      meta_workspace_focus_mru_window (window->screen->active_workspace,
-                                       window);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window);
 #else
       meta_topic (META_DEBUG_FOCUS,
                   "Not unfocusing %s on delete/kill\n",

src/display.c

@@ -2,7 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
  * Copyright (C) 2003, 2004 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
@@ -53,6 +53,9 @@
 #ifdef HAVE_SHAPE
 #include <X11/extensions/shape.h>
 #endif
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
 #ifdef HAVE_XKB
 #include <X11/XKBlib.h>
 #endif
@@ -270,8 +273,8 @@ meta_display_open (const char *name)
     "_NET_WM_STATE_BELOW",
     "_NET_STARTUP_ID",
     "_METACITY_TOGGLE_VERBOSE",
-    "_METACITY_UPDATE_COUNTER",
-    "SYNC_COUNTER",
+    "_NET_WM_SYNC_REQUEST",
+    "_NET_WM_SYNC_REQUEST_COUNTER",
     "_GNOME_PANEL_ACTION",
     "_GNOME_PANEL_ACTION_MAIN_MENU",
     "_GNOME_PANEL_ACTION_RUN_DIALOG",
@@ -281,6 +284,12 @@ meta_display_open (const char *name)
     "_NET_WM_ACTION_MINIMIZE",
     "_NET_FRAME_EXTENTS",
     "_NET_REQUEST_FRAME_EXTENTS",
+    "_NET_WM_USER_TIME",
+    "_NET_WM_STATE_DEMANDS_ATTENTION",
+    "_NET_RESTACK_WINDOW",
+    "_NET_MOVERESIZE_WINDOW",
+    "_NET_DESKTOP_GEOMETRY",
+    "_NET_DESKTOP_VIEWPORT"
   };
   Atom atoms[G_N_ELEMENTS(atom_names)];
   
@@ -319,11 +328,13 @@ meta_display_open (const char *name)
 
   display->pending_pings = NULL;
   display->autoraise_timeout_id = 0;
+  display->autoraise_window = NULL;
   display->focus_window = NULL;
+  display->previously_focused_window = NULL;
   display->expected_focus_window = NULL;
 
 #ifdef HAVE_XSYNC
-  display->grab_update_alarm = None;
+  display->grab_sync_request_alarm = None;
 #endif
   
   /* FIXME copy the checks from GDK probably */
@@ -416,8 +427,8 @@ meta_display_open (const char *name)
   display->atom_net_wm_state_below = atoms[71];
   display->atom_net_startup_id = atoms[72];
   display->atom_metacity_toggle_verbose = atoms[73];
-  display->atom_metacity_update_counter = atoms[74];
-  display->atom_sync_counter = atoms[75];
+  display->atom_net_wm_sync_request = atoms[74];
+  display->atom_net_wm_sync_request_counter = atoms[75];
   display->atom_gnome_panel_action = atoms[76];
   display->atom_gnome_panel_action_main_menu = atoms[77];
   display->atom_gnome_panel_action_run_dialog = atoms[78];
@@ -427,6 +438,12 @@ meta_display_open (const char *name)
   display->atom_net_wm_action_minimize = atoms[82];
   display->atom_net_frame_extents = atoms[83];
   display->atom_net_request_frame_extents = atoms[84];
+  display->atom_net_wm_user_time = atoms[85];
+  display->atom_net_wm_state_demands_attention = atoms[86];
+  display->atom_net_restack_window = atoms[87];
+  display->atom_net_moveresize_window = atoms[88];
+  display->atom_net_desktop_geometry = atoms[89];
+  display->atom_net_desktop_viewport = atoms[90];
 
   display->prop_hooks = NULL;
   meta_display_init_window_prop_hooks (display);
@@ -485,6 +502,9 @@ meta_display_open (const char *name)
   
   display->current_time = CurrentTime;
   display->sentinel_counter = 0;
+
+  display->grab_resize_timeout_id = 0;
+  display->grab_have_keyboard = FALSE;
   
   display->grab_op = META_GRAB_OP_NONE;
   display->grab_wireframe_active = FALSE;
@@ -495,6 +515,8 @@ meta_display_open (const char *name)
 #ifdef HAVE_XSYNC
   {
     int major, minor;
+
+    display->have_xsync = FALSE;
     
     display->xsync_error_base = 0;
     display->xsync_event_base = 0;
@@ -512,6 +534,9 @@ meta_display_open (const char *name)
         display->xsync_error_base = 0;
         display->xsync_event_base = 0;
       }
+    else
+      display->have_xsync = TRUE;
+    
     meta_verbose ("Attempted to init Xsync, found version %d.%d error base %d event base %d\n",
                   major, minor,
                   display->xsync_error_base,
@@ -524,6 +549,8 @@ meta_display_open (const char *name)
 
 #ifdef HAVE_SHAPE
   {
+    display->have_shape = FALSE;
+    
     display->shape_error_base = 0;
     display->shape_event_base = 0;
     
@@ -534,6 +561,9 @@ meta_display_open (const char *name)
         display->shape_error_base = 0;
         display->shape_event_base = 0;
       }
+    else
+      display->have_shape = TRUE;
+    
     meta_verbose ("Attempted to init Shape, found error base %d event base %d\n",
                   display->shape_error_base,
                   display->shape_event_base);
@@ -542,6 +572,31 @@ meta_display_open (const char *name)
   meta_verbose ("Not compiled with Shape support\n");
 #endif /* !HAVE_SHAPE */
 
+#ifdef HAVE_RENDER
+  {
+    display->have_render = FALSE;
+    
+    display->render_error_base = 0;
+    display->render_event_base = 0;
+    
+    if (!XRenderQueryExtension (display->xdisplay,
+                                &display->render_event_base,
+                                &display->render_error_base))
+      {
+        display->render_error_base = 0;
+        display->render_event_base = 0;
+      }
+    else
+      display->have_render = TRUE;
+    
+    meta_verbose ("Attempted to init Render, found error base %d event base %d\n",
+                  display->render_error_base,
+                  display->render_event_base);
+  }
+#else  /* HAVE_RENDER */
+  meta_verbose ("Not compiled with Render support\n");
+#endif /* !HAVE_RENDER */
+  
   /* Create the leader window here. Set its properties and
    * use the timestamp from one of the PropertyNotify events
    * that will follow.
@@ -726,11 +781,7 @@ meta_display_close (MetaDisplay *display)
 
   meta_prefs_remove_listener (prefs_changed_callback, display);
   
-  if (display->autoraise_timeout_id != 0)
-    {
-      g_source_remove (display->autoraise_timeout_id);
-      display->autoraise_timeout_id = 0;
-    }
+  meta_display_remove_autoraise_callback (display);
   
 #ifdef USE_GDK_DISPLAY
   /* Stop caring about events */
@@ -1045,6 +1096,35 @@ meta_display_get_current_time (MetaDisplay *display)
   return display->current_time;
 }
 
+/* Get a timestamp, even if it means a roundtrip */
+guint32
+meta_display_get_current_time_roundtrip (MetaDisplay *display)
+{
+  guint32 timestamp;
+  
+  timestamp = meta_display_get_current_time (display);
+  if (timestamp == CurrentTime)
+    {
+      XEvent property_event;
+
+      /* Using the property XA_PRIMARY because it's safe; nothing
+       * would use it as a property. The type doesn't matter.
+       */
+      XChangeProperty (display->xdisplay,
+                       display->leader_window,
+                       XA_PRIMARY, XA_STRING, 8,
+                       PropModeAppend, NULL, 0);
+      XWindowEvent (display->xdisplay,
+                    display->leader_window,
+                    PropertyChangeMask,
+                    &property_event);
+
+      timestamp = property_event.xproperty.time;
+    }
+
+  return timestamp;
+}
+
 static void
 add_ignored_serial (MetaDisplay  *display,
                     unsigned long serial)
@@ -1110,6 +1190,7 @@ window_raise_with_delay_callback (void *data)
 	      auto_raise->xwindow);
 
   auto_raise->display->autoraise_timeout_id = 0;
+  auto_raise->display->autoraise_window = NULL;
 
   window  = meta_display_lookup_x_window (auto_raise->display, 
 					  auto_raise->xwindow);
@@ -1146,6 +1227,33 @@ window_raise_with_delay_callback (void *data)
   return FALSE;
 }
 
+void
+meta_display_queue_autoraise_callback (MetaDisplay *display,
+                                       MetaWindow  *window)
+{
+  MetaAutoRaiseData *auto_raise_data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+              "Queuing an autoraise timeout for %s with delay %d\n", 
+              window->desc, 
+              meta_prefs_get_auto_raise_delay ());
+  
+  auto_raise_data = g_new (MetaAutoRaiseData, 1);
+  auto_raise_data->display = window->display;
+  auto_raise_data->xwindow = window->xwindow;
+  
+  if (display->autoraise_timeout_id != 0)
+    g_source_remove (display->autoraise_timeout_id);
+
+  display->autoraise_timeout_id = 
+    g_timeout_add_full (G_PRIORITY_DEFAULT,
+                        meta_prefs_get_auto_raise_delay (),
+                        window_raise_with_delay_callback,
+                        auto_raise_data,
+                        g_free);
+  display->autoraise_window = window;
+}
+
 static int
 double_click_timeout_for_event (MetaDisplay *display,
                                 XEvent      *event)
@@ -1168,6 +1276,107 @@ double_click_timeout_for_event (MetaDisplay *display,
   return meta_ui_get_double_click_timeout (screen->ui);
 }                                
 
+#if 0
+static void
+handle_net_moveresize_window (MetaDisplay* display,
+                              XEvent *event)
+{
+  MetaWindow *window;
+  int x, y, width, height;
+  gboolean only_resize;
+  unsigned int gravity;
+  unsigned int mode;
+
+  window = meta_display_lookup_x_window (display,
+                                         event->xclient.window);
+
+  /*
+   * FIXME: The specification seems to have serious endian issues
+   * here.  Does bits 8-11 mean the high-order byte, or the low-order
+   * byte?
+   */
+  gravity = (event->xclient.data.l[0] & ~0xff);
+  mode = (event->xclient.data.l[0] & ~0xff00) >> 8;
+
+  if (window)
+    {
+      meta_window_get_gravity_position (window, &x, &y);
+      width = window->rect.width;
+      height = window->rect.height;
+
+      if (mode & (CWX | CWY))
+        only_resize = FALSE;
+      else
+        only_resize = TRUE;
+
+      if (mode & CWX)
+        x = event->xclient.data.l[1];
+      if (mode & CWY)
+        y = event->xclient.data.l[2];
+      if (mode & CWWidth)
+        width = event->xclient.data.l[3];
+      if (mode & CWHeight)
+        height = event->xclient.data.l[4];
+
+      if (only_resize)
+        {
+          if (gravity)
+	    meta_window_resize_with_gravity (window,
+					     TRUE,
+					     width,
+					     height,
+					     gravity);
+          else
+            meta_window_resize (window,
+				TRUE,
+				width,
+				height);
+        }
+      else
+        {
+          meta_window_move_resize (window,
+                                   TRUE,
+                                   x,
+                                   y,
+                                   width,
+                                   height);
+        }
+    }
+}
+
+static void
+handle_net_restack_window (MetaDisplay* display,
+                           XEvent *event)
+{
+  MetaWindow *window;
+
+  window = meta_display_lookup_x_window (display,
+                                         event->xclient.window);
+
+  if (window)
+    {
+      /*
+       * The EWMH includes a sibling for the restack request, but we
+       * don't currently support these types of raises.
+       *
+       */
+      switch (event->xclient.data.l[2])
+        {
+        case Above:
+          meta_window_raise (window);
+          break;
+        case Below:
+          meta_window_lower (window);
+          break;
+        case TopIf:
+        case BottomIf:
+        case Opposite:
+          break;          
+        }
+    }
+}
+#endif
+
 static gboolean
 event_callback (XEvent   *event,
                 gpointer  data)
@@ -1177,7 +1386,7 @@ event_callback (XEvent   *event,
   Window modified;
   gboolean frame_was_receiver;
   gboolean filter_out_event;
-  
+
   display = data;
   
   if (dump_events)
@@ -1264,7 +1473,7 @@ event_callback (XEvent   *event,
 #ifdef HAVE_XSYNC
   if (META_DISPLAY_HAS_XSYNC (display) && 
       event->type == (display->xsync_event_base + XSyncAlarmNotify) &&
-      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_update_alarm)
+      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_sync_request_alarm)
     {
       filter_out_event = TRUE; /* GTK doesn't want to see this really */
       
@@ -1272,7 +1481,7 @@ event_callback (XEvent   *event,
           display->grab_window != NULL &&
           event->xany.serial >= display->grab_start_serial &&
           grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_event (display->grab_window, event);
+	meta_window_handle_mouse_grab_op_event (display->grab_window, event);
     }
 #endif /* HAVE_XSYNC */
 
@@ -1326,6 +1535,16 @@ event_callback (XEvent   *event,
         }
     }
 #endif /* HAVE_SHAPE */
+
+  if (window && ((event->type == KeyPress) || (event->type == ButtonPress)))
+    {
+      g_assert (CurrentTime != display->current_time);
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Metacity set %s's net_wm_user_time to %d.\n",
+                  window->desc, display->current_time);
+      window->net_wm_user_time_set = TRUE;
+      window->net_wm_user_time = display->current_time;
+    }
   
   switch (event->type)
     {
@@ -1515,6 +1734,8 @@ event_callback (XEvent   *event,
         meta_window_handle_mouse_grab_op_event (window, event);
       /* do this even if window->has_focus to avoid races */
       else if (window && !serial_is_ignored (display, event->xany.serial) &&
+               event->xcrossing.mode != NotifyGrab && 
+               event->xcrossing.mode != NotifyUngrab &&
                event->xcrossing.detail != NotifyInferior &&
                meta_display_focus_sentinel_clear (display))
         {
@@ -1536,26 +1757,7 @@ event_callback (XEvent   *event,
 		  
 		  if (meta_prefs_get_auto_raise ()) 
 		    {
-		      MetaAutoRaiseData *auto_raise_data;
-
-		      meta_topic (META_DEBUG_FOCUS, 
-				  "Queuing an autoraise timeout for %s with delay %d\n", 
-				  window->desc, 
-				  meta_prefs_get_auto_raise_delay ());
-		      
-		      auto_raise_data = g_new (MetaAutoRaiseData, 1);
-		      auto_raise_data->display = window->display;
-		      auto_raise_data->xwindow = window->xwindow;
-		      
-		      if (display->autoraise_timeout_id != 0)
-			g_source_remove (display->autoraise_timeout_id);
-
-		      display->autoraise_timeout_id = 
-			g_timeout_add_full (G_PRIORITY_DEFAULT,
-					    meta_prefs_get_auto_raise_delay (),
-					    window_raise_with_delay_callback,
-					    auto_raise_data,
-					    g_free);
+                      meta_display_queue_autoraise_callback (display, window);
 		    }
 		  else
 		    {
@@ -1582,7 +1784,7 @@ event_callback (XEvent   *event,
           switch (meta_prefs_get_focus_mode ())
             {
             case META_FOCUS_MODE_MOUSE:
-              if (window->has_focus &&
+              if (window == display->expected_focus_window &&
                   (window->frame == NULL || frame_was_receiver) &&
 		  event->xcrossing.mode != NotifyGrab && 
 		  event->xcrossing.mode != NotifyUngrab &&
@@ -1590,10 +1792,8 @@ event_callback (XEvent   *event,
                 {
                   meta_verbose ("Unsetting focus from %s due to LeaveNotify\n",
                                 window->desc);
-                  XSetInputFocus (display->xdisplay,
-                                  display->no_focus_window,
-                                  RevertToPointerRoot,
-                                  event->xcrossing.time);
+                  meta_display_focus_the_no_focus_window (display, 
+                                                          event->xcrossing.time);
                 }
               break;
             case META_FOCUS_MODE_SLOPPY:
@@ -1629,6 +1829,9 @@ event_callback (XEvent   *event,
       else if (meta_display_screen_for_root (display,
                                              event->xany.window) != NULL)
         {
+          MetaScreen * screen;
+          screen = meta_display_screen_for_root (display, event->xany.window);
+
           meta_topic (META_DEBUG_FOCUS,
                       "Focus %s event received on root window 0x%lx "
                       "mode %s detail %s\n",
@@ -1642,29 +1845,20 @@ event_callback (XEvent   *event,
           if (event->type == FocusIn &&
               event->xfocus.detail == NotifyDetailNone)
             {
-              XEvent   property_event;
+              meta_topic (META_DEBUG_FOCUS, 
+                          "Focus got set to None, probably due to brain-damage in the X protocol (see bug 125492).  Setting the default focus window.\n");
 
-              /* FIXME _() gettextify on HEAD */
-              meta_warning ("Working around an application which called XSetInputFocus (None) or with RevertToNone instead of RevertToPointerRoot, this is a minor bug in some application. If you can figure out which application causes this please report it as a bug against that application.\n");
-
-              /* Fix the problem */
-              /* Using the property XA_PRIMARY because it's safe;
-               * nothing would use it as a property. The type
-               * doesn't matter.
-               */
-              XChangeProperty (display->xdisplay,
-                               display->leader_window,
-                               XA_PRIMARY, XA_STRING, 8,
-                               PropModeAppend, NULL, 0);
-              XWindowEvent (display->xdisplay,
-                            display->leader_window,
-                            PropertyChangeMask,
-                            &property_event);
-              XSetInputFocus (display->xdisplay,
-                              display->no_focus_window,
-                              RevertToPointerRoot,
-                              property_event.xproperty.time);
+              meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display));
             }
+          else if (event->type == FocusIn &&
+              event->xfocus.mode == NotifyNormal &&
+              event->xfocus.detail == NotifyInferior)
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focus got set to root window, probably due to gnome-session logout dialog usage (see bug 153220).  Setting the default focus window.\n");
+              meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display));
+            }
+
         }
       break;
     case KeymapNotify:
@@ -1861,10 +2055,18 @@ event_callback (XEvent   *event,
             else if (event->xproperty.atom ==
                      display->atom_net_desktop_names)
               meta_screen_update_workspace_names (screen);
+#if 0
+            else if (event->xproperty.atom ==
+                     display->atom_net_restack_window)
+              handle_net_restack_window (display, event);
+            else if (event->xproperty.atom ==
+                     display->atom_net_moveresize_window)
+              handle_net_moveresize_window (display, event);
+#endif
 
-	    /* we just use this property as a sentinel to avoid
-	     * certain race conditions.  See the comment for the
-	     * sentinel_counter variable declaration in display.h
+            /* we just use this property as a sentinel to avoid
+             * certain race conditions.  See the comment for the
+             * sentinel_counter variable declaration in display.h
 	     */
 	    if (event->xproperty.atom ==
 		display->atom_metacity_sentinel)
@@ -1925,7 +2127,7 @@ event_callback (XEvent   *event,
                                                         space);
 
                   if (workspace)
-                    meta_workspace_activate (workspace);
+                    meta_workspace_activate (workspace, meta_display_get_current_time_roundtrip (display));
                   else
                     meta_verbose ("Don't know about workspace %d\n", space);
                 }
@@ -1952,7 +2154,10 @@ event_callback (XEvent   *event,
 		  if (showing_desktop)
 		    meta_screen_show_desktop (screen);
 		  else
-		    meta_screen_unshow_desktop (screen);
+		    {
+		      meta_screen_unshow_desktop (screen);
+		      meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display));
+		    }
 		}
               else if (event->xclient.message_type ==
                        display->atom_metacity_restart_message)
@@ -2969,10 +3174,16 @@ meta_display_begin_grab_op (MetaDisplay *display,
   display->grab_last_moveresize_time.tv_usec = 0;
   display->grab_motion_notify_time = 0;
 #ifdef HAVE_XSYNC
-  display->grab_update_alarm = None;
+  display->grab_sync_request_alarm = None;
 #endif
   display->grab_was_cancelled = FALSE;
   
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
+	
   if (display->grab_window)
     {
       display->grab_initial_window_pos = display->grab_window->rect;
@@ -2988,10 +3199,8 @@ meta_display_begin_grab_op (MetaDisplay *display,
       
       if (display->grab_wireframe_active)
         {
-          /* FIXME we should really display the outer frame rect,
-           * but that complicates all the move/resize code since
-           * it works in terms of window rect.
-           */
+          MetaRectangle xor_rect;
+          
           display->grab_wireframe_rect = window->rect;
           if (window->frame)
             {
@@ -3000,35 +3209,53 @@ meta_display_begin_grab_op (MetaDisplay *display,
             }
           
           meta_window_calc_showing (display->grab_window);
+
+          meta_window_get_xor_rect (window, &display->grab_wireframe_rect,
+                                    &xor_rect);
+          
           meta_effects_begin_wireframe (display->grab_window->screen,
-                                        &display->grab_wireframe_rect);
+                                        &xor_rect);
+          display->grab_wireframe_last_xor_rect = xor_rect;
         }
       
 #ifdef HAVE_XSYNC
       if (!display->grab_wireframe_active &&
           meta_grab_op_is_resizing (display->grab_op) &&
-          display->grab_window->update_counter != None)
+          display->grab_window->sync_request_counter != None)
         {
           XSyncAlarmAttributes values;
+	  XSyncValue init;
 
-          /* trigger when we make a positive transition to a value
-           * one higher than the current value.
-           */
-          values.trigger.counter = display->grab_window->update_counter;
-          values.trigger.value_type = XSyncRelative;
+          meta_error_trap_push_with_return (display);
+
+	  /* Set the counter to 0, so we know that the application's
+	   * responses to the client messages will always trigger
+	   * a PositiveTransition
+	   */
+	  
+	  XSyncIntToValue (&init, 0);
+	  XSyncSetCounter (display->xdisplay,
+			   display->grab_window->sync_request_counter, init);
+	  
+	  display->grab_window->sync_request_serial = 0;
+	  display->grab_window->sync_request_time.tv_sec = 0;
+	  display->grab_window->sync_request_time.tv_usec = 0;
+	  
+          values.trigger.counter = display->grab_window->sync_request_counter;
+          values.trigger.value_type = XSyncAbsolute;
           values.trigger.test_type = XSyncPositiveTransition;
-          XSyncIntToValue (&values.trigger.wait_value, 1);
-
+          XSyncIntToValue (&values.trigger.wait_value,
+			   display->grab_window->sync_request_serial + 1);
+	  
           /* After triggering, increment test_value by this.
            * (NOT wait_value above)
            */
           XSyncIntToValue (&values.delta, 1);
-
+	  
           /* we want events (on by default anyway) */
           values.events = True;
           
-          meta_error_trap_push_with_return (display);
-          display->grab_update_alarm = XSyncCreateAlarm (display->xdisplay,
+          display->grab_sync_request_alarm = XSyncCreateAlarm (display->xdisplay,
                                                          XSyncCACounter |
                                                          XSyncCAValueType |
                                                          XSyncCAValue |
@@ -3036,12 +3263,13 @@ meta_display_begin_grab_op (MetaDisplay *display,
                                                          XSyncCADelta |
                                                          XSyncCAEvents,
                                                          &values);
+
           if (meta_error_trap_pop_with_return (display, FALSE) != Success)
-            display->grab_update_alarm = None;
+	    display->grab_sync_request_alarm = None;
 
           meta_topic (META_DEBUG_RESIZING,
                       "Created update alarm 0x%lx\n",
-                      display->grab_update_alarm);
+                      display->grab_sync_request_alarm);
         }
 #endif
     }
@@ -3119,6 +3347,21 @@ meta_display_end_grab_op (MetaDisplay *display,
       display->ungrab_should_not_cause_focus_window = display->grab_xwindow;
     }
   
+  if (display->grab_wireframe_active)
+    {
+      display->grab_wireframe_active = FALSE;
+      meta_effects_end_wireframe (display->grab_window->screen,
+                                  &display->grab_wireframe_last_xor_rect);
+      if (!display->grab_was_cancelled)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_wireframe_rect.x,
+                                 display->grab_wireframe_rect.y,
+                                 display->grab_wireframe_rect.width,
+                                 display->grab_wireframe_rect.height);
+      meta_window_calc_showing (display->grab_window);
+    }
+
   if (display->grab_have_pointer)
     {
       meta_topic (META_DEBUG_WINDOW_OPS,
@@ -3138,28 +3381,14 @@ meta_display_end_grab_op (MetaDisplay *display,
     }
 
 #ifdef HAVE_XSYNC
-  if (display->grab_update_alarm != None)
+  if (display->grab_sync_request_alarm != None)
     {
       XSyncDestroyAlarm (display->xdisplay,
-                         display->grab_update_alarm);
+                         display->grab_sync_request_alarm);
+      display->grab_sync_request_alarm = None;
     }
 #endif /* HAVE_XSYNC */
 
-  if (display->grab_wireframe_active)
-    {
-      display->grab_wireframe_active = FALSE;
-      meta_effects_end_wireframe (display->grab_window->screen,
-                                  &display->grab_wireframe_rect);
-      if (!display->grab_was_cancelled)
-        meta_window_move_resize (display->grab_window,
-                                 TRUE,
-                                 display->grab_wireframe_rect.x,
-                                 display->grab_wireframe_rect.y,
-                                 display->grab_wireframe_rect.width,
-                                 display->grab_wireframe_rect.height);
-      meta_window_calc_showing (display->grab_window);
-    }
-
   /* repaint window in case the grab op drew it in a
    * nonstandard way such as transparent or wireframe
    */
@@ -3177,6 +3406,12 @@ meta_display_end_grab_op (MetaDisplay *display,
       meta_ui_resize_popup_free (display->grab_resize_popup);
       display->grab_resize_popup = NULL;
     }
+
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
 }
 
 static void
@@ -3503,7 +3738,7 @@ meta_display_ping_timeout (gpointer data)
               ping_data->timestamp, ping_data->xwindow);
   
   (* ping_data->ping_timeout_func) (ping_data->display, ping_data->xwindow,
-                                    ping_data->user_data);
+                                    ping_data->timestamp, ping_data->user_data);
 
   ping_data->display->pending_pings =
     g_slist_remove (ping_data->display->pending_pings,
@@ -3532,7 +3767,7 @@ meta_display_ping_window (MetaDisplay       *display,
   if (!window->net_wm_ping)
     {
       if (ping_reply_func)
-        (* ping_reply_func) (display, window->xwindow, user_data);
+        (* ping_reply_func) (display, window->xwindow, timestamp, user_data);
 
       return;
     }
@@ -3658,7 +3893,9 @@ process_pong_message (MetaDisplay    *display,
             }
           
           /* Call callback */
-          (* ping_data->ping_reply_func) (display, ping_data->xwindow,
+          (* ping_data->ping_reply_func) (display, 
+                                          ping_data->xwindow,
+                                          ping_data->timestamp, 
                                           ping_data->user_data);
 			      
           ping_data_free (ping_data);
@@ -4347,3 +4584,26 @@ meta_display_focus_sentinel_clear (MetaDisplay *display)
 {
   return (display->sentinel_counter == 0);
 }
+
+void
+meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                        Time         timestamp)
+{
+  XSetInputFocus (display->xdisplay,
+                  display->no_focus_window,
+                  RevertToPointerRoot,
+                  timestamp);
+  display->expected_focus_window = NULL;
+  meta_display_remove_autoraise_callback (display);
+}
+
+void
+meta_display_remove_autoraise_callback (MetaDisplay *display)
+{
+  if (display->autoraise_timeout_id != 0)
+    {
+      g_source_remove (display->autoraise_timeout_id);
+      display->autoraise_timeout_id = 0;
+      display->autoraise_window = NULL;
+    }
+}

src/display.h

@@ -69,6 +69,7 @@ typedef struct _MetaGroupPropHooks  MetaGroupPropHooks;
 
 typedef void (* MetaWindowPingFunc) (MetaDisplay *display,
 				     Window       xwindow,
+				     Time         timestamp,
 				     gpointer     user_data);
 
 
@@ -166,8 +167,8 @@ struct _MetaDisplay
   Atom atom_net_wm_state_below;
   Atom atom_net_startup_id;
   Atom atom_metacity_toggle_verbose;
-  Atom atom_metacity_update_counter;
-  Atom atom_sync_counter;
+  Atom atom_net_wm_sync_request;
+  Atom atom_net_wm_sync_request_counter;
   Atom atom_gnome_panel_action;
   Atom atom_gnome_panel_action_main_menu;
   Atom atom_gnome_panel_action_run_dialog;
@@ -175,12 +176,22 @@ struct _MetaDisplay
   Atom atom_net_wm_strut_partial;
   Atom atom_net_frame_extents;
   Atom atom_net_request_frame_extents;
+  Atom atom_net_wm_user_time;
+  Atom atom_net_wm_state_demands_attention;
+  Atom atom_net_restack_window;
+  Atom atom_net_moveresize_window;
+  Atom atom_net_desktop_geometry;
+  Atom atom_net_desktop_viewport;
 
   /* This is the actual window from focus events,
    * not the one we last set
    */
   MetaWindow *focus_window;
 
+ /* Window that was the actual window from focus events before focus_window
+  */
+  MetaWindow *previously_focused_window;
+
   /* window we are expecting a FocusIn event for
    */
   MetaWindow *expected_focus_window;
@@ -222,6 +233,7 @@ struct _MetaDisplay
 
   /* Pending autoraise */
   guint       autoraise_timeout_id;
+  MetaWindow* autoraise_window;
 
   /* Alt+click button grabs */
   unsigned int window_grab_modifiers;
@@ -244,6 +256,7 @@ struct _MetaDisplay
   guint       grab_wireframe_active : 1;
   guint       grab_was_cancelled : 1;
   MetaRectangle grab_wireframe_rect;
+  MetaRectangle grab_wireframe_last_xor_rect;
   MetaRectangle grab_initial_window_pos;
   MetaResizePopup *grab_resize_popup;
   GTimeVal    grab_last_moveresize_time;
@@ -258,9 +271,10 @@ struct _MetaDisplay
   int         xkb_base_event_type;
 #endif
 #ifdef HAVE_XSYNC
-  /* alarm monitoring client's _METACITY_UPDATE_COUNTER */
-  XSyncAlarm  grab_update_alarm;
+  /* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */
+  XSyncAlarm  grab_sync_request_alarm;
 #endif
+  int	      grab_resize_timeout_id;
 
   /* Keybindings stuff */
   MetaKeyBinding *screen_bindings;
@@ -307,17 +321,33 @@ struct _MetaDisplay
 #ifdef HAVE_XSYNC
   int xsync_event_base;
   int xsync_error_base;
-#define META_DISPLAY_HAS_XSYNC(display) ((display)->xsync_event_base != 0)
-#else
-#define META_DISPLAY_HAS_XSYNC(display) FALSE
 #endif
 #ifdef HAVE_SHAPE
   int shape_event_base;
   int shape_error_base;
-#define META_DISPLAY_HAS_SHAPE(display) ((display)->shape_event_base != 0)
+#endif
+#ifdef HAVE_RENDER
+  int render_event_base;
+  int render_error_base;
+#endif
+#ifdef HAVE_XSYNC
+  unsigned int have_xsync : 1;
+#define META_DISPLAY_HAS_XSYNC(display) ((display)->have_xsync)
+#else
+#define META_DISPLAY_HAS_XSYNC(display) FALSE
+#endif
+#ifdef HAVE_SHAPE
+  unsigned int have_shape : 1;
+#define META_DISPLAY_HAS_SHAPE(display) ((display)->have_shape)
 #else
 #define META_DISPLAY_HAS_SHAPE(display) FALSE
 #endif
+#ifdef HAVE_RENDER
+  unsigned int have_render : 1;
+#define META_DISPLAY_HAS_RENDER(display) ((display)->have_render)
+#else
+#define META_DISPLAY_HAS_RENDER(display) FALSE
+#endif
 };
 
 gboolean      meta_display_open                (const char  *name);
@@ -393,7 +423,8 @@ void     meta_display_increment_event_serial (MetaDisplay *display);
 
 void     meta_display_update_active_window_hint (MetaDisplay *display);
 
-guint32  meta_display_get_current_time (MetaDisplay *display);
+guint32  meta_display_get_current_time           (MetaDisplay *display);
+guint32  meta_display_get_current_time_roundtrip (MetaDisplay *display);
 
 /* utility goo */
 const char* meta_event_mode_to_string   (int m);
@@ -455,4 +486,10 @@ void meta_display_increment_focus_sentinel (MetaDisplay *display);
 void meta_display_decrement_focus_sentinel (MetaDisplay *display);
 gboolean meta_display_focus_sentinel_clear (MetaDisplay *display);
 
+void meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                             Time         timestamp);
+void meta_display_queue_autoraise_callback  (MetaDisplay *display,
+                                             MetaWindow  *window);
+void meta_display_remove_autoraise_callback (MetaDisplay *display);
+
 #endif

src/effects.c

@@ -125,6 +125,22 @@ update_wireframe_window (MetaDisplay         *display,
 #endif
 }
 
+static void
+graphics_sync (BoxAnimationContext *context)
+{
+  XImage *image;
+  
+  /* A hack to force the X server to synchronize with the
+   * graphics hardware
+   */
+  image = XGetImage (context->screen->display->xdisplay,
+		     context->screen->xroot,
+		     0, 0, 1, 1,
+		     AllPlanes, ZPixmap);
+
+  XDestroyImage (image);
+}
+
 static gboolean
 effects_draw_box_animation_timeout (BoxAnimationContext *context)
 {
@@ -182,6 +198,8 @@ effects_draw_box_animation_timeout (BoxAnimationContext *context)
           XDestroyWindow (context->screen->display->xdisplay,
                           context->wireframe_xwindow);
         }
+
+      graphics_sync (context);
       
       g_free (context);
       return FALSE;
@@ -267,7 +285,7 @@ effects_draw_box_animation_timeout (BoxAnimationContext *context)
     }
 
   /* kick changes onto the server */
-  XFlush (context->screen->display->xdisplay);
+  graphics_sync (context);
   
   return TRUE;
 }
@@ -364,7 +382,7 @@ meta_effects_draw_box_animation (MetaScreen     *screen,
                                                   0,
                                                   CopyFromParent,
                                                   CopyFromParent,
-                                                  CopyFromParent,
+                                                  (Visual *)CopyFromParent,
                                                   CWOverrideRedirect | CWBackPixel,
                                                   &attrs);
 

src/effects.h

@@ -25,7 +25,7 @@
 #include "util.h"
 #include "screen.h"
 
-#define META_MINIMIZE_ANIMATION_LENGTH 0.35
+#define META_MINIMIZE_ANIMATION_LENGTH 0.25
 #define META_SHADE_ANIMATION_LENGTH 0.2
 
 typedef enum

src/fixedtip.c

@@ -64,10 +64,8 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number,
       gtk_widget_set_name (tip, "gtk-tooltips");
       gtk_container_set_border_width (GTK_CONTAINER (tip), 4);
 
-      gtk_signal_connect_object (GTK_OBJECT (tip), 
-				 "expose_event",
-				 GTK_SIGNAL_FUNC (expose_handler),
-                                 NULL);
+      g_signal_connect_swapped (tip, "expose_event",
+				 G_CALLBACK (expose_handler), NULL);
 
       label = gtk_label_new (NULL);
       gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
@@ -76,10 +74,8 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number,
       
       gtk_container_add (GTK_CONTAINER (tip), label);
 
-      gtk_signal_connect (GTK_OBJECT (tip),
-			  "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &tip);
+      g_signal_connect (tip, "destroy",
+			G_CALLBACK (gtk_widget_destroyed), &tip);
     }
 
   gtk_label_set_markup (GTK_LABEL (label), markup_text);

src/frame.c

@@ -2,7 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2003 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -26,6 +26,10 @@
 #include "errors.h"
 #include "keybindings.h"
 
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
 #define EVENT_MASK (SubstructureRedirectMask |                     \
                     StructureNotifyMask | SubstructureNotifyMask | \
                     ExposureMask |                                 \
@@ -34,6 +38,60 @@
                     EnterWindowMask | LeaveWindowMask |            \
                     FocusChangeMask |                              \
                     ColormapChangeMask)
+static Visual*
+find_argb_visual (MetaDisplay *display,
+                  int          scr)
+{
+#ifdef HAVE_RENDER
+  XVisualInfo		*xvi;
+  XVisualInfo		template;
+  int			nvi;
+  int			i;
+  XRenderPictFormat	*format;
+  Visual		*visual;
+
+  if (!META_DISPLAY_HAS_RENDER (display))
+    return NULL;
+  
+  template.screen = scr;
+  template.depth = 32;
+  template.class = TrueColor;
+  xvi = XGetVisualInfo (display->xdisplay, 
+                        VisualScreenMask |
+                        VisualDepthMask |
+                        VisualClassMask,
+                        &template,
+                        &nvi);
+  if (!xvi)
+    return NULL;
+  
+  visual = NULL;
+
+  for (i = 0; i < nvi; i++)
+    {
+      format = XRenderFindVisualFormat (display->xdisplay, xvi[i].visual);
+      if (format->type == PictTypeDirect && format->direct.alphaMask)
+	{
+          visual = xvi[i].visual;
+          break;
+	}
+    }
+
+  XFree (xvi);
+
+  if (visual)
+    meta_topic (META_DEBUG_COMPOSITOR,
+                "Found ARGB visual 0x%lx\n",
+                (long) visual->visualid);
+  else
+    meta_topic (META_DEBUG_COMPOSITOR,
+                "No ARGB visual found\n");
+  
+  return visual;
+#else  /* RENDER */
+  return NULL;
+#endif /* !RENDER */
+}
 
 void
 meta_window_ensure_frame (MetaWindow *window)
@@ -77,13 +135,20 @@ meta_window_ensure_frame (MetaWindow *window)
   /* Default depth/visual handles clients with weird visuals; they can
    * always be children of the root depth/visual obviously, but
    * e.g. DRI games can't be children of a parent that has the same
-   * visual as the client.
+   * visual as the client. NULL means default visual.
+   *
+   * We look for an ARGB visual if we can find one, otherwise use
+   * the default of NULL.
+   */
+  
+  /* Special case for depth 32 windows (assumed to be ARGB),
+   * we use the window's visual
    */
-
-  visual = 0;
-  /* XXX special case for depth 32 windows (assumed to be ARGB) */
   if (window->depth == 32)
-    visual = window->xvisual;  
+    visual = window->xvisual;
+  else
+    visual = find_argb_visual(window->display, 
+                              window->screen->number);
 
   frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
                                                 window->display->xdisplay,
@@ -381,6 +446,7 @@ meta_frame_set_screen_cursor (MetaFrame	*frame,
     { 
       xcursor = meta_display_create_x_cursor (frame->window->display, cursor);
       XDefineCursor (frame->window->display->xdisplay, frame->xwindow, xcursor);
+      XFlush (frame->window->display->xdisplay);
       XFreeCursor (frame->window->display->xdisplay, xcursor);
     }
 }

src/frames.c

@@ -64,6 +64,9 @@ static void meta_frames_paint_to_drawable (MetaFrames   *frames,
                                            GdkDrawable  *drawable,
                                            GdkRegion    *region);
 
+static void meta_frames_set_window_background (MetaFrames   *frames,
+                                               MetaUIFrame  *frame);
+
 static void meta_frames_calc_geometry (MetaFrames        *frames,
                                        MetaUIFrame         *frame,
                                        MetaFrameGeometry *fgeom);
@@ -156,7 +159,7 @@ unsigned_long_hash (gconstpointer v)
   gulong val = * (const gulong *) v;
 
   /* I'm not sure this works so well. */
-#if G_SIZEOF_LONG > 4
+#if GLIB_SIZEOF_LONG > 4
   return (guint) (val ^ (val >> 32));
 #else
   return val;
@@ -270,8 +273,8 @@ queue_recalc_func (gpointer key, gpointer value, gpointer data)
    * resize may not actually be needed so we always redraw
    * in case of color change.
    */
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-                            frame->window, GTK_STATE_NORMAL);
+  meta_frames_set_window_background (frames, frame);
+  
   gdk_window_invalidate_rect (frame->window, NULL, FALSE);
   meta_core_queue_frame_resize (gdk_display,
                                 frame->xwindow);
@@ -315,8 +318,8 @@ queue_draw_func (gpointer key, gpointer value, gpointer data)
    * resize may not actually be needed so we always redraw
    * in case of color change.
    */
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-                            frame->window, GTK_STATE_NORMAL);
+  meta_frames_set_window_background (frames, frame);
+
   gdk_window_invalidate_rect (frame->window, NULL, FALSE);
 }
 
@@ -477,8 +480,9 @@ meta_frames_manage_window (MetaFrames *frames,
   frame->window = window;
 
   gdk_window_set_user_data (frame->window, frames);
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-			    frame->window, GTK_STATE_NORMAL);
+
+  /* Set the window background to the current style */
+  meta_frames_set_window_background (frames, frame);
 
   /* Don't set event mask here, it's in frame.c */
   
@@ -612,8 +616,8 @@ meta_frames_reset_bg (MetaFrames *frames,
   widget = GTK_WIDGET (frames);
 
   frame = meta_frames_lookup_window (frames, xwindow);
-  
-  gtk_style_set_background (widget->style, frame->window, GTK_STATE_NORMAL);
+
+  meta_frames_set_window_background (frames, frame);
 }
 
 static void
@@ -848,7 +852,7 @@ meta_frames_apply_shapes (MetaFrames *frames,
                                     0,
                                     CopyFromParent,
                                     CopyFromParent,
-                                    CopyFromParent,
+                                    (Visual *)CopyFromParent,
                                     CWOverrideRedirect,
                                     &attrs);
 
@@ -1368,7 +1372,9 @@ meta_frames_button_press_event (GtkWidget      *widget,
     }
   else if (event->button == 2)
     {
-      meta_core_user_lower (gdk_display, frame->xwindow);
+      meta_core_user_lower_and_unfocus (gdk_display,
+                                        frame->xwindow,
+                                        event->time);
     }
   else if (event->button == 3)
     {
@@ -1893,6 +1899,22 @@ meta_frames_paint_to_drawable (MetaFrames   *frames,
   g_free (areas);
 }
 
+static void
+meta_frames_set_window_background (MetaFrames   *frames,
+                                   MetaUIFrame  *frame)
+{
+  gtk_style_set_background (GTK_WIDGET (frames)->style,
+                            frame->window, GTK_STATE_NORMAL);
+
+#if 0
+  /* This is what we want for transparent background */
+  {
+    col.pixel = 0;
+    gdk_window_set_background (window, &col);
+  }
+#endif
+}
+
 static gboolean
 meta_frames_enter_notify_event      (GtkWidget           *widget,
                                      GdkEventCrossing    *event)

src/iconcache.c

@@ -66,7 +66,7 @@ find_largest_sizes (gulong *data,
       w = data[0];
       h = data[1];
 
-      if (nitems < ((w * h) + 2))
+      if (nitems < ((gulong)(w * h) + 2))
         return FALSE; /* not enough data */
 
       *width = MAX (w, *width);
@@ -122,7 +122,7 @@ find_best_size (gulong  *data,
       w = data[0];
       h = data[1];
 
-      if (nitems < ((w * h) + 2))
+      if (nitems < ((gulong)(w * h) + 2))
         break; /* not enough data */
 
       if (best_start == NULL)

src/keybindings.c

@@ -1822,14 +1822,16 @@ process_keyboard_move_grab (MetaDisplay *display,
         {
           MetaRectangle new_xor;
 
-          new_xor = display->grab_wireframe_rect;
-          new_xor.x = x;
-          new_xor.y = y;
+          display->grab_wireframe_rect.x = x;
+          display->grab_wireframe_rect.y = y;
+          
+          meta_window_get_xor_rect (window, &display->grab_wireframe_rect,
+                                    &new_xor);
           
           meta_effects_update_wireframe (window->screen,
-                                         &display->grab_wireframe_rect,
+                                         &display->grab_wireframe_last_xor_rect,
                                          &new_xor);
-          display->grab_wireframe_rect = new_xor;
+          display->grab_wireframe_last_xor_rect = new_xor;
         }
       else
         {
@@ -2281,15 +2283,19 @@ process_keyboard_resize_grab (MetaDisplay *display,
         {
           MetaRectangle new_xor;
       
-          new_xor.x = x;
-          new_xor.y = y;
-          new_xor.width = width;
-          new_xor.height = height;
+          window->display->grab_wireframe_rect.x = x;
+          window->display->grab_wireframe_rect.y = y;
+          window->display->grab_wireframe_rect.width = width;
+          window->display->grab_wireframe_rect.height = height;
 
+          meta_window_get_xor_rect (window,
+                                    &window->display->grab_wireframe_rect,
+                                    &new_xor);
+          
           meta_effects_update_wireframe (window->screen,
-                                         &window->display->grab_wireframe_rect,
+                                         &window->display->grab_wireframe_last_xor_rect,
                                          &new_xor);
-          window->display->grab_wireframe_rect = new_xor;
+          window->display->grab_wireframe_last_xor_rect = new_xor;
 
           /* do this after drawing the wires, so we don't draw over it */
           meta_window_refresh_resize_popup (window);
@@ -2468,7 +2474,7 @@ handle_activate_workspace (MetaDisplay    *display,
   
   if (workspace)
     {
-      meta_workspace_activate (workspace);
+      meta_workspace_activate (workspace, event->xkey.time);
     }
   else
     {
@@ -2480,12 +2486,14 @@ static void
 error_on_command (int         command_index,
                   const char *command,
                   const char *message,
-                  int         screen_number)
+                  int         screen_number,
+                  Time        timestamp)
 {
   GError *err;
-  char *argv[8];
+  char *argv[10];
   char *key;
   char numbuf[32];
+  char timestampbuf[32];
   
   meta_warning ("Error on command %d \"%s\": %s\n",
                 command_index, command, message);  
@@ -2493,15 +2501,18 @@ error_on_command (int         command_index,
   key = meta_prefs_get_gconf_key_for_command (command_index);
 
   sprintf (numbuf, "%d", screen_number);
+  sprintf (timestampbuf, "%lu", timestamp);
   
   argv[0] = METACITY_LIBEXECDIR"/metacity-dialog";
   argv[1] = "--screen";
   argv[2] = numbuf;
-  argv[3] = "--command-failed-error";
-  argv[4] = key;
-  argv[5] = (char*) (command ? command : "");
-  argv[6] = (char*) message;
-  argv[7] = NULL;
+  argv[3] = "--timestamp";
+  argv[4] = timestampbuf;
+  argv[5] = "--command-failed-error";
+  argv[6] = key;
+  argv[7] = (char*) (command ? command : "");
+  argv[8] = (char*) message;
+  argv[9] = NULL;
   
   err = NULL;
   if (!g_spawn_async_with_pipes ("/",
@@ -2542,7 +2553,7 @@ meta_spawn_command_line_async_on_screen (const gchar *command_line,
                                          GError     **error)
 {
   gboolean retval;
-  gchar **argv = 0;
+  gchar **argv = NULL;
 
   g_return_val_if_fail (command_line != NULL, FALSE);
 
@@ -2590,7 +2601,7 @@ handle_run_command (MetaDisplay    *display,
       
       s = g_strdup_printf (_("No command %d has been defined.\n"),
                            which + 1);
-      error_on_command (which, NULL, s, screen->number);
+      error_on_command (which, NULL, s, screen->number, event->xkey.time);
       g_free (s);
       
       return;
@@ -2599,7 +2610,7 @@ handle_run_command (MetaDisplay    *display,
   err = NULL;
   if (!meta_spawn_command_line_async_on_screen (command, screen, &err))
     {
-      error_on_command (which, command, err->message, screen->number);
+      error_on_command (which, command, err->message, screen->number, event->xkey.time);
       
       g_error_free (err);
     }
@@ -2659,19 +2670,25 @@ process_workspace_switch_grab (MetaDisplay *display,
 
       meta_topic (META_DEBUG_KEYBINDINGS,
                   "Ending workspace tab operation, primary modifier released\n");
-      if (target_workspace)
+
+      if (target_workspace == screen->active_workspace)
         {
           meta_topic (META_DEBUG_KEYBINDINGS,
-                      "Ending grab early so we can focus the target workspace\n");
+                      "Ending grab so we can focus on the target workspace\n");
           meta_display_end_grab_op (display, event->xkey.time);
 
           meta_topic (META_DEBUG_KEYBINDINGS,
-                      "Activating target workspace\n");
+                      "Focusing default window on target workspace\n");
 
-          meta_workspace_activate (target_workspace);
+          meta_workspace_focus_default_window (target_workspace, 
+                                               NULL,
+                                               event->xkey.time);
 
           return TRUE; /* we already ended the grab */
         }
+
+      /* Workspace switching should have already occurred on KeyPress */
+      meta_warning ("target_workspace != active_workspace.  Some other event must have occurred.\n");
       
       return FALSE; /* end grab */
     }
@@ -2734,7 +2751,7 @@ process_workspace_switch_grab (MetaDisplay *display,
           meta_topic (META_DEBUG_KEYBINDINGS,
                       "Activating target workspace\n");
 
-          meta_workspace_activate (target_workspace);
+          meta_workspace_activate (target_workspace, event->xkey.time);
 
           return TRUE; /* we already ended the grab */
         }
@@ -2742,7 +2759,10 @@ process_workspace_switch_grab (MetaDisplay *display,
 
   /* end grab */
   meta_topic (META_DEBUG_KEYBINDINGS,
-              "Ending workspace tabbing, uninteresting key pressed\n");
+              "Ending workspace tabbing & focusing default window; uninteresting key pressed\n");
+  workspace =
+    (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  meta_workspace_focus_default_window (workspace, NULL, event->xkey.time);
   return FALSE;
 }
 
@@ -2756,7 +2776,9 @@ handle_toggle_desktop (MetaDisplay    *display,
   if (screen->showing_desktop)
     {
       meta_screen_unshow_desktop (screen);
-      meta_workspace_focus_top_window (screen->active_workspace, NULL);
+      meta_workspace_focus_default_window (screen->active_workspace, 
+                                           NULL,
+                                           event->xkey.time);
     }
   else
     meta_screen_show_desktop (screen);
@@ -3192,7 +3214,7 @@ do_handle_move_to_workspace  (MetaDisplay    *display,
       /* Activate second, so the window is never unmapped */
       meta_window_change_workspace (window, workspace);
       if (flip)
-        meta_workspace_activate_with_focus (workspace, window);
+        meta_workspace_activate_with_focus (workspace, window, event->xkey.time);
     }
   else
     {
@@ -3356,7 +3378,7 @@ handle_workspace_switch  (MetaDisplay    *display,
           meta_display_end_grab_op (display, event->xkey.time);
         }
       
-      meta_workspace_activate (next);
+      meta_workspace_activate (next, event->xkey.time);
 
       if (grabbed_before_release)
         {
@@ -3368,6 +3390,7 @@ handle_workspace_switch  (MetaDisplay    *display,
     }
 }
 
+#if 0
 static void
 handle_spew_mark (MetaDisplay    *display,
                   MetaScreen     *screen,
@@ -3377,6 +3400,7 @@ handle_spew_mark (MetaDisplay    *display,
 {
   meta_verbose ("-- MARK MARK MARK MARK --\n");
 }
+#endif
 
 void
 meta_set_keybindings_disabled (gboolean setting)

src/main.c

@@ -186,11 +186,11 @@ main (int argc, char **argv)
   act.sa_handler = SIG_IGN;
   act.sa_mask    = empty_mask;
   act.sa_flags   = 0;
-  if (sigaction (SIGPIPE,  &act, 0) < 0)
+  if (sigaction (SIGPIPE,  &act, NULL) < 0)
     g_printerr ("Failed to register SIGPIPE handler: %s\n",
                 g_strerror (errno));
 #ifdef SIGXFSZ
-  if (sigaction (SIGXFSZ,  &act, 0) < 0)
+  if (sigaction (SIGXFSZ,  &act, NULL) < 0)
     g_printerr ("Failed to register SIGXFSZ handler: %s\n",
                 g_strerror (errno));
 #endif

src/menu.c

@@ -62,7 +62,7 @@ static MenuItem menuitems[] = {
   { META_MENU_OP_RESIZE, NULL, FALSE, N_("_Resize") },
   { 0, NULL, FALSE, NULL }, /* separator */
   { META_MENU_OP_DELETE, METACITY_STOCK_DELETE, FALSE, N_("_Close") },
-  { 0, NULL, FALSE, NULL }, /* separator */
+  { META_MENU_OP_WORKSPACES, NULL, FALSE, NULL }, /* separator */
   { META_MENU_OP_STICK, NULL, FALSE, N_("Put on _All Workspaces") },
   { META_MENU_OP_UNSTICK, NULL, FALSE,  N_("Only on _This Workspace") },
   { META_MENU_OP_MOVE_LEFT, NULL, FALSE, N_("Move to Workspace _Left") },
@@ -104,6 +104,7 @@ menu_closed (GtkMenu *widget,
   meta_frames_notify_menu_hide (menu->frames);
   (* menu->func) (menu, gdk_display,
                   menu->client_xwindow,
+		  gtk_get_current_event_time (),
                   0, 0,
                   menu->data);
   
@@ -122,6 +123,7 @@ activate_cb (GtkWidget *menuitem, gpointer data)
   meta_frames_notify_menu_hide (md->menu->frames);
   (* md->menu->func) (md->menu, gdk_display,
                       md->menu->client_xwindow,
+		      gtk_get_current_event_time (),
                       md->op,
                       GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem),
                                                           "workspace")),
@@ -287,7 +289,7 @@ meta_window_menu_new   (MetaFrames         *frames,
           unsigned int key;
           MetaVirtualModifier mods;
           
-          if (menuitems[i].op == 0)
+          if (menuitems[i].label == NULL)
             {
               mi = gtk_separator_menu_item_new ();
             }
@@ -419,10 +421,8 @@ meta_window_menu_new   (MetaFrames         *frames,
   else
     meta_verbose ("not creating workspace menu\n");
   
-  gtk_signal_connect (GTK_OBJECT (menu->menu),
-                      "selection_done",
-                      GTK_SIGNAL_FUNC (menu_closed),
-                      menu);  
+  g_signal_connect (menu->menu, "selection_done",
+                    G_CALLBACK (menu_closed), menu);  
 
   return menu;
 }

src/metacity-dialog.c

@@ -30,6 +30,30 @@
 #define N_(x) x
 
 #include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+
+/* FIXME: When we switch to gtk+-2.6, use of this function should be
+ * replaced by using the real gdk_x11_window_set_user_time.
+ */
+static void
+copy_of_gdk_x11_window_set_user_time (GdkWindow *window,
+                                      Time       timestamp)
+{
+  GdkDisplay *display;
+
+  g_return_if_fail (window != NULL);
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+
+  display = gdk_drawable_get_display (window);
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+                   gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_USER_TIME"),
+                   XA_CARDINAL, 32, PropModeReplace,
+                   (guchar *)&timestamp, 1);
+}
 
 static Window
 window_from_string (const char *str)
@@ -76,7 +100,8 @@ on_realize (GtkWidget *dialog,
 
 static int
 kill_window_question (const char *window_name,
-                      const char *parent_str)
+                      const char *parent_str,
+                      Time        timestamp)
 {
   GtkWidget *dialog;
   char *str, *tmp;
@@ -109,6 +134,9 @@ kill_window_question (const char *window_name,
   g_signal_connect (G_OBJECT (dialog), "realize",
                     G_CALLBACK (on_realize), (char*) parent_str);
   
+  gtk_widget_realize (dialog);
+  copy_of_gdk_x11_window_set_user_time (dialog->window, timestamp);
+
   /* return our PID, then window ID that should be killed */
   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
     g_print ("%d\n%s\n", (int) getpid (), parent_str);
@@ -220,7 +248,8 @@ create_lame_apps_list (char **lame_apps)
 }
 
 static int
-warn_about_no_sm_support (char **lame_apps)
+warn_about_no_sm_support (char **lame_apps,
+                          Time   timestamp)
 {
   GtkWidget *dialog;
   GtkWidget *list;
@@ -267,6 +296,9 @@ warn_about_no_sm_support (char **lame_apps)
                       sw,
                       TRUE, TRUE, 0);
   
+  gtk_widget_realize (dialog);
+  copy_of_gdk_x11_window_set_user_time (dialog->window, timestamp);
+
   gtk_widget_show_all (dialog);
 
   gtk_main ();
@@ -277,7 +309,8 @@ warn_about_no_sm_support (char **lame_apps)
 static int
 error_about_command (const char *gconf_key,
                      const char *command,
-                     const char *error)
+                     const char *error,
+                     Time        timestamp)
 {
   GtkWidget *dialog;
 
@@ -296,6 +329,9 @@ error_about_command (const char *gconf_key,
                                      GTK_BUTTONS_CLOSE,
                                      "%s", error);
   
+  gtk_widget_realize (dialog);
+  copy_of_gdk_x11_window_set_user_time (dialog->window, timestamp);
+
   gtk_dialog_run (GTK_DIALOG (dialog));
 
   gtk_widget_destroy (dialog);
@@ -306,52 +342,61 @@ error_about_command (const char *gconf_key,
 int
 main (int argc, char **argv)
 {
+  Time timestamp;
+
   bindtextdomain (GETTEXT_PACKAGE, METACITY_LOCALEDIR);
   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
   textdomain (GETTEXT_PACKAGE);
 
   gtk_init (&argc, &argv);
     
-  if (argc < 2)
+  if (argc < 4)
     {
       g_printerr ("bad args to metacity-dialog\n");
       return 1;
     }
-  
-  if (strcmp (argv[1], "--kill-window-question") == 0)
+
+  if (strcmp (argv[1], "--timestamp") != 0)
     {
-      if (argc < 4)
+      g_printerr ("bad args to metacity-dialog\n");
+      return 1;
+    }
+  timestamp = strtoul (argv[2], NULL, 10);
+  
+  if (strcmp (argv[3], "--kill-window-question") == 0)
+    {
+      if (argc < 6)
         {
           g_printerr ("bad args to metacity-dialog\n");
           return 1;
         }
 
-      return kill_window_question (argv[2], argv[3]);
+      return kill_window_question (argv[4], argv[5], timestamp);
     }
-  else if (strcmp (argv[1], "--warn-about-no-sm-support") == 0)
+  else if (strcmp (argv[3], "--warn-about-no-sm-support") == 0)
     {
       /* argc must be even because we want title-class pairs */
-      if (argc < 3 || (argc % 2) != 0)
+      if (argc < 5 || (argc % 2) != 0)
         {
           g_printerr ("bad args to metacity-dialog\n");
           return 1;
         }
 
-      return warn_about_no_sm_support (&argv[2]);
+      return warn_about_no_sm_support (&argv[4], timestamp);
     }
-  else if (strcmp (argv[1], "--command-failed-error") == 0)
+  else if (strcmp (argv[3], "--command-failed-error") == 0)
     {
 
       /* the args are the gconf key of the failed command, the text of
        * the command, and the error message
        */
-      if (argc != 5)
+      if (argc != 7)
         {
           g_printerr ("bad args to metacity-dialog\n");
           return 1;
         }
 
-      return error_about_command (argv[2], argv[3], argv[4]);
+      return error_about_command (argv[4], argv[5], argv[6], timestamp);
     }
   
   g_printerr ("bad args to metacity-dialog\n");

src/metacity.schemas.in

@@ -129,7 +129,7 @@
       <applyto>/apps/metacity/general/titlebar_uses_system_font</applyto>      
       <owner>metacity</owner>
       <type>bool</type>
-      <default>true</default>
+      <default>false</default>
       <locale name="C">
          <short>Use standard system font in window titles</short>
          <long> 
@@ -288,7 +288,7 @@
          <short>Activate window menu</short>
          <long>
           The keybinding used to activate the window menu.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -310,7 +310,7 @@ you set
          <short>Toggle fullscreen mode</short>
          <long>
           The keybinding used to toggle fullscreen mode.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -333,7 +333,7 @@ you set
 
           The keybinding used to toggle always on top.  A window that
 	  is always on top will always be visible over other overlapping windows.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -354,7 +354,7 @@ you set
          <short>Toggle maximization state</short>
          <long>
           The keybinding used to toggle maximization.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -372,10 +372,10 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F10</default>
       <locale name="C">
-         <short>Maximize a window</short>
+         <short>Maximize window</short>
          <long>
           The keybinding used to maximize a window
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If you set
@@ -392,10 +392,10 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F5</default>
       <locale name="C">
-         <short>Unmaximize a window</short>
+         <short>Unmaximize window</short>
          <long>
           The keybinding used to unmaximize a window.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If you set
@@ -415,7 +415,7 @@ you set
          <short>Toggle shaded state</short>
          <long>
           The keybinding used to toggle shaded/unshaded state.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -433,10 +433,10 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F4</default>
       <locale name="C">
-         <short>Close a window</short>
+         <short>Close window</short>
          <long>
           The keybinding used to close a window.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -454,10 +454,10 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F9</default>
       <locale name="C">
-         <short>Minimize a window</short>
+         <short>Minimize window</short>
          <long>
           The keybinding used to minimize a window.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -475,11 +475,11 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F7</default>
       <locale name="C">
-         <short>Move a window</short>
+         <short>Move window</short>
          <long>
           The keybinding used to enter "move mode" and begin moving a
         window using the keyboard.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -497,11 +497,11 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F8</default>
       <locale name="C">
-         <short>Resize a window</short>
+         <short>Resize window</short>
          <long>
           The keybinding used to enter "resize mode" and begin resizing a
         window using the keyboard.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -523,7 +523,7 @@ you set
          <long>
           The keybinding used to toggle whether the window is on all 
           workspaces or just one.
-          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1.
+          The format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1".
           The parser is
           fairly liberal and allows lower or upper case, and also
           abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If
@@ -546,7 +546,7 @@ you set
           The keybinding used to move a window to workspace 1.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -569,7 +569,7 @@ you set
           The keybinding used to move a window to workspace 2.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -592,7 +592,7 @@ you set
           The keybinding used to move a window to workspace 3.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -615,7 +615,7 @@ you set
           The keybinding used to move a window to workspace 4.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -638,7 +638,7 @@ you set
           The keybinding used to move a window to workspace 5.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -661,7 +661,7 @@ you set
           The keybinding used to move a window to workspace 6.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -685,7 +685,7 @@ you set
           The keybinding used to move a window to workspace 7.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -708,7 +708,7 @@ you set
           The keybinding used to move a window to workspace 8.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -731,7 +731,7 @@ you set
           The keybinding used to move a window to workspace 9.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -754,7 +754,7 @@ you set
           The keybinding used to move a window to workspace 10.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -777,7 +777,7 @@ you set
           The keybinding used to move a window to workspace 11.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -800,7 +800,7 @@ you set
           The keybinding used to move a window to workspace 12.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -824,7 +824,7 @@ you set
           The keybinding used to move a window one workspace to the left.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -849,7 +849,7 @@ you set
           The keybinding used to move a window one workspace to the right.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -873,7 +873,7 @@ you set
           The keybinding used to move a window one workspace up.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -897,7 +897,7 @@ you set
           The keybinding used to move a window one workspace down.  
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -924,7 +924,7 @@ you set
             it lowers the window below other windows.
 
             The format looks like "&lt;Control&gt;a" or
-            "&lt;Shift&gt;&lt;Alt&gt;F1.
+            "&lt;Shift&gt;&lt;Alt&gt;F1".
 
             The parser is fairly liberal and allows lower or upper case,
             and also abbreviations such as "&lt;Ctl&gt;" and
@@ -947,7 +947,7 @@ you set
             This keybinding raises the window above other windows.
 
             The format looks like "&lt;Control&gt;a" or
-            "&lt;Shift&gt;&lt;Alt&gt;F1.
+            "&lt;Shift&gt;&lt;Alt&gt;F1".
 
             The parser is fairly liberal and allows lower or upper case,
             and also abbreviations such as "&lt;Ctl&gt;" and
@@ -970,7 +970,7 @@ you set
             This keybinding lowers a window below other windows.
 
             The format looks like "&lt;Control&gt;a" or
-            "&lt;Shift&gt;&lt;Alt&gt;F1.
+            "&lt;Shift&gt;&lt;Alt&gt;F1".
 
             The parser is fairly liberal and allows lower or upper case,
             and also abbreviations such as "&lt;Ctl&gt;" and
@@ -993,7 +993,7 @@ you set
             This keybinding resizes a window to fill available vertical space.
 
             The format looks like "&lt;Control&gt;a" or
-            "&lt;Shift&gt;&lt;Alt&gt;F1.
+            "&lt;Shift&gt;&lt;Alt&gt;F1".
 
             The parser is fairly liberal and allows lower or upper case,
             and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1016,7 +1016,7 @@ you set
             This keybinding resizes a window to fill available horizontal space.
 
             The format looks like "&lt;Control&gt;a" or
-            "&lt;Shift&gt;&lt;Alt&gt;F1.
+            "&lt;Shift&gt;&lt;Alt&gt;F1".
 
             The parser is fairly liberal and allows lower or upper case,
             and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1045,7 +1045,7 @@ you set
           while using this binding reverses the direction of movement.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1070,7 +1070,7 @@ you set
           binding makes the direction go forward again.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1094,7 +1094,7 @@ you set
           the desktop, using a popup window.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1118,7 +1118,7 @@ you set
           and the desktop, using a popup window.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1144,7 +1144,7 @@ you set
           while using this binding reverses the direction of movement.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1169,7 +1169,7 @@ you set
           binding makes the direction go forward again.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1193,7 +1193,7 @@ you set
           the desktop, without a popup window.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1217,7 +1217,7 @@ you set
           the desktop, without a popup window.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1241,7 +1241,7 @@ you set
           focus to the desktop background.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1264,7 +1264,7 @@ you set
           The keybinding that switches to workspace 1.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1287,7 +1287,7 @@ you set
           The keybinding that switches to workspace 2.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1310,7 +1310,7 @@ you set
           The keybinding that switches to workspace 3.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1334,7 +1334,7 @@ you set
           The keybinding that switches to workspace 4.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1358,7 +1358,7 @@ you set
           The keybinding that switches to workspace 5.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1383,7 +1383,7 @@ you set
           The keybinding that switches to workspace 6.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1408,7 +1408,7 @@ you set
           The keybinding that switches to workspace 7.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1432,7 +1432,7 @@ you set
           The keybinding that switches to workspace 8.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1457,7 +1457,7 @@ you set
           The keybinding that switches to workspace 9.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1482,7 +1482,7 @@ you set
           The keybinding that switches to workspace 10.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1506,7 +1506,7 @@ you set
           The keybinding that switches to workspace 11.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1529,7 +1529,7 @@ you set
           The keybinding that switches to workspace 12.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1554,7 +1554,7 @@ you set
           of the current workspace.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1580,7 +1580,7 @@ you set
           of the current workspace.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1605,7 +1605,7 @@ you set
           the current workspace.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1630,7 +1630,7 @@ you set
           the current workspace.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1653,7 +1653,7 @@ you set
           The keybinding which shows the panel's main menu.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1671,13 +1671,13 @@ you set
       <type>string</type>
       <default>&lt;Alt&gt;F2</default>
       <locale name="C">
-         <short>Show the panel run dialog</short>
+         <short>Show the panel run application dialog</short>
          <long>
-          The keybinding which display's the panel's "Run Program" dialog
+          The keybinding which display's the panel's "Run Application" dialog
           box.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1700,7 +1700,7 @@ you set
           The keybinding which invokes the panel's screenshot utility.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1724,7 +1724,7 @@ you set
           to take a screenshot of a window.
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and
@@ -1759,7 +1759,7 @@ you set
           command in /apps/metacity/keybinding_commands
 
           The format looks like "&lt;Control&gt;a" or
-          "&lt;Shift&gt;&lt;Alt&gt;F1.
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
 
           The parser is fairly liberal and allows lower or upper case,
           and also abbreviations such as "&lt;Ctl&gt;" and

src/prefs.c

@@ -1975,19 +1975,19 @@ meta_prefs_get_button_layout (MetaButtonLayout *button_layout_p)
 }
 
 gboolean
-meta_prefs_get_visual_bell ()
+meta_prefs_get_visual_bell (void)
 {
   return provide_visual_bell;
 }
 
 gboolean
-meta_prefs_bell_is_audible ()
+meta_prefs_bell_is_audible (void)
 {
   return bell_is_audible;
 }
 
 MetaVisualBellType
-meta_prefs_get_visual_bell_type ()
+meta_prefs_get_visual_bell_type (void)
 {
   return visual_bell_type;
 }
@@ -2010,25 +2010,25 @@ meta_prefs_get_window_bindings (const MetaKeyPref **bindings,
 }
 
 MetaActionDoubleClickTitlebar
-meta_prefs_get_action_double_click_titlebar ()
+meta_prefs_get_action_double_click_titlebar (void)
 {
   return action_double_click_titlebar;
 }
 
 gboolean
-meta_prefs_get_auto_raise ()
+meta_prefs_get_auto_raise (void)
 {
   return auto_raise;
 }
 
 int
-meta_prefs_get_auto_raise_delay ()
+meta_prefs_get_auto_raise_delay (void)
 {
   return auto_raise_delay;
 }
 
 gboolean
-meta_prefs_get_reduced_resources ()
+meta_prefs_get_reduced_resources (void)
 {
   return reduced_resources;
 }

src/screen.c

@@ -57,6 +57,9 @@ static void set_workspace_names    (MetaScreen *screen);
 static void prefs_changed_callback (MetaPreference pref,
                                     gpointer       data);
 
+static void set_desktop_geometry_hint (MetaScreen *screen);
+static void set_desktop_viewport_hint (MetaScreen *screen);
+
 #ifdef HAVE_STARTUP_NOTIFICATION
 static void meta_screen_sn_event   (SnMonitorEvent *event,
                                     void           *user_data);
@@ -82,7 +85,7 @@ set_wm_check_hint (MetaScreen *screen)
 static int
 set_supported_hint (MetaScreen *screen)
 {
-#define N_SUPPORTED 54
+#define N_SUPPORTED 58
   Atom atoms[N_SUPPORTED];
   
   atoms[0] = screen->display->atom_net_wm_name;
@@ -139,6 +142,12 @@ set_supported_hint (MetaScreen *screen)
   atoms[51] = screen->display->atom_net_wm_action_minimize;
   atoms[52] = screen->display->atom_net_frame_extents;
   atoms[53] = screen->display->atom_net_request_frame_extents;
+  atoms[54] = screen->display->atom_net_wm_user_time;
+  atoms[55] = screen->display->atom_net_wm_state_demands_attention;
+  atoms[56] = screen->display->atom_net_desktop_geometry;
+  atoms[57] = screen->display->atom_net_desktop_viewport;
+  //atoms[58] = screen->display->atom_net_restack_window;
+  //atoms[59] = screen->display->atom_net_moveresize_window;
   
   XChangeProperty (screen->display->xdisplay, screen->xroot,
                    screen->display->atom_net_supported,
@@ -575,6 +584,10 @@ meta_screen_new (MetaDisplay *display,
   
   set_wm_check_hint (screen);
 
+  set_desktop_viewport_hint (screen);
+
+  set_desktop_geometry_hint (screen);
+
   meta_screen_update_workspace_layout (screen);
 
   /* Get current workspace */
@@ -591,7 +604,7 @@ meta_screen_new (MetaDisplay *display,
   /* Screens must have at least one workspace at all times,
    * so create that required workspace.
    */
-  meta_workspace_activate (meta_workspace_new (screen));
+  meta_workspace_activate (meta_workspace_new (screen), timestamp);
   update_num_workspaces (screen);
   
   set_workspace_names (screen);
@@ -628,7 +641,7 @@ meta_screen_new (MetaDisplay *display,
                                                 current_workspace);
     
     if (space != NULL)
-      meta_workspace_activate (space);
+      meta_workspace_activate (space, timestamp);
   }
 
   meta_compositor_manage_screen (screen->display->compositor,
@@ -965,6 +978,51 @@ set_number_of_spaces_hint (MetaScreen *screen,
   meta_error_trap_pop (screen->display, FALSE);
 }
 
+static void
+set_desktop_geometry_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  data[0] = screen->width;
+  data[1] = screen->height;
+
+  meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %ld, %ld\n", data[0], data[1]);
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom_net_desktop_geometry,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+set_desktop_viewport_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  /*
+   * Metacity does not implement viewports, so this is a fixed 0,0
+   */
+  data[0] = 0;
+  data[1] = 0;
+
+  meta_verbose ("Setting _NET_DESKTOP_VIEWPORT to 0, 0\n");
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom_net_desktop_viewport,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
 static void
 update_num_workspaces (MetaScreen *screen)
 {
@@ -1019,7 +1077,7 @@ update_num_workspaces (MetaScreen *screen)
     }
 
   if (need_change_space)
-    meta_workspace_activate (last_remaining);
+    meta_workspace_activate (last_remaining, meta_display_get_current_time_roundtrip (screen->display));
 
   /* Should now be safe to free the workspaces */
   tmp = extras;
@@ -1065,6 +1123,7 @@ meta_screen_set_cursor (MetaScreen *screen,
   
   xcursor = meta_display_create_x_cursor (screen->display, cursor);
   XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
   XFreeCursor (screen->display->xdisplay, xcursor);
 }
 
@@ -1224,9 +1283,9 @@ meta_screen_ensure_workspace_popup (MetaScreen *screen)
   /* don't show tab popup, since proper space isn't selected yet */
 }
 
-void
-meta_screen_focus_mouse_window (MetaScreen  *screen,
-                                MetaWindow  *not_this_one)
+MetaWindow*
+meta_screen_get_mouse_window (MetaScreen  *screen,
+                              MetaWindow  *not_this_one)
 {
   MetaWindow *window;
   Window root_return, child_return;
@@ -1256,22 +1315,7 @@ meta_screen_focus_mouse_window (MetaScreen  *screen,
                                                          root_x_return,
                                                          root_y_return);
 
-  /* FIXME I'm a loser on the CurrentTime front */
-  if (window)
-    {
-      meta_topic (META_DEBUG_FOCUS,
-                  "Focusing mouse window %s\n", window->desc);
-
-      meta_window_focus (window, meta_display_get_current_time (screen->display));
-
-      /* Also raise the window if in click-to-focus */
-      if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
-        meta_window_raise (window);
-    }
-  else
-    {
-      meta_topic (META_DEBUG_FOCUS, "No mouse window to focus found\n");
-    }
+  return window;
 }
 
 const MetaXineramaScreenInfo*
@@ -1725,7 +1769,7 @@ meta_create_offscreen_window (Display *xdisplay,
                         0,
                         CopyFromParent,
                         CopyFromParent,
-                        CopyFromParent,
+                        (Visual *)CopyFromParent,
                         CWOverrideRedirect | CWEventMask,
                         &attrs);
 }
@@ -2116,6 +2160,7 @@ meta_screen_resize (MetaScreen *screen,
   screen->height = height;
 
   reload_xinerama_infos (screen);
+  set_desktop_geometry_hint (screen);
   
   /* Queue a resize on all the windows */
   meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
@@ -2194,8 +2239,6 @@ meta_screen_show_desktop (MetaScreen *screen)
   queue_windows_showing (screen);
 
   update_showing_desktop_hint (screen);
-
-  meta_workspace_focus_top_window (screen->active_workspace, NULL);
 }
 
 void
@@ -2481,6 +2524,7 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
   if (sequence != NULL)
     {
       int space;
+      Time timestamp;
           
       meta_topic (META_DEBUG_STARTUP,
                   "Found startup sequence for window %s ID \"%s\"\n",
@@ -2500,6 +2544,17 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
             }
         }
 
+      if (!window->initial_timestamp_set)
+        {
+          timestamp = sn_startup_sequence_get_timestamp (sequence);
+          meta_topic (META_DEBUG_STARTUP,
+                      "Setting initial window timestamp to %lu based on startup info\n",
+                      timestamp);
+              
+          window->initial_timestamp_set = TRUE;
+          window->initial_timestamp = timestamp;
+        }
+
       return;
     }
   else

src/screen.h

@@ -148,7 +148,7 @@ void          meta_screen_ensure_tab_popup    (MetaScreen                 *scree
 
 void          meta_screen_ensure_workspace_popup (MetaScreen *screen);
 
-void          meta_screen_focus_mouse_window   (MetaScreen                 *screen,
+MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                 MetaWindow                 *not_this_one);
 
 const MetaXineramaScreenInfo* meta_screen_get_current_xinerama    (MetaScreen    *screen);

src/session.c

@@ -271,7 +271,9 @@ meta_session_init (const char *previous_client_id,
   
   if (session_connection == NULL)
     {
-      meta_warning (_("Failed to a open connection to a session manager, so window positions will not be saved: %s\n"), buf);
+      meta_topic (META_DEBUG_SM, 
+                  "Failed to a open connection to a session manager, so window positions will not be saved: %s\n",
+                  buf);
 
       goto out;
     }
@@ -1849,6 +1851,8 @@ warn_about_lame_clients_and_finish_interact (gboolean shutdown)
   GError *err;
   GIOChannel *channel;
   LameClientsDialogData *d;
+  Time timestamp;
+  char timestampbuf[32];
   
   lame = NULL;
   displays = meta_displays_list ();
@@ -1891,8 +1895,12 @@ warn_about_lame_clients_and_finish_interact (gboolean shutdown)
   
   lame = g_slist_sort (lame, (GCompareFunc) windows_cmp_by_title);
 
+  timestamp = 0;
+  sprintf (timestampbuf, "%lu", timestamp);
+
   len = g_slist_length (lame);
   len *= 2; /* titles and also classes */
+  len += 2; /* --timestamp flag and actual timestamp */
   len += 1; /* NULL term */
   len += 2; /* metacity-dialog command and option */
   
@@ -1902,6 +1910,10 @@ warn_about_lame_clients_and_finish_interact (gboolean shutdown)
 
   argv[i] = METACITY_LIBEXECDIR"/metacity-dialog";
   ++i;
+  argv[i] = "--timestamp";
+  ++i;
+  argv[i] = timestampbuf;
+  ++i;
   argv[i] = "--warn-about-no-sm-support";
   ++i;
   

src/stack.c

@@ -47,6 +47,8 @@
 #define WINDOW_IN_STACK(w) (w->stack_position >= 0)
 
 static void meta_stack_sync_to_server (MetaStack *stack);
+static void meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                                    int         position);
 
 MetaStack*
 meta_stack_new (MetaScreen *screen)
@@ -122,8 +124,8 @@ meta_stack_remove (MetaStack  *stack,
   /* Set window to top position, so removing it will not leave gaps
    * in the set of positions
    */
-  meta_window_set_stack_position (window,
-                                  stack->n_positions - 1);
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
   window->stack_position = -1;
   stack->n_positions -= 1;  
 
@@ -162,8 +164,8 @@ void
 meta_stack_raise (MetaStack  *stack,
                   MetaWindow *window)
 {  
-  meta_window_set_stack_position (window,
-                                  stack->n_positions - 1);
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
   
   meta_stack_sync_to_server (stack);
 }
@@ -172,7 +174,7 @@ void
 meta_stack_lower (MetaStack  *stack,
                   MetaWindow *window)
 {
-  meta_window_set_stack_position (window, 0);
+  meta_window_set_stack_position_no_sync (window, 0);
   
   meta_stack_sync_to_server (stack);
 }
@@ -669,7 +671,7 @@ ensure_above (MetaWindow *above,
   if (above->stack_position < below->stack_position)
     {
       /* move above to below->stack_position bumping below down the stack */
-      meta_window_set_stack_position (above, below->stack_position);
+      meta_window_set_stack_position_no_sync (above, below->stack_position);
       g_assert (below->stack_position + 1 == above->stack_position);
     }
   meta_topic (META_DEBUG_STACK, "%s above at %d > %s below at %d\n",
@@ -1465,8 +1467,8 @@ meta_stack_windows_cmp  (MetaStack  *stack,
 }
 
 void
-meta_window_set_stack_position (MetaWindow *window,
-                                int         position)
+meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                        int         position)
 {
   int low, high, delta;
   GList *tmp;
@@ -1517,3 +1519,11 @@ meta_window_set_stack_position (MetaWindow *window,
               "Window %s had stack_position set to %d\n",
               window->desc, window->stack_position);
 }
+
+void
+meta_window_set_stack_position (MetaWindow *window,
+                                int         position)
+{
+  meta_window_set_stack_position_no_sync (window, position);
+  meta_stack_sync_to_server (window->screen->stack);
+}

src/stack.h

@@ -141,7 +141,3 @@ void meta_window_set_stack_position (MetaWindow *window,
                                      int         position);
 
 #endif
-
-
-
-

src/tabpopup.c

@@ -473,7 +473,7 @@ meta_ui_tab_popup_get_selected (MetaTabPopup *popup)
       return te->key;
     }
   else
-    return None;
+    return (MetaTabEntryKey)None;
 }
 
 void

src/theme-parser.c

@@ -4350,7 +4350,7 @@ meta_theme_load (const char *theme_name,
           g_propagate_error (err, error);
           g_free (theme_file);
           g_free (theme_dir);
-          return FALSE; /* all fallbacks failed */
+          return NULL; /* all fallbacks failed */
         }
     }