Released 2.8.2

2004-08-03  Elijah Newren  <newren@math.utah.edu>

	Released 2.8.2

	* NEWS, README: update

COMPLIANCE

@@ -0,0 +1,159 @@
+Metacity Standards Compliance
+=============================
+$Id$
+
+1) Introduction
+2) EWMH Compliance
+  a. Root Window Properties
+  b. Root Window Messages
+  c. Application Window Properties
+  d. Window Manager Protocols
+3) ICCCM Compliance
+
+1) Introduction
+---------------
+
+This document details metacity compliance with the relevent standards.
+The format of this document is as follows:
+
+[-/+?] Hint Name/Feature Name (Version number)
+       Errata/Comments
+
+The first character indicates the level of compliance as follows:
+    -   none
+    /   partial
+    +   complete
+    ?   unknown
+
+The title indicates a feature or a hint in the specification, and the
+version number indicates the minimum version of the specification
+supported by metacity.  Later versions may be supported if no
+incompatible changes have been made in the specification.
+
+2) EWMH Compliance
+------------------
+
+The EWMH, or Extended Window Manager Hints is a freedesktop.org-
+developed standard to support a number of conventions for
+communication between the window manager and clients.  It builds on
+and extends the ICCCM (See Section 3).  A copy of the current EWMH
+standard is available at http://freedesktop.org/Standards/wm-spec/
+
+  a. Root Window Properties
+  -------------------------
+
++ _NET_SUPPORTED (1.3)
+
++ _NET_CLIENT_LIST (1.3)
+
++ _NET_NUMBER_OF_DESKTOPS (1.3)
+
++ _NET_DESKTOP_GEOMETRY (1.3)
+  Metacity does not implement large desktops, so this is kept set to
+  the screen size.
+
++ _NET_DESKTOP_VIEWPORT (1.3)
+  Metacity does not implement viewports, so this is a constant (0,0).
+
++ _NET_CURRENT_DESKTOP (1.3)
+
++ _NET_DESKTOP_NAMES (1.3)
+
++ _NET_ACTIVE_WINDOW (1.3)
+
++ _NET_WORKAREA (1.3)
+
++ _NET_SUPPORTING_WM_CHECK (1.3)
+
++ _NET_VIRTUAL_ROOTS (1.3)
+  Metacity does not read or set this property, but it does not use
+  virtual roots to implement virtual desktops, so it complies with the
+  specification.
+
++ _NET_DESKTOP_LAYOUT (1.3)
+
++ _NET_SHOWING_DESKTOP (1.3)
+
+  b. Root Window Messages
+  -----------------------
+
++ _NET_CLOSE_WINDOW (1.3)
+
+- _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 (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)  
+
+  c. Application Window Properties
+  --------------------------------
+
++ _NET_WM_NAME (1.3)
+
++ _NET_WM_VISIBLE_NAME (1.3)
+  Metacity does not set this property, but metacity will never display
+  a name different from _NET_WM_NAME
+
++ _NET_WM_ICON_NAME (1.3)
+
++ _NET_WM_VISIBLE_ICON_NAME (1.3)
+  Metacity does not set this property, but metacity will never display
+  a name different from _NET_WM_NAME
+
++ _NET_WM_DESKTOP (1.3)
+
++ _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_ALLOWED_ACTIONS (1.3)
+  Metacity keeps this hint up to date.  The code is somewhat crufty
+  and should be rewritten, though it is functional.
+  See: http://bugzilla.gnome.org/show_bug.cgi?id=90420
+
++ _NET_WM_STRUT (1.3)
+
++ _NET_WM_STRUT_PARTIAL (1.3)
+
++ _NET_WM_ICON_GEOMETRY (1.3)
+  Metacity uses this property to draw minimize/restore animations
+
++ _NET_WM_ICON (1.3)
+
++ _NET_WM_PID (1.3)
+
++ _NET_WM_HANDLED_ICONS (1.3)
+  Metacity does not read or set this property.  However, metacity
+  never manages iconified windows, and so has no need to do so.
+
++ _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
+  prior to the window being mapped, this may be an estimate.  This is,
+  however, expressly allowed by the specification.
+
+  d. Window Manager Protocols
+  ---------------------------
++ _NET_WM_PING (1.3)
+
+3) ICCCM Compliance
+-------------------
+TODO

ChangeLog

@@ -1,3 +1,849 @@
+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: update
+
+2004-05-02  Rob Adams  <readams@readams.net>
+
+	* src/metacity-dialog.c (warn_about_no_sm_support): make the no sm
+	support warning dialog resizable, since the default GTK warning
+	dialog not has default not resizable.  Fix for #141672 from
+	Olivier Crete.
+
+2004-04-29  Rob Adams  <readams@readams.net>
+
+	* src/prefs.c (change_notify): Add a value type check for the
+	visual bell/audible bell gconf settings.  Patch from Jarrod
+	Johnson for #141409.
+
+2004-04-19  Mark McLoughlin  <mark@skynet.ie>
+	
+        Syncing across this change from libwnck.
+	Patch from Neil Muller <neil@dip.sun.ac.za> in bug #133979.
+	
+	* src/iconcache.c: (find_largest_sizes), (find_best_size):
+	Don't down-size nitems from a gulong to an int. Fixes a
+	crash with enlightenment, apparently.
+
+2004-04-16  Iñaki Larrañaga  <dooteo@euskalgnu.org>
+
+	* configure.in: Added "eu" (Basque) to ALL_LINGUAS.
+
+2004-04-15  Elijah Newren  <newren@math.utah.edu>
+
+	* src/display.c: Prevent unwanted grab op from occurring.
+	Previously, for some people under certain conditions, clicking and
+	releasing the mouse button rapidly enough would result in Metacity
+	starting a move operation due to ignoring the button release.
+	This should fix that problem (it does for me).  See bug 136587.
+
+2004-04-11  Rob Adams  <readams@readams.net>
+
+	* configure.in: Make the --enable-xinerama switch work properly.
+	Fix for #138562 from foser@gentoo.org.
+	
+2004-04-09  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+        * configure.in: Added "gu" (Gujarati) to ALL_LINGUAS.
+
+2004-03-27  Tõivo Leedjärv  <toivo@linux.ee>
+
+	* configure.in: Added et to ALL_LINGUAS.
+
+2004-03-24  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+        * configure.in: Added "pa" (Punjabi) to ALL_LINGUAS.
+
+2004-03-21  Havoc Pennington  <hp@redhat.com>
+
+	* configure.in: 2.8.0
+
+	* NEWS: update
+
+2004-03-07  Elijah Newren  <newren@math.utah.edu>
+
+	* rationales.txt: Bring up to date (see bug 136252).
+
+2004-03-07  Havoc Pennington  <hp@redhat.com>
+
+	* configure.in: 2.7.1
+
+2004-03-04  Paisa Seeluangsawat  <paisa@users.sf.net>
+
+	* configure.in: Added "th" (Thai) to ALL_LINGUAS.
+
+2004-03-01  Rob Adams  <readams@readams.net>
+
+	* src/stack.c (compute_layer): don't promote due to transiency; we
+	handle that elsewhere now.
+	(ensure_above): perform layer promotion here as well as stack
+	position promotion.  Note that this means that we need to do stack
+	constraints now on layer change now.
+	(get_maximum_layer_of_ancestor): remove function
+	(max_layer_func): remove function
+	(MaxLayerData): remove struct
+
+2004-02-28  Rob Adams  <readams@readams.net>
+
+	Revert 2/27 patch for layer promotion.
+
+2004-02-27  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_notify_focus): only move on MRU list
+	if the window belongs on the workspace, since the FocusIn event
+	could be for a window whose workspace we've since switched away
+	from.  Possible fix for #122016.
+
+	* src/workspace.c (meta_workspace_contains_window): search for the
+	workspace in window->workspaces rather than the window in
+	workspace->windows.  Since the number of workspaces is at most 36,
+	this is a O(1) lookup rather than a O(n) lookup.  Sorry; couldn't
+	resist.
+
+2004-02-27  Rob Adams  <readams@readams.net>
+
+	* src/metacity.schemas.in: Change
+	move_to_workspace_left/right/up/down keybindings to
+	<Control><Alt><Shift> arrow to avoid conflicting with new
+	keybindings in spacial nautilus.
+
+2004-02-27  Rob Adams  <readams@readams.net>
+
+	Handle layer promotion of transient descendants of layer-promoted
+	windows to also be layer promoted, using a simple iterative
+	algorithm.
+
+	* src/stack.c (compute_layer): change name to promote_layer, and
+	convert to simply perform any necessary layer promotion without
+	computing the standalone layer.
+	(max_layer_func): use window->layer instead of
+	get_standalone_layer
+	(get_maximum_layer_of_ancestor): use window->layer instead of
+	get_standalone_layer
+	(meta_stack_ensure_sorted): implement iterative algorithm,
+	explained in a long comment.
+	
+	* src/window.h: add a tmp_layer field used by stack.c for
+	determining if the stack is dirty or not, since maintaining this
+	information in meta_stack_ensure_sorted is no longer practical.
+
+2004-02-23  Rob Adams  <readams@readams.net>
+
+	Add my copyright notice to a number of files on which it should
+	already exist.
+	
+	* src/window.c (meta_window_notify_focus): modify code to move to
+	front of MRU list so that we can have an assert that it was there
+	in the first place.  This code may be causing some crashes.  See
+	#131196.
+	
+2004-02-22  Christian Rose  <menthos@menthos.com>
+
+	* configure.in: Added "en_CA" to ALL_LINGUAS.
+
+2004-02-19  Rob Adams  <readams@readams.net>
+
+	* src/prefs.h: remove trailing comma in MetaKeyBindingAction enum.
+	Fix for #134868 thanks to bugzilla-gnome@thewrittenword.com.
+
+2004-02-16  Rob Adams  <readams@readams.net>
+
+	* src/window.c (update_move): reset drag state after shaking loose
+	or reattaching.  Fix for #132625.
+
+2004-02-15  Anders Carlsson  <andersca@gnome.org>
+
+	* src/menu.c (meta_window_menu_new): Actually translate a message,
+	don't just mark it for translation.
+
+2004-02-14  Elijah Newren  <newren@math.utah.edu>
+
+	* src/workspace.c: When moving a window to a different workspace,
+	prepend it to the mru list insted of appending it.  Fixes #134368.
+
+2004-02-14  Rob Adams  <readams@readams.net>
+
+	If we're moving a window and receive a _NET_CURRENT_DESKTOP
+	message indicating a workspace switch, bring along the drag window
+	to the new workspace, solving a potentially weird bug where the
+	window would be lost on the old workspace.  This also makes it
+	possible to implement edge flipping in an external program with
+	just a few lines of code.  Patch for #131630 from ed@catmur.co.uk.
+	
+	* src/keybindings.c (switch_to_workspace): remove function -- no
+	longer needed.
+	(handle_activate_workspace): call meta_workspace_activate instead
+	of switch_to_workspace
+
+	* src/workspace.c (meta_workspace_activate_with_focus): if we're
+	in a move grab op, bring along the drag window.
+
+2004-02-14  Rob Adams  <readams@readams.net>
+
+	* configure.in: Add configure option to not even try using
+	xinerama, to make metacity buildable on systems with no shared
+	library version of the xinerama libraries.  Patch for #134203 from
+	Julio M. Merino Vidal.
+
+2004-02-01  Rob Adams  <readams@readams.net>
+
+	* COMPLIANCE: Bring up to date with current draft EWHM.
+
+2004-01-27  James M. Cape  <jcape@ignore-your.tv>
+
+	* src/themes/Esco/metacity-theme-1.xml: Use the 'utility' frame
+	for dialogs too.
+
+2004-01-24  James M. Cape  <jcape@ignore-your.tv>
+
+	* src/themes/Esco/metacity-theme-1.xml: Updated this theme.
+
+2004-01-21  Elijah Newren  <newren@math.utah.edu>
+
+	* src/screen.c (set_supported_hint): Removed some duplicate
+	entries.
+
+2004-01-17  Rob Adams  <readams@readams.net>
+
+	* src/metacity.schemas.in: Default binding removed for
+	toggle_shaded, since we don't have anything in the graphical UI
+	for it any more.
+
+2004-01-17  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_show_menu): Don't show
+	left/right/up/down if a window is sticky.  Make "On Top"
+	insensitive for docks, splash screens, and desktops since it has
+	no effect anyway.
+
+2004-01-10  Rob Adams  <readams@readams.net>
+
+	* src/metacity.schemas.in: update default
+	action_double_click_titlebar to be toggle_maximize instead of
+	toggle_shade.  See #131126.
+	
+2004-01-10  Rob Adams  <readams@readams.net>
+
+	* src/constraints.c (meta_window_constrain): if we maximize after
+	placement, and the window is too big to fix in the work area,
+	define a sane saved_rect approximately with dimensions
+	three-quarters approximately three quarters the size of the work
+	area.  This avoids the problem where large windows would
+	unmaximize and actually get bigger.  See #93590.
+
+2004-01-09  Thomas Fitzsimmons  <fitzsim@redhat.com>
+
+	Add _NET_FRAME_EXTENTS and _NET_REQUEST_FRAME_EXTENTS.
+
+	* src/display.c: include xprops.h
+	(process_request_frame_extents): new function
+	(meta_display_open): add _NET_FRAME_EXTENTS and
+	_NET_REQUEST_FRAME_EXTENTS atoms
+	(event_callback): handle frame extents message
+
+	* src/display.h (struct _MetaDisplay): add atom_net_frame_extents
+	and atom_net_request_frame_extents
+
+	* src/theme.c (meta_pango_font_desc_get_text_height): make font_desc
+	parameter const
+
+	* src/ui.c: include prefs.h
+	(meta_ui_theme_get_frame_borders): new function
+
+	* src/window.c (update_net_frame_extents): new function
+	(meta_window_move_resize_internal): update frame extents
+	property when frame geometry changes
+
+	* src/screen.c (set_supported_hint): add atom_net_frame_extents
+	and atom_net_request_frame_extents
+
+2004-01-09  Calum Benson  <calum.benson@sun.com>
+
+	* src/themes/Atlanta/metacity-theme-1.xml:
+
+	Ensure Atlanta window buttons get larger when using large
+	print themes. Fixes #123469.
+
+2003-01-04  Rob Adams  <readams@readams.net>
+
+	Maintain the button grab for sloppy and mouse focus all the time.
+	This fixes a number of problem introduced by trying to drop the
+	grab; we now do this only for click to focus mode.  This has the
+	unfortunate effect that #102209 reappears for sloppy and mouse
+	focus, but this seems unavoidable, because of limitations in the X
+	protocol.  See #115072.
+
+	* src/display.c (meta_display_grab_focus_window_button): #if 0 the
+	section on not grabbing unless in click-to-focus mode.
+
+	* src/window.c (meta_window_notify_focus): drop focus button grab
+	on FocusIn and acquire it on FocusOut only when in click-to-focus
+	mode.
+	
+2004-01-03  Robert Sedak  <robert.sedak@sk.htnet.hr>
+
+        * configure.in: Added "hr" in ALL_LINGUAS.
+
+2003-01-02  Rob Adams  <readams@readams.net>
+
+	* README: Update reference to EWMH.
+
+	* HACKING: Add a reference to COMPLIANCE and to the ICCCM and
+	EWHM.
+
+2003-12-25  Havoc Pennington  <hp@redhat.com>
+
+	* src/compositor.c (process_reparent): handle ReparentNotify, and
+	add a lot of debug output.
+
+2003-12-25  Havoc Pennington  <hp@redhat.com>
+
+	* src/compositor.c (meta_compositor_process_event): change to
+	track all children of the root window, not only mapped children;
+	this keeps us from losing track of the stacking order
+
+	* src/display.c (event_callback): don't do any of the compositor
+	event handling inline, do it all in compositor.c
+
+2003-12-21  Rob Adams  <readams@readams.net
+
+	* src/main.c (main): fix minor punctuation error in a string.  Fix
+	for #129805.
+
+2003-12-20  Rob Adams  <readams@readams.net>
+
+	Reorganize the window menu according to discussion on #110904.
+	The workspace name mnemonic chunk of the patch is thanks to
+	Jonathan Blandford.
+	
+	* src/common.h: add MENU_OP_ABOVE, MENU_OP_UNABOVE, MENU_UP_MOVE_TO_*
+	menu ops.
+
+	* src/core.c (meta_core_get_menu_accelerator): add accelerator for
+	the new menu ops.
+
+	* src/menu.c: add checked attribute in _MenuItem struct to display
+	a checkmark next to a menu item.  Add the new menu items to
+	menuitems.
+	(get_workspace_name_with_accel): Add mnemonics even to renamed
+	workspaces.
+	(menu_item_new): provide support for the checked attribute
+	(meta_window_menu_new): construct new submenu for workspace
+	switching.
+
+	* src/window.c (menu_callback): implement support for the new menu
+	ops.
+	(meta_window_show_menu): don't use the OP_*SHAPE operations, and
+	compute which of the OP_MOVE_TO_* ops should be used for the
+	current workspace and workspace layout.  Add the OP_*ABOVE
+	operations.
+	
+2003-12-20  Arafat Medini <lumina@silverpen.de>
+
+	* configure.in: Added Arabic locale "ar" to ALL_LINGUAS
+
+2003-12-17  Rob Adams  <readams@readams.net>
+
+	* src/display.c (meta_display_open): initialize
+	grab_wireframe_active to FALSE.  Fix for #128090.
+
+2003-12-17  Rob Adams  <readams@readams.net>
+
+	* src/tabpopup.c (meta_ui_tab_popup_new): Don't try to call
+	utf8_strndup on a null title for an entry.  Fix for #128566.
+
+	* src/workspace.c (meta_workspace_free): Call g_list_free on the
+	mru_list, since with sticky windows that MRU list could well not
+	be emtpy.  See #122016.
+
+2003-12-13  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_new_with_attrs): set on_all_workspaces
+	in all cases _before_ adding to the workspaces, so that windows
+	initially on all workspaces are added correctly to the MRU lists.
+	Fix for #120907.
+
+	* src/workspace.c (meta_workspace_add_window): handle sticky
+	windows so that we add to add mru lists if needed
+	(meta_workspace_remove_window): handle sticky windows so that they
+	are removed from all mru lists if needed.
+
+2003-12-12  Havoc Pennington  <hp@redhat.com>
+
+	* src/window.c (meta_window_free): unstick window to get it out of
+	mru_list it should not be in; assert that window has been removed
+	from all mru_list. Perhaps fixes #122016 crash.
+
+2003-11-29  Havoc Pennington  <hp@redhat.com>
+
+	* fix up compositing manager to somewhat work
+
+2003-11-26  Rob Adams  <readams@readams.net>
+
+	* COMPLIANCE: fix a couple of minor typos.
+
+2003-11-24  Havoc Pennington  <hp@redhat.com>
+
+	* src/compositor.c (meta_compositor_new): fix the extension checks
+
+2003-11-24  Havoc Pennington  <hp@redhat.com>
+
+	* src/iconcache.c (meta_icon_cache_init): init prev_mask field
+
+	* src/window.c (meta_window_new_with_attrs): init xgroup_leader
+	prior to use
+
+2003-11-24  Havoc Pennington  <hp@redhat.com>
+
+	* src/display.c (meta_display_begin_grab_op): add an event_serial
+	argument and use it when the pointer is already grabbed
+	automatically on the button press. May fix bug #126871
+
+2003-11-24  Havoc Pennington  <hp@redhat.com>
+
+	* Apply patch from Gregory Merchan to avoid using CurrentTime when
+	setting input focus. Bug #108881
+
+2003-11-23  Havoc Pennington  <hp@redhat.com>
+
+	* src/compositor.c: move xcompmgr code in here (minus drop
+	shadows), untested since Keith's server just crashes at the
+	moment. "It compiles"
+
+2003-11-20  Havoc Pennington  <hp@redhat.com>
+
+	* src/window.c (meta_window_new_with_attrs): new function
+
+	* src/display.c, src/screen.c: create the compositor and feed
+	windows and events to it
+
+2003-11-20  Havoc Pennington  <hp@redhat.com>
+
+	* src/window.c (meta_window_notify_focus): revert the change here
+	
+2003-11-17  Rob Adams  <readams@readams.net
+
+	* src/window.c (set_allowed_actions_hint): increment i between
+	resize and fullscreen.
+
+2003-11-16  Rob Adams  <readams@readams.net>
+
+	Create COMPLIANCE document describing metacity specification
+	compliance.  Right now gives detailed EWMH compliance; still need
+	to add ICCCM compliance information.  Also some minor fixes to
+	bring metacity into compliance on some points.
+	
+	* COMPLIANCE: new file
+
+	* src/display.h, src/display.c (meta_display_open),
+	src/screen.c (set_supported_hint): add
+	atom_net_wm_action_fullscreen and atom_net_wm_action_minimize
+
+	* src/window.c (set_allowed_actions_hint): some fixes to which
+	hints to set and add fullscreen and minimize.
+	
+2003-11-16  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_notify_focus): add paranoia check to
+	make sure a window is really on a workspace before inserting it at
+	the beginning of the MRU list.  Maybe there's a race condition
+	with focusing and workspace switching.  Hopefully a fix for
+	#122016.
+
+2003-11-15  Havoc Pennington  <hp@redhat.com>
+
+	* src/main.c (main): fix warning
+
+	* src/compositor.c: add a new file to contain compositing manager
+	functionality; not yet implemented at all.
+
+2003-11-15  Rob Adams  <readams@readams.net>
+
+	Inherit visual from frame window so that metacity will work with
+	the new compositing manager extension work by Keith on
+	freedesktop.org, so that ARGB windows can be full
+	alpha-transparent without a metacity frame getting drawn in the
+	background.  In the long term, we need to actually set alpha
+	values when drawing the frame so that it will really work; this is
+	a stopgap solution.  Patch from Keith Packard; see Bug 126875.
+	
+	* src/frame.c (meta_window_ensure_frame): pass client visual to
+	frame.
+
+	* src/ui.[ch] (meta_ui_create_frame_window): add new xvisual
+	parameter and use it to create new window.
+	
+2003-11-15  Rob Adams  <readams@readams.net>
+
+	* src/window.c (update_net_wm_type): don't set window->type_atom
+	here so that the type-inference code will actually be called.  Fix
+	for #126873 from Keith Packard.
+
+2003-11-08  Rob Adams  <readams@readams.net>
+
+	* src/window.c (meta_window_move_resize_internal): configure frame
+	first if we grow more than we shrink combined in both dimensions.
+	Patch from Soren Sandmann for #108925.
+
+2003-11-07  Rob Adams  <readams@readams.net>
+
+	* src/place.c (meta_window_place): use maximize_after_placement to
+	automaximize in meta_window_place; avoids a problem with not
+	recalculating the frame geometry after auto-maximizing.
+
+2003-11-07  Rob Adams  <readams@readams.net>
+
+	* src/window.c (window_should_be_showing): show the window if it's
+	a transient of a dock or desktop, since otherwise such windows are
+	invisible in show desktop mode.  Fix for #124648.
+
+2003-11-07  Rob Adams  <readams@readams.net>
+
+	* src/main.c (main): Try harder to find a theme in the event that
+	the theme in the preference cannot be found.  Patch from Marcin
+	Krzyzanowski.  See #125815.
+
+	* src/place.c (meta_window_place): use "visual" centering for
+	dialog placement and clip new dialogs to an xinerama workspace.
+	Fix for #118336.
+
+2003-10-30  Havoc Pennington  <hp@redhat.com>
+
+	* src/menu.c (meta_window_menu_new): patch to avoid creating
+	stick/unstick menu items when only one workspace, bug #116563
+	from Michael Terry
+
+2003-10-25  Havoc Pennington  <hp@redhat.com>
+
+	* src/window.c (meta_window_notify_focus): if a window is focused
+	which is not either a dock or a transient in the same group as a
+	dock, shuffle all dock/desktop windows to the end of the MRU list
+	so they won't annoyingly get focus all the time. #123816
+
+2003-10-15  Yukihiro Nakai  <nakai@gnome.gr.jp>
+
+	Gettextize metacity-theme-viewer. #121747
+
+	* src/theme-viewer.c: gettextize.
+	* po/POTFILES.in: Add src/theme-viewer.c
+
+2003-10-13  Havoc Pennington  <hp@redhat.com>
+
+        In the "prefs cause code complexity" department, here's a "sloppy
+	focus die die die" kind of moment.
+
+	* src/display.c (meta_display_grab_focus_window_button): don't
+	grab in sloppy focus mode, since we were dropping the grab on
+	window enter anyway this just removes races from the current
+	behavior.
+
+	* src/display.c (prefs_changed_callback): ungrab/grab on focus
+	mode changes, since we treat sloppy and click differently.
+	
+2003-10-12  Havoc Pennington  <hp@redhat.com>
+
+        Merge reduced_resources mode patch from the branch. Offers
+	wireframe and no-animations.
+	
+	* src/window.c (implement_showing): no animation if we are 
+	in reduced resources mode
+
+	* src/prefs.c: add REDUCED_RESOURCES pref
+
+	* src/window.c (meta_window_update_keyboard_resize): fix to 
+	modify grab_anchor_window_pos to grab_wireframe_rect if 
+	appropriate instead of window->rect
+
+	* src/display.h (struct _MetaDisplay): add grab_start_serial used
+	to avoid responding to events that occurred prior to the grab
+	initialization.
+
+	Still broken in various ways, specifically EnterNotify that
+	occurred prior to XGrabPointer is processed as if it occurred
+	after.
+	
+	* src/window.c (meta_window_update_keyboard_move): add this
+	instead of meta_window_warp_pointer() crack
+
+	* src/effects.c (meta_effects_update_wireframe): draw a kind of
+	grid for the wireframe, instead of just a rectangle, like twm
+
+	* src/screen.c (meta_screen_new): line width of 3 for the XOR gc
+
+        "Reduced resources" mode based on wireframe patch from
+	Erwann Chenede. Still pretty buggy.
+	
+	* src/keybindings.c (process_keyboard_move_grab)
+	(process_keyboard_resize_grab): add gruesome wireframe hacks
+
+	* src/display.c (meta_display_end_grab_op): end wireframe
+	(meta_display_begin_grab_op): begin wireframe
+
+	* src/effects.c (meta_effects_end_wireframe) 
+	(meta_effects_update_wireframe, meta_effects_begin_wireframe): 
+	routines to draw the wireframe stuff
+
+	* src/window.c (window_should_be_showing): hide window when 
+	doing wireframe, commented out as it breaks grab
+	* src/window.c (meta_window_refresh_resize_popup): handle wireframe
+
+	* src/screen.c (meta_screen_new): create a screen->root_xor_gc 
+	for use in drawing wireframes
+	
+	* src/frames.c (meta_frames_push_delay_exposes): repaint
+	everything before we delay
+
+2003-10-11  Havoc Pennington  <hp@pobox.com>
+
+	* src/display.c (meta_display_begin_grab_op): initialize
+	display->grab_have_pointer to FALSE, previously I think you could
+	get a case where we didn't have the grab and thought we did.
+	Bugs were reported with this happening. Of course we still have
+	the "why did the grab fail" problem, but it should be less
+	noticeable with this fixed.
+
+2003-10-06  Rob Adams  <readams@readams.net>
+
+	* src/constraints.c (constraint_onscreen_*_func): disable onscreen
+	resize constraints for right, left, and bottom, since there is no
+	way to violate onscreen constraints by resizing in these
+	directions and the code to implement the constraints made some
+	incorrect assumptions.  Fix for #120701, #120756, #123165,
+	#123631, #123838.
+
+2003-10-06  Žygimantas Beručka  <uid0@tuxfamily.org>
+
+	* configure.in: Added "lt" to ALL_LINGUAS
+
 2003-10-01  Havoc Pennington  <hp@redhat.com>
 
 	* NEWS: update

HACKING

@@ -101,4 +101,9 @@ be NULL.
 
 The code could use cleanup in a lot of places, feel free to do so.
 
-
+Metacity is ideally a fully ICCCM and EWMH-compliant window manager.
+Reading these specifications is a useful first step to understanding
+the role of a window manager on an X11 desktop and the standards and
+conventions on which X11 desktops are based.  Please refer to the
+COMPLIANCE file for additional information on these specifications and
+metacity's compliance therewith.

NEWS

@@ -1,3 +1,75 @@
+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
+===
+
+Thanks to Olivier Crete, Jarrod Johnson, Neil Muller, Elijah Newren,
+Mark McLoughlin, Rob Adams, and foser AT gentoo.org for fixes in this
+release.
+
+  - make the --enable-xinerama switch work properly
+  - prevent unwanted grab op from occurring
+  - don't down-size nitems from a gulong to an int
+  - add a value type check for the visual/audible bell gconf settings
+  - make the no sm support warning resizable
+  - more translations
+
+2.8.0
+===
+
+No code changes in this release, but some new translations.
+
+2.7.1
+===
+
+Thanks to Rob Adams for fixes in this release.
+
+ - bug #122016 - fix a focus race
+ - Change move_to_workspace_left/right/up/down keybindings to
+   <Control><Alt><Shift> arrow to avoid conflicting with new
+   keybindings in spacial nautilus.
+ - fix dialog stacking order issues so e.g. panel properties 
+   dialog is above the panel
+
+2.7.0
+===
+
+First unstable release tarball for GNOME 2.6.
+
+Thanks to Anders Carlsson, Elijah Newren, Rob Adams, James Cape,
+Thomas Fitzimmons, Calum Benson for fixes in this release.
+
 2.6.2
 ===
 

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
+The stable releases so far are 2.4.x, 2.6.x, 2.8.0, 2.8.1, 2.8.1.x
 
-Unstable branches are 2.3.x, 2.5.x
+Unstable branches are 2.3.x, 2.5.x, 2.8.y (where y>=2)
 
 COMPILING METACITY
 ===
@@ -39,9 +39,9 @@ See the HACKING file for some notes on hacking Metacity.
 SHRINKING METACITY
 ===
 
-Not that metacity is huge (<400K binary last I checked), but about
-half of that is in the preferences handling, in static strings that
-aren't essential, and in the theme engine.
+Not that metacity is huge, but a substantial amount of code is in
+preferences handling, in static strings that aren't essential, and in
+the theme engine.
 
 You can strip about 70K from the metacity binary by compiling with 
 options such as:
@@ -187,11 +187,10 @@ METACITY FEATURES
      be respawned. It theoretically restores sizes/positions/workspace
      for session-aware applications.
 
- - Metacity implements much of the new window manager spec from
-   freedesktop.org
-   (http://www.freedesktop.org/standards/wm-spec.html), and much of
-   the ICCCM. But then there are parts of each that it doesn't
-   implement, just because I haven't yet.
+ - Metacity implements much of the EWMH window manager specification
+   from freedesktop.org, as well as the older ICCCM.  Please refer to
+   the COMPLIANCE file for information on metacity compliance with
+   these standards.
 
  - Uses Pango to render text, so has cool i18n capabilities. 
    Supports UTF-8 window titles and such.
@@ -370,12 +369,11 @@ A: This one is also in rationales.txt. Because "ouija board" UI, where
      http://pobox.com/~hp/free-software-ui.html
      http://pobox.com/~hp/features.html   
 
-Q: Why no wireframe move/resize?
+Q: Why does wireframe move/resize suck?
 
-A: It's implemented in a patch that will be merged for GNOME 2.6
-   and is already in some vendor packages.
+A: You can turn it on with the reduced_resources setting.
 
-   But: Because it has low usability, and is a pain
+   But: it has low usability, and is a pain
    to implement, and there's no reason opaque move/resize should be a
    problem on any setup that can run a modern desktop worth a darn to
    begin with.

configure.in

@@ -4,8 +4,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.6.2)
+# 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.2)
 
 # Honor aclocal flags
 ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"
@@ -125,6 +127,8 @@ AC_ARG_ENABLE(sm,       [  --disable-sm             disable metacity's session m
 
 AC_ARG_ENABLE(startup-notification,   [  --disable-startup-notification             disable metacity's startup notification support, for embedded/size-sensitive custom non-GNOME builds],,enable_startup_notification=auto)
 
+AC_ARG_ENABLE(compositor,   [  --disable-compositor             disable metacity's compositing manager],,enable_compositor=auto)
+
 AC_ARG_ENABLE(xsync,       [  --disable-xsync             disable metacity's use of the XSync extension],,enable_xsync=auto)
 
 AC_ARG_ENABLE(shape,       [  --disable-shape             disable metacity's use of the shaped window extension],,enable_shape=auto)
@@ -132,7 +136,7 @@ AC_ARG_ENABLE(shape,       [  --disable-shape             disable metacity's use
 ## try definining HAVE_BACKTRACE
 AC_CHECK_HEADERS(execinfo.h, [AC_CHECK_FUNCS(backtrace)])
 
-ALL_LINGUAS="am az be bg bn ca cs cy da de el en_GB es fa fi fr ga gl he hi hu id is it ja ko lv mk ml mn ms nl nn no pl pt pt_BR ro ru sl sk sq sr sr@Latn sv ta tr uk vi wa zh_CN zh_TW"
+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"
 AM_GLIB_GNU_GETTEXT
 
 ## here we get the flags we'll actually use
@@ -149,7 +153,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
@@ -175,6 +179,32 @@ else
   echo "Building without libstartup-notification"
 fi
 
+XCOMPOSITE_VERSION=1.0
+AC_MSG_CHECKING([Xcomposite >= $XCOMPOSITE_VERSION])
+if $PKG_CONFIG --atleast-version $XCOMPOSITE_VERSION xcomposite; then
+   have_xcomposite=yes
+else
+   have_xcomposite=no
+fi
+AC_MSG_RESULT($have_xcomposite)
+
+if test x$enable_compositor = xyes; then
+   have_xcomposite=yes
+   echo "CompositeExt support forced on"
+elif test x$enable_compositor = xauto; then
+   true
+else
+   have_xcomposite=no
+fi
+
+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])
+else
+  echo "Building without compositing manager"
+fi
+
 PKG_CHECK_MODULES(METACITY, $METACITY_PC_MODULES)
 
 AC_PATH_XTRA
@@ -185,46 +215,51 @@ ALL_X_LIBS="$X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
 metacity_save_cppflags="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS $X_CFLAGS"
 
+AC_ARG_ENABLE(xinerama,[  --disable-xinerama          disable metacity's use of the Xinerama extension],
+              try_xinerama=$enable_xinerama,try_xinerama=yes)
+
 use_solaris_xinerama=no
 use_xfree_xinerama=no
-case "$host" in
-    *-*-solaris*)
-        # Check for solaris
-        use_solaris_xinerama=yes
-        AC_CHECK_LIB(Xext, XineramaGetInfo,
-        	     use_solaris_xinerama=yes, use_solaris_xinerama=no,
-                     $ALL_X_LIBS)
-        if test "x$use_solaris_xinerama" = "xyes"; then
-            AC_CHECK_HEADER(X11/extensions/xinerama.h,
-                      	    if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
-                                X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
-        	            fi
-                            AC_DEFINE(HAVE_SOLARIS_XINERAMA, , [Have Solaris-style Xinerama])
-          	            AC_DEFINE(HAVE_XINERAMA, , [Have some version of Xinerama]),
-                            use_solaris_xinerama=no,
-                            [#include <X11/Xlib.h>])
-        fi	
-        AC_MSG_CHECKING(for Xinerama support on Solaris)
-        AC_MSG_RESULT($use_solaris_xinerama);
-        ;;
-    *)
-        # Check for XFree
-        use_xfree_xinerama=yes
-        AC_CHECK_LIB(Xinerama, XineramaQueryExtension,
-            [AC_CHECK_HEADER(X11/extensions/Xinerama.h,
-       	                     X_EXTRA_LIBS="-lXinerama $X_EXTRA_LIBS"   
-      	                     if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
-             	                 X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
-      	                     fi
-        	             AC_DEFINE(HAVE_XFREE_XINERAMA, , [Have XFree86-style Xinerama])
-      	                     AC_DEFINE(HAVE_XINERAMA,, [Have some version of Xinerama]), 
-      	                     use_xfree_xinerama=no,
-                             [#include <X11/Xlib.h>])],
-            use_xfree_xinerama=no, -lXext $ALL_X_LIBS)
-        AC_MSG_CHECKING(for Xinerama support on XFree86)
-        AC_MSG_RESULT($use_xfree_xinerama);
-        ;;
-esac
+if test "${try_xinerama}" != no; then
+    case "$host" in
+        *-*-solaris*)
+            # Check for solaris
+            use_solaris_xinerama=yes
+            AC_CHECK_LIB(Xext, XineramaGetInfo,
+                         use_solaris_xinerama=yes, use_solaris_xinerama=no,
+                         $ALL_X_LIBS)
+            if test "x$use_solaris_xinerama" = "xyes"; then
+                AC_CHECK_HEADER(X11/extensions/xinerama.h,
+                                if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
+                                    X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
+                                fi
+                                AC_DEFINE(HAVE_SOLARIS_XINERAMA, , [Have Solaris-style Xinerama])
+                                AC_DEFINE(HAVE_XINERAMA, , [Have some version of Xinerama]),
+                                use_solaris_xinerama=no,
+                                [#include <X11/Xlib.h>])
+            fi	
+            AC_MSG_CHECKING(for Xinerama support on Solaris)
+            AC_MSG_RESULT($use_solaris_xinerama);
+            ;;
+        *)
+            # Check for XFree
+            use_xfree_xinerama=yes
+            AC_CHECK_LIB(Xinerama, XineramaQueryExtension,
+                [AC_CHECK_HEADER(X11/extensions/Xinerama.h,
+                                 X_EXTRA_LIBS="-lXinerama $X_EXTRA_LIBS"   
+                                 if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
+                                     X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
+                                 fi
+                                 AC_DEFINE(HAVE_XFREE_XINERAMA, , [Have XFree86-style Xinerama])
+                                 AC_DEFINE(HAVE_XINERAMA,, [Have some version of Xinerama]), 
+                                 use_xfree_xinerama=no,
+                                 [#include <X11/Xlib.h>])],
+                use_xfree_xinerama=no, -lXext $ALL_X_LIBS)
+            AC_MSG_CHECKING(for Xinerama support on XFree86)
+            AC_MSG_RESULT($use_xfree_xinerama);
+            ;;
+    esac
+fi
 
 CPPFLAGS="$metacity_save_cppflags"
 
@@ -399,10 +434,11 @@ metacity-$VERSION:
 	XFree86 Xinerama:         ${use_xfree_xinerama}
 	Solaris Xinerama:         ${use_solaris_xinerama}
 	Startup notification:     ${have_startup_notification}
+	Compositing manager:      ${have_xcomposite}
 	Session management:       ${found_sm}
 	Shape extension:          ${found_shape}
 	Resize-and-rotate:        ${found_randr}
 	Xsync:                    ${found_xsync}
         Deprecated config dialog: ${enable_config_dialog}
 "
-## echo "This is the UNSTABLE branch of metacity, use 2.4.x for stable (gnome-2-2 branch in CVS)"
+echo "This is the UNSTABLE branch of metacity, use 2.8.1.x for stable (gnome-2-6 branch in CVS)"

po/ChangeLog

@@ -1,3 +1,505 @@
+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.
+
+2004-04-16  Iñaki Larrañaga  <dooteo@euskalgnu.org>
+
+	* eu.po: Added Basque translation.
+
+2004-04-15  Andras Timar  <timar@gnome.hu>
+
+	* hu.po: Updated Hungarian translation.
+
+2004-04-09  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+        * gu.po: Added Gujurati translation by
+        Gujarati Team <magnet@magnet-i.com>.
+
+2004-04-06  Mohammad DAMT  <mdamt@bisnisweb.com>
+
+	* id.po: Updated Indonesian translation
+
+2004-04-03  Mugurel Tudor  <mugurelu@go.ro>
+
+	* ro.po: Updated Romanian translation
+
+2004-03-29  Jordi Mallach  <jordi@sindominio.net>
+
+	* ca.po: Updated Catalan translation.
+
+2004-03-27  Tõivo Leedjärv  <toivo@linux.ee>
+
+	* et.po: Added Estonian translation.
+
+2004-03-24  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+        * pa.po: Added Punjabi translation by
+        Jaswinder Singh Phulewala <jaswinderlinux@netscape.net>.
+
+2004-03-20  Mugurel Tudor  <mugurelu@go.ro>
+
+	* ro.po: Updated Romanian translation.
+
+2004-03-20  Gareth Owen  <gowen72@yahoo.com>
+
+	* en_GB.po: Updated British translation
+
+2004-03-19  Andras Timar  <timar@gnome.hu>
+
+	* hu.po: Updated Hungarian translation.
+
+2004-03-18  Arafat Medini  <lumina@silverpen.de>
+
+	* ar.po: Updated Arabic translation.
+
+2004-03-17  Leonid Kanter  <leon@asplinux.ru>
+
+	* ru.po: Updated Russian translation
+
+2004-03-16  Dafydd Harries  <daf@muse.19inch.net>
+
+	* cy.po: Updated Welsh translation.
+
+2004-03-15  Alessio Frusciante  <algol@firenze.linux.it>
+
+	* it.po: Updated Italian translation by
+	Luca Ferretti <elle.uca@infinito.it>.
+
+2004-03-15  Nikos Charonitakis  <frolix68@yahoo.gr>
+
+	* el.po: Updated Greek translation.
+
+2004-03-14  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2004-03-13  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2004-03-13  Theppitak Karoonboonyanan  <thep@linux.thai.net>
+
+	* th.po: Updated Thai translation.
+
+2004-03-12  Funda Wang  <fundawang@linux.net.cn>
+
+	* zh_CN.po: Updated Simplified Chinese translation.
+
+2004-03-12  Yuriy Syrota  <rasta@cvs.gnome.org>
+
+	* uk.po: Updated Ukrainian translation.
+
+2004-03-11  Alessio Frusciante  <algol@firenze.linux.it>
+
+	* it.po: Updated Italian translation.
+
+2004-03-11  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2004-03-10  Theppitak Karoonboonyanan  <thep@linux.thai.net>
+
+	* th.po: Updated Thai translation.
+
+2004-03-09  Alessio Frusciante  <algol@firenze.linux.it>
+
+	* it.po: Updated Italian translation by
+	Luca Ferretti <elle.uca@infinito.it>.
+
+2004-03-09  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* no.po: Updated Norwegian translation.
+
+2004-03-09  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spansih translation.
+
+2004-03-08 Alastair McKinstry <mckinstry@computer.org>
+
+	* ga.po: Updated Irish translation.
+
+2004-03-08  Theppitak Karoonboonyanan  <thep@linux.thai.net>
+
+	* th.po: Updated Thai translation.
+
+2004-03-06  Mətin Əmirov  <metin@karegen.com>
+
+	* az.po: Translation updated.
+
+2004-03-07  Funda Wang  <fundawang@linux.net.cn>
+
+	* zh_CN.po: Updated Simplified Chinese translation.
+
+2004-03-04  Paisa Seeluangsawat  <paisa@users.sf.net>
+
+	* th.po: Added Thai translation.
+
+2004-03-3  Arafat Medini  <lumina@silverpen.de>
+
+	* ar.po: Updated Arabic translation.
+
+2004-03-02  Stanislav Visnovsky <visnovsky@kde.org>
+
+	* sk.po: Convert to UTF-8.
+
+2004-02-26  Guntupalli Karunakar  <karunakar@freedomink.org>
+
+	* hi.po: Updated Hindi translations.
+
+2004-02-23  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-02-22  Christian Rose  <menthos@menthos.com>
+
+	* en_CA.po: Added Canadian English translation by
+	Adam Weinberger <adamw@FreeBSD.org>.
+
+2004-02-17  Takeshi AIHANA <aihana@gnome.gr.jp>
+
+	* ja.po: Updated Japanese translation.
+
+2004-02-11  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* no.po: Updated Norwegian translation.
+
+2004-02-07  Robert Sedak  <robert.sedak@sk.htnet.hr>
+ 
+         * hr.po: Updated Croatian translation.
+
+2004-02-08  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2004-02-05  Pauli Virtanen  <pauli.virtanen@hut.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2004-02-03  Kostas Papadimas <pkst@gnome.org>
+
+	* el.po: Updated  Greek translation.
+
+2004-02-02  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-02-01  Ole Laursen  <olau@hardworking.dk>
+
+	* da.po: Updated Danish translation.
+
+2004-01-31  Mətin Əmirov  <metin@karegen.com>
+
+	* az.po: Translation updated.
+
+2004-01-28  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Fixed Czech translation.
+
+2004-01-20  Artur Flinta  <aflinta@cvs.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2004-01-18  Christian Neumair  <chris@gnome-de.org>
+
+	* de.po: Updated German translation.
+
+2004-01-16  Hasbullah Bin Pit <sebol@ikhlas.com>
+
+	* ms.po: Updated Malay translation.
+
+2004-01-15  Laurent Dhima  <laurenti@alblinux.net>
+
+	* sq.po: Updated Albanian translation.
+
+2004-01-13  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* no.po: Updated Norwegian translation.
+
+2004-01-13  Artur Flinta  <aflinta@cvs.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2004-01-12  Žygimantas Beručka  <uid0@tuxfamily.org>
+
+	* lt.po: Updated Lithuanian translation by Tomas Kuliavas.
+
+2004-01-11  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2004-01-11  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2004-01-05  Vincent van Adrighem  <adrighem@gnome.org>
+
+	* nl.po: Translation updated by Tino Meinen.
+
+2004-01-04  Duarte Loreto <happyguy_pt@hotmail.com>
+
+	* pt.po: Updated and revised Portuguese translation.
+
+2004-01-03  Sanlig Badral  <badral@openmn.org>
+
+	* mn.po: Updated Mongolian translation.
+
+2004-01-03  Robert Sedak  <robert.sedak@sk.htnet.hr>
+
+	* hr.po: Updated Croatian translation.
+
+2004-01-02  Sanlig Badral  <Badral@openmn.org>
+
+	* mn.po: Updated Mongolian translation.
+    
+2004-01-02  Taneem Ahmed  <taneem@bengalinux.org>
+
+	* bn.po: Updated Bangla (Bengali) translation.
+
+2003-12-29  Christian Neumair  <chris@gnome-de.org>
+
+	* de.po: Updated German translation.
+
+2003-12-29  Åsmund Skjæveland  <aasmunds@fys.uio.no>
+
+	* nn.po: Updated Norwegian Nynorsk translation.
+
+2003-12-24  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation.
+
+2003-12-23  Gustavo Noronha Silva  <kov@debian.org>
+
+	* pt_BR.po: updated translation.
+
+2003-12-22  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Updated Czech translation.
+
+2003-12-22  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2003-12-22  Christian Rose  <menthos@menthos.com>
+
+	* sv.po: Updated Swedish translation.
+
+2003-12-21  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation.
+
+2003-12-21  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2003-12-20  Arafat Medini <lumina@silverpen.de>
+
+	* ar.po: Added Arabic translation.
+
+2003-12-19  Gustavo Noronha Silva  <kov@debian.org>
+
+	* pt_BR.po: updated translation.
+
+2003-12-18  Yukihiro Nakai  <nakai@gnome.gr.jp>
+
+	* ja.po: Minor update.
+
+2003-12-14  Francisco Javier F. Serrador  <serrador@cvs.gnome.org>
+
+	* es.po: Updated Spanish translation
+
+2003-12-04  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Cleared up Serbian translation.
+
+2003-12-03  Sanlig Badral  <badral@openmn.org>
+
+	* mn.po: Updated Mongolian translation. 
+
+2003-12-02  Miloslav Trmac  <mitr@volny.cz>
+
+	* cs.po: Updated Czech translation.
+
+2003-11-29  Ole Laursen  <olau@hardworking.dk>
+
+	* da.po: Updated Danish translation.
+
+2003-11-26   Vincent van Adrighem  <adrighem@gnome.org>
+
+	* nl.po: Dutch translation updated by Vincent van Adrighem.
+
+2003-11-10  Pablo Gonzalo del Campo  <pablodc@bigfoot.com>
+
+        * es.po: Updated Spanish translation by
+                 Francisco Javier F. Serrador <serrador@arrakis.es>.
+		 
+2003-11-08  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2003-10-30  Kostas Papadimas <pkst@gnome.org>
+
+	* el.po: Updated Greek translation.
+
+2003-10-20  Andras Timar  <timar@gnome.hu>
+
+	* hu.po: Updated Hungarian translation.
+
+2003-10-15  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2003-10-15  Yukihiro Nakai  <nakai@gnome.gr.jp>
+
+	* ja.pp: Update Japanese translation.
+
+2003-10-13  Danilo Šegan  <dsegan@gmx.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2003-10-08  Andras Timar  <timar@gnome.hu>
+
+	* hu.po: Updated Hungarian translation.
+
+2003-10-06  Žygimantas Beručka  <uid0@tuxfamily.org>
+
+	* lt.po: Added Lithuanian translation by Tomas Kuliavas
+	<tokul@users.sourceforge.net>.
+
+2003-10-06  Mugurel Tudor  <mugurelu@go.ro>
+
+	* ro.po: Updated Romanian translation
+
 2003-09-30  Kjartan Maraas  <kmaraas@gnome.org>
 
 	* no.po: Update Norwegian translation.

po/POTFILES.in

@@ -17,6 +17,7 @@ src/resizepopup.c
 src/screen.c
 src/session.c
 src/theme-parser.c
+src/theme-viewer.c
 src/theme.c
 src/tools/metacity-properties.desktop.in
 src/tools/metacity-properties.glade

rationales.txt

@@ -1,18 +1,43 @@
 
-Focus windows on map: see http://bugzilla.gnome.org/show_bug.cgi?id=82921
+History
+====
+
+Focus windows on map: see
+  http://bugzilla.gnome.org/show_bug.cgi?id=118372
+  http://bugzilla.gnome.org/show_bug.cgi?id=82921
+
 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
 Opaque resize: http://bugzilla.gnome.org/show_bug.cgi?id=92618
-Super+click to resize: http://bugzilla.gnome.org/show_bug.cgi?id=79315
+Alt+click to move/resize: http://bugzilla.gnome.org/show_bug.cgi?id=101151
 minimized windows in Alt+tab: http://bugzilla.gnome.org/show_bug.cgi?id=89416
-raise windows on click: http://bugzilla.gnome.org/show_bug.cgi?id=86108
 dialogs above entire app group: http://bugzilla.gnome.org/show_bug.cgi?id=88926
-display window size/position: http://bugzilla.gnome.org/show_bug.cgi?id=85213, 
-http://bugzilla.gnome.org/show_bug.cgi?id=106645
+
+display window size/position: 
+  http://bugzilla.gnome.org/show_bug.cgi?id=85213
+  http://bugzilla.gnome.org/show_bug.cgi?id=106645
+  http://bugzilla.gnome.org/show_bug.cgi?id=130821
 
 configure click actions, alt+click:
-http://bugzilla.gnome.org/show_bug.cgi?id=83210
+  http://bugzilla.gnome.org/show_bug.cgi?id=83210
 
 system modal dialogs: http://bugzilla.gnome.org/show_bug.cgi?id=83357
 
 workspace wrapping: http://bugzilla.gnome.org/show_bug.cgi?id=89315
+
+raise windows on click:
+  http://bugzilla.gnome.org/show_bug.cgi?id=86108
+  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

src/Makefile.am

@@ -14,6 +14,8 @@ metacity_SOURCES= 				\
 	bell.h					\
 	bell.c					\
 	common.h				\
+	compositor.c				\
+	compositor.h				\
 	constraints.c				\
 	constraints.h				\
 	core.c					\

src/common.h

@@ -58,7 +58,13 @@ typedef enum
   META_MENU_OP_STICK       = 1 << 7,
   META_MENU_OP_WORKSPACES  = 1 << 8,
   META_MENU_OP_MOVE        = 1 << 9,
-  META_MENU_OP_RESIZE      = 1 << 10
+  META_MENU_OP_RESIZE      = 1 << 10,
+  META_MENU_OP_ABOVE       = 1 << 11,
+  META_MENU_OP_UNABOVE     = 1 << 12,
+  META_MENU_OP_MOVE_LEFT   = 1 << 13,
+  META_MENU_OP_MOVE_RIGHT  = 1 << 14,
+  META_MENU_OP_MOVE_UP     = 1 << 15,
+  META_MENU_OP_MOVE_DOWN   = 1 << 16
 } MetaMenuOp;
 
 typedef struct _MetaWindowMenu MetaWindowMenu;
@@ -66,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.h

@@ -0,0 +1,56 @@
+/* Metacity compositing manager */
+
+/* 
+ * Copyright (C) 2003 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_COMPOSITOR_H
+#define META_COMPOSITOR_H
+
+#include "util.h"
+#include "display.h"
+
+MetaCompositor* meta_compositor_new           (MetaDisplay       *display);
+void            meta_compositor_unref         (MetaCompositor    *compositor);
+void            meta_compositor_process_event (MetaCompositor    *compositor,
+                                               XEvent            *xevent,
+                                               MetaWindow        *window);
+void            meta_compositor_add_window    (MetaCompositor    *compositor,
+                                               Window             xwindow,
+                                               XWindowAttributes *attrs);
+void            meta_compositor_remove_window (MetaCompositor    *compositor,
+                                               Window             xwindow);
+
+void meta_compositor_manage_screen   (MetaCompositor *compositor,
+                                      MetaScreen     *screen);
+void meta_compositor_unmanage_screen (MetaCompositor *compositor,
+                                      MetaScreen     *screen);
+
+void meta_compositor_damage_window   (MetaCompositor *compositor,
+                                      MetaWindow     *window);
+
+#endif /* META_COMPOSITOR_H */
+
+
+
+
+
+
+
+
+

src/constraints.c

@@ -2,6 +2,7 @@
 
 /*
  * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -559,16 +560,9 @@ constraint_onscreen_bottom_func  (MetaWindow           *window,
                                   const MetaRectangle  *orig,
                                   int                  *y_delta)
 {
-  int max_dy;
-  int bottommost_y;
-
-  get_outermost_onscreen_positions (window, info, orig, 0, *y_delta,
-                                    NULL, NULL, NULL, &bottommost_y);
-
-  max_dy = bottommost_y - orig->y;
-
-  if (*y_delta > max_dy)
-    *y_delta = max_dy;
+  /* no way to resize off the bottom so that constraints are
+     violated */
+  return;
 }
 
 static void
@@ -595,16 +589,9 @@ constraint_onscreen_left_func    (MetaWindow           *window,
                                   const MetaRectangle  *orig,
                                   int                  *x_delta)
 {
-  int min_dx;
-  int leftmost_x;
-
-  get_outermost_onscreen_positions (window, info, orig, *x_delta, 0,
-                                    &leftmost_x, NULL, NULL, NULL);
-
-  min_dx = leftmost_x - orig->x;
-
-  if (*x_delta < min_dx)
-    *x_delta = min_dx;
+  /* no way to resize off the sides so that constraints are violated
+   */
+  return;
 }
 
 static void
@@ -613,16 +600,9 @@ constraint_onscreen_right_func   (MetaWindow           *window,
                                   const MetaRectangle  *orig,
                                   int                  *x_delta)
 {
-  int max_dx;
-  int rightmost_x;
-
-  get_outermost_onscreen_positions (window, info, orig, *x_delta, 0,
-                                    NULL, &rightmost_x, NULL, NULL);
-
-  max_dx = rightmost_x - orig->x;
-
-  if (*x_delta > max_dx)
-    *x_delta = max_dx;
+  /* no way to resize off the sides so that constraints are violated
+   */
+  return;
 }
 
 static void
@@ -631,16 +611,9 @@ constraint_onscreen_hcenter_func (MetaWindow           *window,
                                   const MetaRectangle  *orig,
                                   int                  *x_delta)
 {
-  int max_dx;
-  int leftmost_x;
-  
-  get_outermost_onscreen_positions (window, info, orig, *x_delta, 0,
-                                    &leftmost_x, NULL, NULL, NULL);
-
-  max_dx = orig->x - leftmost_x;
-
-  if (*x_delta > max_dx)
-    *x_delta = max_dx;
+  /* no way to resize off the sides so that constraints are violated
+   */
+  return;
 }
 
 static void
@@ -1347,6 +1320,19 @@ meta_window_constrain (MetaWindow          *window,
       (window->placed || did_placement))
     {
       window->maximize_after_placement = FALSE;
+
+      if (OUTER_WIDTH (*new) >= info.work_area_xinerama.width &&
+	  OUTER_HEIGHT (*new) >= info.work_area_xinerama.height)
+	{
+	  /* define a sane saved_rect so that the user can unmaximize
+	   * to something reasonable.
+	   */
+	  new->width = .75 * info.work_area_xinerama.width;
+	  new->height = .75 * info.work_area_xinerama.height;
+	  new->x = info.work_area_xinerama.x + .125 * info.work_area_xinerama.width;
+	  new->y = info.work_area_xinerama.y + .083 * info.work_area_xinerama.height;
+	}
+
       meta_window_maximize_internal (window, new);
 
       /* maximization may have changed frame geometry */

src/core.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -586,17 +587,17 @@ meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
       name = META_KEYBINDING_MAXIMIZE;
       break;
     case META_MENU_OP_UNSHADE:
-      name = META_KEYBINDING_TOGGLE_SHADE;
-      break;
     case META_MENU_OP_SHADE:
       name = META_KEYBINDING_TOGGLE_SHADE;
       break;
     case META_MENU_OP_UNSTICK:
-      name = META_KEYBINDING_TOGGLE_STICKY;
-      break;
     case META_MENU_OP_STICK:
       name = META_KEYBINDING_TOGGLE_STICKY;
       break;
+    case META_MENU_OP_ABOVE:
+    case META_MENU_OP_UNABOVE:
+      name = META_KEYBINDING_TOGGLE_ABOVE;
+      break;
     case META_MENU_OP_WORKSPACES:
       switch (workspace)
         {
@@ -644,6 +645,18 @@ meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
     case META_MENU_OP_RESIZE:
       name = META_KEYBINDING_BEGIN_RESIZE;
       break;
+    case META_MENU_OP_MOVE_LEFT:
+      name = META_KEYBINDING_MOVE_WORKSPACE_LEFT;
+      break;
+    case META_MENU_OP_MOVE_RIGHT:
+      name = META_KEYBINDING_MOVE_WORKSPACE_RIGHT;
+      break;
+    case META_MENU_OP_MOVE_UP:
+      name = META_KEYBINDING_MOVE_WORKSPACE_UP;
+      break;
+    case META_MENU_OP_MOVE_DOWN:
+      name = META_KEYBINDING_MOVE_WORKSPACE_DOWN;
+      break;
     }
 
   if (name)
@@ -678,6 +691,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
                          Window      frame_xwindow,
                          MetaGrabOp  op,
                          gboolean    pointer_already_grabbed,
+                         int         event_serial,
                          int         button,
                          gulong      modmask,
                          Time        timestamp,
@@ -699,6 +713,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
 
   return meta_display_begin_grab_op (display, screen, window,
                                      op, pointer_already_grabbed,
+                                     event_serial,
                                      button, modmask,
                                      timestamp, root_x, root_y);
 }

src/core.h

@@ -133,6 +133,7 @@ gboolean   meta_core_begin_grab_op (Display    *xdisplay,
                                     Window      frame_xwindow,
                                     MetaGrabOp  op,
                                     gboolean    pointer_already_grabbed,
+                                    int         event_serial,
                                     int         button,
                                     gulong      modmask,
                                     Time        timestamp,
@@ -163,6 +164,8 @@ void       meta_core_get_screen_size (Display *xdisplay,
  */
 void meta_core_increment_event_serial (Display *display);
 
+int meta_ui_get_last_event_serial (Display *xdisplay);
+
 #endif
 
 

src/delete.c

@@ -396,10 +396,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,8 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2002 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
  * modify it under the terms of the GNU General Public License as
@@ -33,8 +34,11 @@
 #include "keybindings.h"
 #include "prefs.h"
 #include "resizepopup.h"
+#include "xprops.h"
 #include "workspace.h"
 #include "bell.h"
+#include "effects.h"
+#include "compositor.h"
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #ifdef HAVE_SOLARIS_XINERAMA
@@ -88,6 +92,8 @@ static Window event_get_modified_window (MetaDisplay    *display,
                                          XEvent         *event);
 static guint32 event_get_time           (MetaDisplay    *display,
                                          XEvent         *event);
+static void    process_request_frame_extents (MetaDisplay    *display,
+                                              XEvent         *event);
 static void    process_pong_message     (MetaDisplay    *display,
                                          XEvent         *event);
 static void    process_selection_request (MetaDisplay   *display,
@@ -185,6 +191,7 @@ meta_display_open (const char *name)
   GSList *screens;
   GSList *tmp;
   int i;
+  Time timestamp;
   /* Remember to edit code that assigns each atom to display struct
    * when adding an atom name here.
    */
@@ -263,13 +270,23 @@ 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",
     "_METACITY_SENTINEL",
-    "_NET_WM_STRUT_PARTIAL"
+    "_NET_WM_STRUT_PARTIAL",
+    "_NET_WM_ACTION_FULLSCREEN",
+    "_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)];
   
@@ -312,7 +329,7 @@ meta_display_open (const char *name)
   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 */
@@ -405,14 +422,24 @@ 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];
   display->atom_metacity_sentinel = atoms[79];
   display->atom_net_wm_strut_partial = atoms[80];
-  
+  display->atom_net_wm_action_fullscreen = atoms[81];
+  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);
   display->group_prop_hooks = NULL;
@@ -472,6 +499,7 @@ meta_display_open (const char *name)
   display->sentinel_counter = 0;
   
   display->grab_op = META_GRAB_OP_NONE;
+  display->grab_wireframe_active = FALSE;
   display->grab_window = NULL;
   display->grab_screen = NULL;
   display->grab_resize_popup = NULL;
@@ -525,6 +553,43 @@ meta_display_open (const char *name)
 #else  /* HAVE_SHAPE */
   meta_verbose ("Not compiled with Shape support\n");
 #endif /* !HAVE_SHAPE */
+
+  /* Create the leader window here. Set its properties and
+   * use the timestamp from one of the PropertyNotify events
+   * that will follow.
+   */
+  {
+    XSetWindowAttributes attrs;
+    gulong data[1];
+    XEvent event;
+
+    attrs.event_mask = PropertyChangeMask;
+    attrs.override_redirect = True;
+
+    display->leader_window = meta_create_offscreen_window (display->xdisplay,
+                                                           DefaultRootWindow (display->xdisplay));                                                           
+
+    set_utf8_string_hint (display,
+                          display->leader_window,
+                          display->atom_net_wm_name,
+                          "Metacity");
+    
+    data[0] = display->leader_window;
+    XChangeProperty (display->xdisplay,
+                     display->leader_window,
+                     display->atom_net_supporting_wm_check,
+                     XA_WINDOW,
+                     32, PropModeReplace, (guchar*) data, 1);
+
+    XWindowEvent (display->xdisplay,
+                  display->leader_window,
+                  PropertyChangeMask,
+                  &event);
+
+    timestamp = event.xproperty.time;
+  }
+
+  display->compositor = meta_compositor_new (display);
   
   screens = NULL;
   
@@ -533,7 +598,7 @@ meta_display_open (const char *name)
     {
       MetaScreen *screen;
 
-      screen = meta_screen_new (display, i);
+      screen = meta_screen_new (display, i, timestamp);
 
       if (screen)
         screens = g_slist_prepend (screens, screen);
@@ -550,25 +615,6 @@ meta_display_open (const char *name)
       meta_display_close (display);
       return FALSE;
     }
-
-  /* display->leader_window was created as a side effect of
-   * initializing the screens
-   */
-  
-  set_utf8_string_hint (display,
-                        display->leader_window,
-                        display->atom_net_wm_name,
-                        "Metacity");
-  {
-    gulong data[1];
-    data[0] = display->leader_window;
-
-    XChangeProperty (display->xdisplay,
-                     display->leader_window,
-                     display->atom_net_supporting_wm_check,
-                     XA_WINDOW,
-                     32, PropModeReplace, (guchar*) data, 1);
-  }
  
   meta_display_grab (display);
   
@@ -595,9 +641,11 @@ meta_display_open (const char *name)
     if (focus == None || focus == PointerRoot)
       focus = display->no_focus_window;
 
-    /* FIXME CurrentTime evil */
+    /* Use the same timestamp that was passed to meta_screen_new(),
+     * as it is the most recent timestamp.
+     */
     XSetInputFocus (display->xdisplay, focus, RevertToPointerRoot,
-                    CurrentTime);
+                    timestamp);
     
     meta_error_trap_pop (display, FALSE);
   }
@@ -745,6 +793,8 @@ meta_display_close (MetaDisplay *display)
   all_displays = g_slist_remove (all_displays, display);
 
   meta_display_shutdown_keys (display);
+
+  meta_compositor_unref (display->compositor);
   
   g_free (display);
 
@@ -1130,6 +1180,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)
@@ -1139,7 +1290,7 @@ event_callback (XEvent   *event,
   Window modified;
   gboolean frame_was_receiver;
   gboolean filter_out_event;
-  
+
   display = data;
   
   if (dump_events)
@@ -1219,20 +1370,22 @@ event_callback (XEvent   *event,
        * goes to the frame.
        */
       frame_was_receiver = TRUE;
-      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event\n");
+      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event for %s\n",
+                  window->desc);
     }
 
 #ifdef HAVE_XSYNC
   if (META_DISPLAY_HAS_XSYNC (display) && 
       event->type == (display->xsync_event_base + XSyncAlarmNotify) &&
-      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_update_alarm)
+      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_sync_request_alarm)
     {
       filter_out_event = TRUE; /* GTK doesn't want to see this really */
       
       if (display->grab_op != META_GRAB_OP_NONE &&
           display->grab_window != NULL &&
+          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 */
 
@@ -1286,6 +1439,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)
     {
@@ -1296,7 +1459,8 @@ event_callback (XEvent   *event,
     case ButtonPress:
       if ((window &&
            grab_op_is_mouse (display->grab_op) &&
-           display->grab_button != (int) event->xbutton.button && 
+           display->grab_button != (int) event->xbutton.button &&
+           event->xany.serial >= display->grab_start_serial &&
            display->grab_window == window) ||
           grab_op_is_keyboard (display->grab_op))
         {
@@ -1335,7 +1499,12 @@ event_callback (XEvent   *event,
                    * frames.c or special-cased if the click was on a
                    * minimize/close button.
                    */
-                  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+
+                  /* Raise on clicking the client area always or only
+                   * in click to focus mode? The debate rages.
+                   * Feel free to change TRUE to FALSE or vice versa
+                   */
+                  if (TRUE /* meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK */) 
                     {
                       meta_window_raise (window);
                       
@@ -1386,6 +1555,7 @@ event_callback (XEvent   *event,
                                               window,
                                               op,
                                               TRUE,
+                                              event->xbutton.serial,
                                               event->xbutton.button,
                                               0,
                                               event->xbutton.time,
@@ -1424,6 +1594,10 @@ event_callback (XEvent   *event,
                 mode = AsyncPointer; /* eat focus click */
               else
                 mode = ReplayPointer; /* give event back */
+
+              meta_verbose ("Allowing events mode %s time %lu\n",
+                            mode == AsyncPointer ? "AsyncPointer" : "ReplayPointer",
+                            (unsigned long) event->xbutton.time);
               
               XAllowEvents (display->xdisplay,
                             mode, event->xbutton.time);
@@ -1436,6 +1610,7 @@ event_callback (XEvent   *event,
                                           window,
                                           META_GRAB_OP_MOVING,
                                           TRUE,
+                                          event->xbutton.serial,
                                           event->xbutton.button,
                                           0,
                                           event->xbutton.time,
@@ -1446,16 +1621,19 @@ event_callback (XEvent   *event,
       break;
     case ButtonRelease:
       if (display->grab_window == window &&
+          event->xany.serial >= display->grab_start_serial &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       break;
     case MotionNotify:
       if (display->grab_window == window &&
+          event->xany.serial >= display->grab_start_serial &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       break;
     case EnterNotify:
       if (display->grab_window == window &&
+          event->xany.serial >= display->grab_start_serial &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       /* do this even if window->has_focus to avoid races */
@@ -1519,6 +1697,7 @@ event_callback (XEvent   *event,
       break;
     case LeaveNotify:
       if (display->grab_window == window &&
+          event->xany.serial >= display->grab_start_serial &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       else if (window != NULL)
@@ -1586,14 +1765,28 @@ event_callback (XEvent   *event,
           if (event->type == FocusIn &&
               event->xfocus.detail == NotifyDetailNone)
             {
+              XEvent   property_event;
+
               /* 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,
-                              CurrentTime); /* CurrentTime FIXME */
+                              property_event.xproperty.time);
             }
         }
       break;
@@ -1609,6 +1802,7 @@ event_callback (XEvent   *event,
       break;
     case CreateNotify:
       break;
+      
     case DestroyNotify:
       if (window)
         {
@@ -1627,6 +1821,7 @@ event_callback (XEvent   *event,
           else
             {
               meta_window_free (window); /* Unmanage destroyed window */
+              window = NULL;
             }
         }
       break;
@@ -1789,10 +1984,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)
@@ -1853,7 +2056,10 @@ event_callback (XEvent   *event,
                                                         space);
 
                   if (workspace)
-                    meta_workspace_activate (workspace);
+                    {
+                      meta_workspace_activate (workspace);
+                      meta_workspace_focus_default_window (workspace, NULL);
+                    }
                   else
                     meta_verbose ("Don't know about workspace %d\n", space);
                 }
@@ -1926,6 +2132,13 @@ event_callback (XEvent   *event,
                     }
 		}
             }
+
+          if (event->xclient.message_type ==
+              display->atom_net_request_frame_extents)
+            {
+              meta_verbose ("Received _NET_REQUEST_FRAME_EXTENTS message\n");
+              process_request_frame_extents (display, event);
+            }
         }
       break;
     case MappingNotify:
@@ -1975,6 +2188,10 @@ event_callback (XEvent   *event,
       break;
     }
 
+  meta_compositor_process_event (display->compositor,
+                                 event,
+                                 window);
+  
   display->current_time = CurrentTime;
   return filter_out_event;
 }
@@ -2368,9 +2585,15 @@ meta_spew_event (MetaDisplay *display,
       break;
     case CreateNotify:
       name = "CreateNotify";
+      extra = g_strdup_printf ("parent: 0x%lx window: 0x%lx",
+                               event->xcreatewindow.parent,
+                               event->xcreatewindow.window);
       break;
     case DestroyNotify:
       name = "DestroyNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx",
+                               event->xdestroywindow.event,
+                               event->xdestroywindow.window);
       break;
     case UnmapNotify:
       name = "UnmapNotify";
@@ -2394,6 +2617,10 @@ meta_spew_event (MetaDisplay *display,
       break;
     case ReparentNotify:
       name = "ReparentNotify";
+      extra = g_strdup_printf ("window: 0x%lx parent: 0x%lx event: 0x%lx\n",
+                               event->xreparent.window,
+                               event->xreparent.parent,
+                               event->xreparent.event);
       break;
     case ConfigureNotify:
       name = "ConfigureNotify";
@@ -2788,6 +3015,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
                             MetaWindow  *window,
                             MetaGrabOp   op,
                             gboolean     pointer_already_grabbed,
+                            int          event_serial,
                             int          button,
                             gulong       modmask,
                             Time         timestamp,
@@ -2797,8 +3025,9 @@ meta_display_begin_grab_op (MetaDisplay *display,
   Window grab_xwindow;
   
   meta_topic (META_DEBUG_WINDOW_OPS,
-              "Doing grab op %d on window %s button %d pointer already grabbed: %d\n",
-              op, window ? window->desc : "none", button, pointer_already_grabbed);
+              "Doing grab op %d on window %s button %d pointer already grabbed: %d pointer pos %d,%d\n",
+              op, window ? window->desc : "none", button, pointer_already_grabbed,
+              root_x, root_y);
   
   if (display->grab_op != META_GRAB_OP_NONE)
     {
@@ -2808,6 +3037,12 @@ meta_display_begin_grab_op (MetaDisplay *display,
       return FALSE;
     }
 
+  /* We'll ignore any events < this serial. */
+  if (pointer_already_grabbed)
+    display->grab_start_serial = event_serial;
+  else
+    display->grab_start_serial = XNextRequest (display->xdisplay);
+  
   /* FIXME:
    *   If we have no MetaWindow we do our best
    *   and try to do the grab on the RootWindow.
@@ -2818,10 +3053,12 @@ meta_display_begin_grab_op (MetaDisplay *display,
     grab_xwindow = window->frame ? window->frame->xwindow : window->xwindow;
   else
     grab_xwindow = screen->xroot;
+
+  display->grab_have_pointer = FALSE;
   
   if (pointer_already_grabbed)
     display->grab_have_pointer = TRUE;
-      
+  
   meta_display_set_grab_op_cursor (display, screen, op, FALSE, grab_xwindow,
                                    timestamp);
 
@@ -2858,48 +3095,93 @@ meta_display_begin_grab_op (MetaDisplay *display,
   display->grab_xwindow = grab_xwindow;
   display->grab_button = button;
   display->grab_mask = modmask;
-  display->grab_initial_root_x = root_x;
-  display->grab_initial_root_y = root_y;
+  display->grab_anchor_root_x = root_x;
+  display->grab_anchor_root_y = root_y;
   display->grab_latest_motion_x = root_x;
   display->grab_latest_motion_y = root_y;
   display->grab_last_moveresize_time.tv_sec = 0;
   display->grab_last_moveresize_time.tv_usec = 0;
   display->grab_motion_notify_time = 0;
 #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;
       meta_window_get_position (display->grab_window,
                                 &display->grab_initial_window_pos.x,
                                 &display->grab_initial_window_pos.y);
+      display->grab_anchor_window_pos = display->grab_initial_window_pos;
 
+      display->grab_wireframe_active =
+        meta_prefs_get_reduced_resources () && 
+        (meta_grab_op_is_resizing (display->grab_op) ||
+         meta_grab_op_is_moving (display->grab_op));
+      
+      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.
+           */
+          display->grab_wireframe_rect = window->rect;
+          if (window->frame)
+            {
+              display->grab_wireframe_rect.x += window->frame->rect.x;
+              display->grab_wireframe_rect.y += window->frame->rect.y;
+            }
+          
+          meta_window_calc_showing (display->grab_window);
+          meta_effects_begin_wireframe (display->grab_window->screen,
+                                        &display->grab_wireframe_rect);
+        }
+      
 #ifdef HAVE_XSYNC
-      if (meta_grab_op_is_resizing (display->grab_op) &&
-          display->grab_window->update_counter != None)
+      if (!display->grab_wireframe_active &&
+          meta_grab_op_is_resizing (display->grab_op) &&
+          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 |
@@ -2907,12 +3189,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
     }
@@ -2948,7 +3231,15 @@ meta_display_begin_grab_op (MetaDisplay *display,
     }
 
   if (display->grab_window)
-    meta_window_refresh_resize_popup (display->grab_window);
+    {
+      meta_window_refresh_resize_popup (display->grab_window);
+
+      /* repaint window in case we draw it differently
+       * when grabbed
+       */
+      meta_compositor_damage_window (display->compositor,
+                                     display->grab_window);
+    }
   
   return TRUE;
 }
@@ -3001,12 +3292,35 @@ 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
+   */
+  if (display->grab_window != NULL)
+    meta_compositor_damage_window (display->compositor,
+                                   display->grab_window);
   
   display->grab_window = NULL;
   display->grab_screen = NULL;
@@ -3018,6 +3332,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
@@ -3029,6 +3349,11 @@ meta_change_button_grab (MetaDisplay *display,
                          int          modmask)
 {
   unsigned int ignored_mask;
+
+  meta_verbose ("%s 0x%lx sync = %d button = %d modmask 0x%x\n",
+                grab ? "Grabbing" : "Ungrabbing",
+                xwindow,
+                sync, button, modmask);
   
   meta_error_trap_push (display);
   
@@ -3046,6 +3371,8 @@ meta_change_button_grab (MetaDisplay *display,
 
       if (meta_is_debugging ())
         meta_error_trap_push_with_return (display);
+
+      /* GrabModeSync means freeze until XAllowEvents */
       
       if (grab)
         XGrabButton (display->xdisplay, button, modmask | ignored_mask,
@@ -3147,11 +3474,32 @@ meta_display_ungrab_window_buttons  (MetaDisplay *display,
 #define MAX_FOCUS_BUTTON 4
 void
 meta_display_grab_focus_window_button (MetaDisplay *display,
-                                       Window       xwindow)
+                                       MetaWindow  *window)
 {
   /* Grab button 1 for activating unfocused windows */
-  meta_verbose ("Grabbing unfocused window buttons for 0x%lx\n", xwindow);
+  meta_verbose ("Grabbing unfocused window buttons for %s\n", window->desc);
 
+#if 0
+  /* FIXME:115072 */
+  /* Don't grab at all unless in click to focus mode. In click to
+   * focus, we may sometimes be clever about intercepting and eating
+   * the focus click. But in mouse focus, we never do that since the
+   * focus window may not be raised, and who wants to think about
+   * mouse focus anyway.
+   */
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+    {
+      meta_verbose (" (well, not grabbing since not in click to focus mode)\n");
+      return;
+    }
+#endif
+  
+  if (window->have_focus_click_grab)
+    {
+      meta_verbose (" (well, not grabbing since we already have the grab)\n");
+      return;
+    }
+  
   /* FIXME If we ignored errors here instead of spewing, we could
    * put one big error trap around the loop and avoid a bunch of
    * XSync()
@@ -3162,29 +3510,37 @@ meta_display_grab_focus_window_button (MetaDisplay *display,
     while (i < MAX_FOCUS_BUTTON)
       {
         meta_change_button_grab (display,
-                                 xwindow,
-                                 TRUE, TRUE, i, 0);
+                                 window->xwindow,
+                                 TRUE, TRUE,
+                                 i, 0);
         
         ++i;
       }
+
+    window->have_focus_click_grab = TRUE;
   }
 }
 
 void
 meta_display_ungrab_focus_window_button (MetaDisplay *display,
-                                         Window       xwindow)
+                                         MetaWindow  *window)
 {
-  meta_verbose ("Ungrabbing unfocused window buttons for 0x%lx\n", xwindow);
+  meta_verbose ("Ungrabbing unfocused window buttons for %s\n", window->desc);
 
+  if (!window->have_focus_click_grab)
+    return;
+  
   {
     int i = 1;
     while (i < MAX_FOCUS_BUTTON)
       {
-        meta_change_button_grab (display, xwindow,
-                                 FALSE, TRUE, i, 0);
+        meta_change_button_grab (display, window->xwindow,
+                                 FALSE, FALSE, i, 0);
         
         ++i;
       }
+
+    window->have_focus_click_grab = FALSE;
   }
 }
 
@@ -3363,6 +3719,74 @@ meta_display_ping_window (MetaDisplay       *display,
                                   timestamp);
 }
 
+static void
+process_request_frame_extents (MetaDisplay    *display,
+                               XEvent         *event)
+{
+  /* The X window whose frame extents will be set. */
+  Window xwindow = event->xclient.window;
+  unsigned long data[4] = { 0, 0, 0, 0 };
+
+  MotifWmHints *hints = NULL;
+  gboolean hints_set = FALSE;
+
+  meta_verbose ("Setting frame extents for 0x%lx\n", xwindow);
+
+  /* See if the window is decorated. */
+  hints_set = meta_prop_get_motif_hints (display,
+                                         xwindow,
+                                         display->atom_motif_wm_hints,
+                                         &hints);
+  if ((hints_set && hints->decorations) || !hints_set)
+    {
+      int top = 0;
+      int bottom = 0;
+      int left = 0;
+      int right = 0;
+
+      MetaScreen *screen;
+
+      screen = meta_display_screen_for_xwindow (display,
+                                                event->xclient.window);
+      if (screen == NULL)
+        {
+          meta_warning ("Received request to set _NET_FRAME_EXTENTS "
+                        "on 0x%lx which is on a screen we are not managing\n",
+                        event->xclient.window);
+          meta_XFree (hints);
+          return;
+        }
+
+      /* Return estimated frame extents for a normal window. */
+      meta_ui_theme_get_frame_borders (screen->ui,
+                                       META_FRAME_TYPE_NORMAL,
+                                       0,
+                                       &top,
+                                       &bottom,
+                                       &left,
+                                       &right);
+
+      data[0] = left;
+      data[1] = right;
+      data[2] = top;
+      data[3] = bottom;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting _NET_FRAME_EXTENTS on unmanaged window 0x%lx "
+              "to top = %ld, left = %ld, bottom = %ld, right = %ld\n",
+              xwindow, data[0], data[1], data[2], data[3]);
+
+  meta_error_trap_push (display);
+  XChangeProperty (display->xdisplay, xwindow,
+                   display->atom_net_frame_extents,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 4);
+  meta_error_trap_pop (display, FALSE);
+
+  meta_XFree (hints);
+}
+
 /* process the pong from our ping */
 static void
 process_pong_message (MetaDisplay    *display,
@@ -4008,12 +4432,17 @@ static void
 prefs_changed_callback (MetaPreference pref,
                         void          *data)
 {
-  if (pref == META_PREF_MOUSE_BUTTON_MODS)
+  /* It may not be obvious why we regrab on focus mode
+   * change; it's because we handle focus clicks a
+   * bit differently for the different focus modes.
+   */
+  if (pref == META_PREF_MOUSE_BUTTON_MODS ||
+      pref == META_PREF_FOCUS_MODE)
     {
       MetaDisplay *display = data;
       GSList *windows;
       GSList *tmp;
-
+      
       windows = meta_display_list_windows (display);
       
       /* Ungrab all */
@@ -4022,19 +4451,20 @@ prefs_changed_callback (MetaPreference pref,
         {
           MetaWindow *w = tmp->data;
           meta_display_ungrab_window_buttons (display, w->xwindow);
-          meta_display_ungrab_focus_window_button (display, w->xwindow);
+          meta_display_ungrab_focus_window_button (display, w);
           tmp = tmp->next;
         }
-      
+
       /* change our modifier */
-      update_window_grab_modifiers (display);
+      if (pref == META_PREF_MOUSE_BUTTON_MODS)
+        update_window_grab_modifiers (display);
 
       /* Grab all */
       tmp = windows;
       while (tmp != NULL)
         {
           MetaWindow *w = tmp->data;
-          meta_display_grab_focus_window_button (display, w->xwindow);
+          meta_display_grab_focus_window_button (display, w);
           meta_display_grab_window_buttons (display, w->xwindow);
           tmp = tmp->next;
         }

src/display.h

@@ -3,6 +3,7 @@
 /* 
  * Copyright (C) 2001 Havoc Pennington
  * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -53,6 +54,7 @@ struct _MetaRectangle
   int height;
 };
 
+typedef struct MetaCompositor  MetaCompositor;
 typedef struct _MetaDisplay    MetaDisplay;
 typedef struct _MetaFrame      MetaFrame;
 typedef struct _MetaKeyBinding MetaKeyBinding;
@@ -152,6 +154,8 @@ struct _MetaDisplay
   Atom atom_net_wm_allowed_actions;
   Atom atom_net_wm_action_move;
   Atom atom_net_wm_action_resize;
+  Atom atom_net_wm_action_fullscreen;
+  Atom atom_net_wm_action_minimize;
   Atom atom_net_wm_action_shade;
   Atom atom_net_wm_action_stick;
   Atom atom_net_wm_action_maximize_horz;
@@ -162,14 +166,22 @@ 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;
   Atom atom_metacity_sentinel;
   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
    */
@@ -225,19 +237,24 @@ struct _MetaDisplay
   MetaScreen *grab_screen;
   MetaWindow *grab_window;
   Window      grab_xwindow;
+  gulong      grab_start_serial;
   int         grab_button;
-  int         grab_initial_root_x;
-  int         grab_initial_root_y;
+  int         grab_anchor_root_x;
+  int         grab_anchor_root_y;
+  MetaRectangle grab_anchor_window_pos;
   int         grab_latest_motion_x;
   int         grab_latest_motion_y;
   gulong      grab_mask;
   guint       grab_have_pointer : 1;
   guint       grab_have_keyboard : 1;
+  guint       grab_wireframe_active : 1;
+  guint       grab_was_cancelled : 1;
+  MetaRectangle grab_wireframe_rect;
   MetaRectangle grab_initial_window_pos;
   MetaResizePopup *grab_resize_popup;
   GTimeVal    grab_last_moveresize_time;
   Time        grab_motion_notify_time;
-
+  
   /* we use property updates as sentinels for certain window focus events
    * to avoid some race conditions on EnterNotify events
    */
@@ -247,9 +264,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;
@@ -286,6 +304,9 @@ struct _MetaDisplay
 
   /* Managed by group-props.c */
   MetaGroupPropHooks *group_prop_hooks;
+
+  /* Managed by compositor.c */
+  MetaCompositor *compositor;
   
 #ifdef HAVE_STARTUP_NOTIFICATION
   SnDisplay *sn_display;
@@ -355,6 +376,7 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display,
                                      MetaWindow  *window,
                                      MetaGrabOp   op,
                                      gboolean     pointer_already_grabbed,
+                                     int          event_serial,
                                      int          button,
                                      gulong       modmask,
                                      Time         timestamp,
@@ -369,9 +391,9 @@ void     meta_display_ungrab_window_buttons  (MetaDisplay *display,
                                               Window       xwindow);
 
 void meta_display_grab_focus_window_button   (MetaDisplay *display,
-                                              Window       xwindow);
+                                              MetaWindow  *window);
 void meta_display_ungrab_focus_window_button (MetaDisplay *display,
-                                              Window       xwindow);
+                                              MetaWindow  *window);
 
 /* make a request to ensure the event serial has changed */
 void     meta_display_increment_event_serial (MetaDisplay *display);

src/effects.c

@@ -409,5 +409,108 @@ meta_effects_draw_box_animation (MetaScreen     *screen,
   XFlush (context->screen->display->xdisplay);  
 }
 
+void
+meta_effects_begin_wireframe (MetaScreen          *screen,
+                              const MetaRectangle *rect)
+{
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (screen->display);
+  meta_ui_push_delay_exposes (screen->ui);  
 
+  meta_effects_update_wireframe (screen, NULL, rect);
+}
+
+static void
+draw_xor_rect (MetaScreen          *screen,
+               const MetaRectangle *rect)
+{
+  /* The lines in the center can't overlap the rectangle or each
+   * other, or the XOR gets reversed. So we have to draw things
+   * a bit oddly.
+   */
+  XSegment segments[8];
+  int i;
+  
+#define LINE_WIDTH META_WIREFRAME_XOR_LINE_WIDTH
+  
+  XDrawRectangle (screen->display->xdisplay,
+                  screen->xroot,
+                  screen->root_xor_gc,
+                  rect->x, rect->y,
+                  rect->width, rect->height);
+
+  /* Don't put lines inside small rectangles where they won't fit */
+  if (rect->width < (LINE_WIDTH * 4) ||
+      rect->height < (LINE_WIDTH * 4))
+    return;
+  
+  /* Two vertical lines at 1/3 and 2/3 */
+  segments[0].x1 = rect->x + rect->width / 3;
+  segments[0].y1 = rect->y + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[0].x2 = segments[0].x1;
+  segments[0].y2 = rect->y + rect->height - LINE_WIDTH / 2;  
+
+  segments[1] = segments[0];
+  segments[1].x1 = rect->x + (rect->width / 3) * 2;
+  segments[1].x2 = segments[1].x1;
+
+  /* Now make two horizontal lines at 1/3 and 2/3, but not
+   * overlapping the verticals
+   */
+
+  segments[2].x1 = rect->x + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[2].x2 = segments[0].x1 - LINE_WIDTH / 2;
+  segments[2].y1 = rect->y + rect->height / 3;
+  segments[2].y2 = segments[2].y1;
+
+  segments[3] = segments[2];
+  segments[3].x1 = segments[2].x2 + LINE_WIDTH;
+  segments[3].x2 = segments[1].x1 - LINE_WIDTH / 2;
+  
+  segments[4] = segments[3];
+  segments[4].x1 = segments[3].x2 + LINE_WIDTH;
+  segments[4].x2 = rect->x + rect->width - LINE_WIDTH / 2;
+
+  /* Second horizontal line is just like the first, but
+   * shifted down
+   */
+  i = 5;
+  while (i < 8)
+    {
+      segments[i] = segments[i - 3];
+      segments[i].y1 = rect->y + (rect->height / 3) * 2;
+      segments[i].y2 = segments[i].y1;
+      ++i;
+    }
+  
+  XDrawSegments (screen->display->xdisplay,
+                 screen->xroot,
+                 screen->root_xor_gc,
+                 segments,
+                 G_N_ELEMENTS (segments));
+}
+
+void
+meta_effects_update_wireframe (MetaScreen          *screen,
+                               const MetaRectangle *old_rect,
+                               const MetaRectangle *new_rect)
+{
+  if (old_rect)
+    draw_xor_rect (screen, old_rect);
+    
+  if (new_rect)
+    draw_xor_rect (screen, new_rect);
+    
+  XFlush (screen->display->xdisplay);
+}
+
+void
+meta_effects_end_wireframe (MetaScreen          *screen,
+                            const MetaRectangle *old_rect)
+{
+  meta_effects_update_wireframe (screen, old_rect, NULL);
+  
+  meta_display_ungrab (screen->display);
+  meta_ui_pop_delay_exposes (screen->ui);
+}
 

src/effects.h

@@ -41,4 +41,12 @@ void meta_effects_draw_box_animation (MetaScreen     *screen,
                                       double          seconds_duration,
                                       MetaBoxAnimType anim_type);
 
+void meta_effects_begin_wireframe  (MetaScreen          *screen,
+                                    const MetaRectangle *rect);
+void meta_effects_update_wireframe (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    const MetaRectangle *new_rect);
+void meta_effects_end_wireframe    (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect);
+
 #endif /* META_EFFECTS_H */

src/frame.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 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
@@ -39,6 +40,7 @@ meta_window_ensure_frame (MetaWindow *window)
 {
   MetaFrame *frame;
   XSetWindowAttributes attrs;
+  Visual *visual;
   
   if (window->frame)
     return;
@@ -78,10 +80,16 @@ meta_window_ensure_frame (MetaWindow *window)
    * visual as the client.
    */
 
+  visual = 0;
+  /* XXX special case for depth 32 windows (assumed to be ARGB) */
+  if (window->depth == 32)
+    visual = window->xvisual;  
+
   frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
-						window->display->xdisplay,
-						frame->rect.x,
-						frame->rect.y,
+                                                window->display->xdisplay,
+                                                visual,
+                                                frame->rect.x,
+                                                frame->rect.y,
 						frame->rect.width,
 						frame->rect.height,
 						frame->window->screen->number);
@@ -153,6 +161,8 @@ meta_window_destroy_frame (MetaWindow *window)
   if (window->frame == NULL)
     return;
 
+  meta_verbose ("Unframing window %s\n", window->desc);
+  
   frame = window->frame;
   
   meta_bell_notify_frame_destroy (frame);

src/frames.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 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
@@ -1257,6 +1258,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                frame->xwindow,
                                op,
                                TRUE,
+                               meta_ui_get_last_event_serial (gdk_display),
                                event->button,
                                0,
                                event->time,
@@ -1336,6 +1338,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                frame->xwindow,
                                op,
                                TRUE,
+                               meta_ui_get_last_event_serial (gdk_display),
                                event->button,
                                0,
                                event->time,
@@ -1355,6 +1358,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                    frame->xwindow,
                                    META_GRAB_OP_MOVING,
                                    TRUE,
+                                   meta_ui_get_last_event_serial (gdk_display),
                                    event->button,
                                    0,
                                    event->time,
@@ -2110,6 +2114,13 @@ get_control (MetaFrames *frames,
 void
 meta_frames_push_delay_exposes (MetaFrames *frames)
 {
+  if (frames->expose_delay_count == 0)
+    {
+      /* Make sure we've repainted things */
+      gdk_window_process_all_updates ();
+      XFlush (gdk_display);
+    }
+  
   frames->expose_delay_count += 1;
 }
 

src/group.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as

src/iconcache.c

@@ -46,7 +46,7 @@ get_fallback_icons (MetaScreen     *screen,
 
 static gboolean
 find_largest_sizes (gulong *data,
-                    int     nitems,
+                    gulong  nitems,
                     int    *width,
                     int    *height)
 {
@@ -81,7 +81,7 @@ find_largest_sizes (gulong *data,
 
 static gboolean
 find_best_size (gulong  *data,
-                int      nitems,
+                gulong   nitems,
                 int      ideal_width,
                 int      ideal_height,
                 int     *width,
@@ -520,6 +520,7 @@ meta_icon_cache_init (MetaIconCache *icon_cache)
 
   icon_cache->origin = USING_NO_ICON;
   icon_cache->prev_pixmap = None;
+  icon_cache->prev_mask = None;
 #if 0
   icon_cache->icon = NULL;
   icon_cache->mini_icon = NULL;

src/keybindings.c

@@ -1,7 +1,9 @@
 /* Metacity Keybindings */
 
 /* 
- * Copyright (C) 2001 Havoc Pennington, 2002 Red Hat Inc.
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -27,6 +29,7 @@
 #include "frame.h"
 #include "place.h"
 #include "prefs.h"
+#include "effects.h"
 
 #include <X11/keysym.h>
 #include <string.h>
@@ -1693,10 +1696,24 @@ process_keyboard_move_grab (MetaDisplay *display,
   if (is_modifier (display, event->xkey.keycode))
     return TRUE;
 
-  meta_window_get_position (window, &x, &y);
+  if (display->grab_wireframe_active)
+    {
+      x = display->grab_wireframe_rect.x;
+      y = display->grab_wireframe_rect.y;
+    }
+  else
+    {
+      meta_window_get_position (window, &x, &y);
+    }
 
+  /* FIXME in wireframe mode the edge snapping is all fucked up
+   * since the edge-find routines use window->rect. Window
+   * constraints are also broken with wireframe.
+   */  
   smart_snap = (event->xkey.state & ShiftMask) != 0;
-
+  if (display->grab_wireframe_active)
+    smart_snap = FALSE;
+  
 #define SMALL_INCREMENT 1
 #define NORMAL_INCREMENT 10
 
@@ -1709,13 +1726,18 @@ process_keyboard_move_grab (MetaDisplay *display,
 
   if (keysym == XK_Escape)
     {
-      /* End move and restore to original position */
+      /* End resize and restore to original state.
+       * The move_resize is only needed when !wireframe
+       * since in wireframe we always moveresize at the end
+       * of the grab only.
+       */
       meta_window_move_resize (display->grab_window,
                                TRUE,
                                display->grab_initial_window_pos.x,
                                display->grab_initial_window_pos.y,
                                display->grab_initial_window_pos.width,
                                display->grab_initial_window_pos.height);
+      display->grab_was_cancelled = TRUE;
     }
   
   /* When moving by increments, we still snap to edges if the move
@@ -1729,11 +1751,14 @@ process_keyboard_move_grab (MetaDisplay *display,
     case XK_KP_Prior:
     case XK_Up:
     case XK_KP_Up:
-      edge = meta_window_find_next_horizontal_edge (window, FALSE);
       y -= incr;
-          
-      if (smart_snap || ((edge > y) && ABS (edge - y) < incr))
-        y = edge;
+
+      if (!display->grab_wireframe_active)
+        {
+          edge = meta_window_find_next_horizontal_edge (window, FALSE);
+          if (smart_snap || ((edge > y) && ABS (edge - y) < incr))
+            y = edge;
+        }
           
       handled = TRUE;
       break;
@@ -1741,11 +1766,14 @@ process_keyboard_move_grab (MetaDisplay *display,
     case XK_KP_Next:
     case XK_Down:
     case XK_KP_Down:
-      edge = meta_window_find_next_horizontal_edge (window, TRUE);
       y += incr;
 
-      if (smart_snap || ((edge < y) && ABS (edge - y) < incr))
-        y = edge;
+      if (!display->grab_wireframe_active)
+        {
+          edge = meta_window_find_next_horizontal_edge (window, TRUE);
+          if (smart_snap || ((edge < y) && ABS (edge - y) < incr))
+            y = edge;
+        }
           
       handled = TRUE;
       break;
@@ -1757,11 +1785,14 @@ process_keyboard_move_grab (MetaDisplay *display,
     case XK_KP_End:
     case XK_Left:
     case XK_KP_Left:
-      edge = meta_window_find_next_vertical_edge (window, FALSE);
       x -= incr;
-          
-      if (smart_snap || ((edge > x) && ABS (edge - x) < incr))
-        x = edge;
+
+      if (!display->grab_wireframe_active)
+        {
+          edge = meta_window_find_next_vertical_edge (window, FALSE);
+          if (smart_snap || ((edge > x) && ABS (edge - x) < incr))
+            x = edge;
+        }
 
       handled = TRUE;
       break;
@@ -1769,18 +1800,43 @@ process_keyboard_move_grab (MetaDisplay *display,
     case XK_KP_Next:
     case XK_Right:
     case XK_KP_Right:
-      edge = meta_window_find_next_vertical_edge (window, TRUE);
       x += incr;
-      if (smart_snap || ((edge < x) && ABS (edge - x) < incr))
-        x = edge;
+
+      if (!display->grab_wireframe_active)
+        {
+          edge = meta_window_find_next_vertical_edge (window, TRUE);
+          if (smart_snap || ((edge < x) && ABS (edge - x) < incr))
+            x = edge;
+        }
+      
       handled = TRUE;
       break;
     }
 
   if (handled)
     {
-      meta_window_move (window, TRUE, x, y);
-      meta_window_warp_pointer (window, display->grab_op);
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window location %d,%d due to keypress\n",
+                  x, y);
+      if (display->grab_wireframe_active)
+        {
+          MetaRectangle new_xor;
+
+          new_xor = display->grab_wireframe_rect;
+          new_xor.x = x;
+          new_xor.y = y;
+          
+          meta_effects_update_wireframe (window->screen,
+                                         &display->grab_wireframe_rect,
+                                         &new_xor);
+          display->grab_wireframe_rect = new_xor;
+        }
+      else
+        {
+          meta_window_move (window, TRUE, x, y);
+        }
+      
+      meta_window_update_keyboard_move (window);
     }
 
   return handled;
@@ -1815,13 +1871,18 @@ process_keyboard_resize_grab (MetaDisplay *display,
 
   if (keysym == XK_Escape)
     {
-      /* End resize and restore to original state */
+      /* End resize and restore to original state.
+       * The move_resize is only needed when !wireframe
+       * since in wireframe we always moveresize at the end
+       * of the grab only.
+       */
       meta_window_move_resize (display->grab_window,
                                TRUE,
                                display->grab_initial_window_pos.x,
                                display->grab_initial_window_pos.y,
                                display->grab_initial_window_pos.width,
                                display->grab_initial_window_pos.height);
+      display->grab_was_cancelled = TRUE;
 
       return FALSE;
     }
@@ -1931,20 +1992,38 @@ process_keyboard_resize_grab (MetaDisplay *display,
 
   if (handled)
     {
-      meta_window_update_resize_grab_op (window, TRUE);
+      meta_window_update_keyboard_resize (window, TRUE);
       return TRUE; 
-    } 
+    }
 
-  meta_window_get_position (window, &orig_x, &orig_y);
-  x = orig_x;
-  y = orig_y;
-  width = window->rect.width;
-  height = window->rect.height;
+  if (display->grab_wireframe_active)
+    {
+      x = display->grab_wireframe_rect.x;
+      y = display->grab_wireframe_rect.y;
+      orig_x = x;
+      orig_y = y;
+      width = display->grab_wireframe_rect.width;
+      height = display->grab_wireframe_rect.height;
+    }
+  else
+    {
+      meta_window_get_position (window, &orig_x, &orig_y);
+      x = orig_x;
+      y = orig_y;
+      width = window->rect.width;
+      height = window->rect.height;
+    }
 
   gravity = meta_resize_gravity_from_grab_op (display->grab_op);
-  
-  smart_snap = (event->xkey.state & ShiftMask) != 0;
 
+  /* FIXME in wireframe mode the edge snapping is all fucked up
+   * since the edge-find routines use window->rect. Window
+   * constraints are also broken with wireframe.
+   */  
+  smart_snap = (event->xkey.state & ShiftMask) != 0;
+  if (display->grab_wireframe_active)
+    smart_snap = FALSE;
+  
 #define SMALL_INCREMENT 1
 #define NORMAL_INCREMENT 10
 
@@ -1994,12 +2073,16 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case NorthWestGravity:
         case NorthEastGravity:
           /* Move bottom edge up */
-          edge = meta_window_find_next_horizontal_edge (window, TRUE);
           height -= height_inc;
           
-          if (smart_snap || ((edge > (y+height)) &&
-                             ABS (edge - (y+height)) < height_inc))
-            height = edge - y;
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_horizontal_edge (window, TRUE);
+              
+              if (smart_snap || ((edge > (y+height)) &&
+                                 ABS (edge - (y+height)) < height_inc))
+                height = edge - y;
+            }
           
           handled = TRUE;
           break;
@@ -2008,11 +2091,15 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthWestGravity:
         case SouthEastGravity:
           /* Move top edge up */
-          edge = meta_window_find_next_horizontal_edge (window, FALSE);
           y -= height_inc;
-          
-          if (smart_snap || ((edge > y) && ABS (edge - y) < height_inc))
-            y = edge;
+
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_horizontal_edge (window, FALSE);          
+
+              if (smart_snap || ((edge > y) && ABS (edge - y) < height_inc))
+                y = edge;
+            }
           
           height += (orig_y - y);
           break;
@@ -2035,12 +2122,16 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case NorthWestGravity:
         case NorthEastGravity:
           /* Move bottom edge down */
-          edge = meta_window_find_next_horizontal_edge (window, TRUE);
           height += height_inc;
-          
-          if (smart_snap || ((edge < (y+height)) &&
-                             ABS (edge - (y+height)) < height_inc))
-            height = edge - y;
+
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_horizontal_edge (window, TRUE);
+
+               if (smart_snap || ((edge < (y+height)) &&
+                                  ABS (edge - (y+height)) < height_inc))
+                 height = edge - y;
+            }
           
           handled = TRUE;
           break;
@@ -2049,11 +2140,15 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthWestGravity:
         case SouthEastGravity:
           /* Move top edge down */
-          edge = meta_window_find_next_horizontal_edge (window, FALSE);
           y += height_inc;
-          
-          if (smart_snap || ((edge < y) && ABS (edge - y) < height_inc))
-            y = edge;
+
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_horizontal_edge (window, FALSE);
+
+              if (smart_snap || ((edge < y) && ABS (edge - y) < height_inc))
+                y = edge;
+            }
           
           height -= (y - orig_y);
           break;
@@ -2076,11 +2171,15 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthEastGravity:
         case NorthEastGravity:
           /* Move left edge left */
-          edge = meta_window_find_next_vertical_edge (window, TRUE);
           x -= width_inc;
           
-          if (smart_snap || ((edge > x) && ABS (edge - x) < width_inc))
-            x = edge;
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_vertical_edge (window, TRUE);
+
+               if (smart_snap || ((edge > x) && ABS (edge - x) < width_inc))
+                 x = edge;
+            }
           
           width += (orig_x - x);
           break;
@@ -2089,12 +2188,16 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthWestGravity:
         case NorthWestGravity:
           /* Move right edge left */
-          edge = meta_window_find_next_vertical_edge (window, FALSE);
           width -= width_inc;
           
-          if (smart_snap || ((edge > (x+width)) &&
-                             ABS (edge - (x+width)) < width_inc))
-            width = edge - x;
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_vertical_edge (window, FALSE);
+              
+              if (smart_snap || ((edge > (x+width)) &&
+                                 ABS (edge - (x+width)) < width_inc))
+                width = edge - x;
+            }
           
           handled = TRUE;
           break;
@@ -2117,11 +2220,15 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthEastGravity:
         case NorthEastGravity:
           /* Move left edge right */
-          edge = meta_window_find_next_vertical_edge (window, FALSE);
           x += width_inc;
-          
-          if (smart_snap || ((edge < x) && ABS (edge - x) < width_inc))
-            x = edge;
+
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_vertical_edge (window, FALSE);
+
+              if (smart_snap || ((edge < x) && ABS (edge - x) < width_inc))
+                x = edge;
+            }
           
           width -= (x - orig_x);
           break;
@@ -2130,12 +2237,16 @@ process_keyboard_resize_grab (MetaDisplay *display,
         case SouthWestGravity:
         case NorthWestGravity:
           /* Move right edge right */
-          edge = meta_window_find_next_vertical_edge (window, TRUE);
           width += width_inc;
-          
-          if (smart_snap || ((edge > (x+width)) &&
-                             ABS (edge - (x+width)) < width_inc))
-            width = edge - x;
+
+          if (!display->grab_wireframe_active)
+            {
+              edge = meta_window_find_next_vertical_edge (window, TRUE);
+              
+              if (smart_snap || ((edge > (x+width)) &&
+                                 ABS (edge - (x+width)) < width_inc))
+                width = edge - x;
+            }
           
           handled = TRUE;
           break;
@@ -2162,8 +2273,32 @@ process_keyboard_resize_grab (MetaDisplay *display,
   
   if (handled)
     {
-      meta_window_move_resize (window, TRUE, x, y, width, height);
-      meta_window_update_resize_grab_op (window, FALSE);
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window location %d,%d %dx%d due to keypress\n",
+                  x, y, width, height);
+      
+      if (display->grab_wireframe_active)
+        {
+          MetaRectangle new_xor;
+      
+          new_xor.x = x;
+          new_xor.y = y;
+          new_xor.width = width;
+          new_xor.height = height;
+
+          meta_effects_update_wireframe (window->screen,
+                                         &window->display->grab_wireframe_rect,
+                                         &new_xor);
+          window->display->grab_wireframe_rect = new_xor;
+
+          /* do this after drawing the wires, so we don't draw over it */
+          meta_window_refresh_resize_popup (window);
+        }
+      else
+        {
+          meta_window_move_resize (window, TRUE, x, y, width, height);
+        }
+      meta_window_update_keyboard_resize (window, FALSE);
     }
 
   return handled;
@@ -2308,44 +2443,6 @@ process_tab_grab (MetaDisplay *display,
   return key_used;
 }
 
-static void
-switch_to_workspace (MetaDisplay *display,
-                     MetaWorkspace *workspace)
-{
-  MetaWindow *move_window;
-
-  move_window = NULL;
-  if (display->grab_op == META_GRAB_OP_MOVING)
-    move_window = display->grab_window;
-      
-  if (move_window != NULL)
-    {
-      if (move_window->on_all_workspaces)
-        move_window = NULL; /* don't move it after all */
-
-      /* We put the window on the new workspace, flip spaces,
-       * then remove from old workspace, so the window
-       * never gets unmapped and we maintain the button grab
-       * on it.
-       */
-      if (move_window)
-        {
-          if (!meta_workspace_contains_window (workspace,
-                                               move_window))
-            meta_workspace_add_window (workspace, move_window);
-        }
-    }
-      
-  meta_workspace_activate (workspace);
-
-  if (move_window)
-    {
-      /* Removes window from other spaces */
-      meta_window_change_workspace (move_window, workspace);
-      meta_window_raise (move_window);
-    }
-}
-
 static void
 handle_activate_workspace (MetaDisplay    *display,
                            MetaScreen     *screen,
@@ -2371,7 +2468,7 @@ handle_activate_workspace (MetaDisplay    *display,
   
   if (workspace)
     {
-      switch_to_workspace (display, workspace);
+      meta_workspace_activate (workspace);
     }
   else
     {
@@ -2571,7 +2668,7 @@ process_workspace_switch_grab (MetaDisplay *display,
           meta_topic (META_DEBUG_KEYBINDINGS,
                       "Activating target workspace\n");
 
-          switch_to_workspace (display, target_workspace);
+          meta_workspace_activate (target_workspace);
 
           return TRUE; /* we already ended the grab */
         }
@@ -2637,7 +2734,7 @@ process_workspace_switch_grab (MetaDisplay *display,
           meta_topic (META_DEBUG_KEYBINDINGS,
                       "Activating target workspace\n");
 
-          switch_to_workspace (display, target_workspace);
+          meta_workspace_activate (target_workspace);
 
           return TRUE; /* we already ended the grab */
         }
@@ -2659,7 +2756,7 @@ 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);
     }
   else
     meta_screen_show_desktop (screen);
@@ -2824,6 +2921,7 @@ do_choose_window (MetaDisplay    *display,
                                            tab_op_from_tab_type (type) :
                                            cycle_op_from_tab_type (type),
                                            FALSE,
+                                           event->xkey.serial,
                                            0,
                                            binding->mask,
                                            event->xkey.time,
@@ -3231,6 +3329,7 @@ handle_workspace_switch  (MetaDisplay    *display,
                                   NULL,
                                   META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
                                   FALSE,
+                                  event->xkey.serial,
                                   0,
                                   grab_mask,
                                   event->xkey.time,
@@ -3257,7 +3356,7 @@ handle_workspace_switch  (MetaDisplay    *display,
           meta_display_end_grab_op (display, event->xkey.time);
         }
       
-      switch_to_workspace (display, next);
+      meta_workspace_activate (next);
 
       if (grabbed_before_release)
         {

src/main.c

@@ -378,7 +378,11 @@ main (int argc, char **argv)
 #else
   meta_verbose ("Compiled without startup notification\n");
 #endif
-
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  meta_verbose ("Compiled with composite extensions\n");
+#else
+  meta_verbose ("Compiled without composite extensions\n");
+#endif
   
   /* Load prefs */
   meta_prefs_init ();
@@ -421,18 +425,36 @@ main (int argc, char **argv)
   
   meta_ui_set_current_theme (meta_prefs_get_theme (), FALSE);
 
-  /* Try some panic stuff, this is lame but we really
-   * don't want users to lose their WM :-/
+  /* Try to find some theme that'll work if the theme preference
+   * doesn't exist.  First try Simple (the default theme) then just
+   * try anything in the themes directory.
    */
   if (!meta_ui_have_a_theme ())
     meta_ui_set_current_theme ("Simple", FALSE);
   
   if (!meta_ui_have_a_theme ())
-    meta_ui_set_current_theme ("Atlanta", FALSE);
-
-  if (!meta_ui_have_a_theme ())
-    meta_ui_set_current_theme ("Crux", FALSE);
-
+    {
+      const char *dir_entry = NULL;
+      GError *err = NULL;
+      GDir   *themes_dir = NULL;
+      
+      if (!(themes_dir = g_dir_open (METACITY_DATADIR"/themes", 0, &err)))
+        {
+          meta_fatal (_("Failed to scan themes directory: %s\n"), err->message);
+          g_error_free (err);
+        } 
+      else 
+        {
+          while (((dir_entry = g_dir_read_name (themes_dir)) != NULL) && 
+                 (!meta_ui_have_a_theme ()))
+            {
+              meta_ui_set_current_theme (dir_entry, FALSE);
+            }
+          
+          g_dir_close (themes_dir);
+        }
+    }
+  
   if (!meta_ui_have_a_theme ())
     meta_fatal (_("Could not find a theme! Be sure %s exists and contains the usual themes."),
                 METACITY_DATADIR"/themes");

src/menu.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2004 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -36,6 +37,7 @@ struct _MenuItem
 {
   MetaMenuOp op;
   const char *stock_id;
+  const gboolean checked;
   const char *label;
 };
 
@@ -49,18 +51,24 @@ struct _MenuData
 static void activate_cb (GtkWidget *menuitem, gpointer data);
 
 static MenuItem menuitems[] = {
-  { META_MENU_OP_MINIMIZE, METACITY_STOCK_MINIMIZE, N_("Mi_nimize") },
-  { META_MENU_OP_MAXIMIZE, METACITY_STOCK_MAXIMIZE, N_("Ma_ximize") },
-  { META_MENU_OP_UNMAXIMIZE, NULL, N_("Unma_ximize") },
-  { META_MENU_OP_SHADE, NULL, N_("Roll _Up") },
-  { META_MENU_OP_UNSHADE, NULL, N_("_Unroll") },
-  { META_MENU_OP_MOVE, NULL, N_("_Move") },
-  { META_MENU_OP_RESIZE, NULL, N_("_Resize") },
-  { 0, NULL, NULL }, /* separator */
-  { META_MENU_OP_DELETE, METACITY_STOCK_DELETE, N_("_Close") },
-  { 0, NULL, NULL }, /* separator */
-  { META_MENU_OP_STICK, NULL, N_("Put on _All Workspaces") },
-  { META_MENU_OP_UNSTICK, NULL, N_("Only on _This Workspace") }
+  { META_MENU_OP_MINIMIZE, METACITY_STOCK_MINIMIZE, FALSE, N_("Mi_nimize") },
+  { META_MENU_OP_MAXIMIZE, METACITY_STOCK_MAXIMIZE, FALSE, N_("Ma_ximize") },
+  { META_MENU_OP_UNMAXIMIZE, NULL, FALSE, N_("Unma_ximize") },
+  { META_MENU_OP_SHADE, NULL, FALSE, N_("Roll _Up") },
+  { META_MENU_OP_UNSHADE, NULL, FALSE, N_("_Unroll") },
+  { META_MENU_OP_ABOVE, NULL, FALSE, N_("On _Top") },
+  { META_MENU_OP_UNABOVE, NULL, TRUE, N_("On _Top") },
+  { META_MENU_OP_MOVE, NULL, FALSE, N_("_Move") },
+  { 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_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") },
+  { META_MENU_OP_MOVE_RIGHT, NULL, FALSE, N_("Move to Workspace R_ight") },
+  { META_MENU_OP_MOVE_UP, NULL, FALSE, N_("Move to Workspace _Up") },
+  { META_MENU_OP_MOVE_DOWN, NULL, FALSE, N_("Move to Workspace _Down") }
 };
 
 static void
@@ -96,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);
   
@@ -114,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")),
@@ -157,26 +167,30 @@ get_workspace_name_with_accel (Display *display,
        * Above name is a pointer into the Workspace struct. Here we make
        * a copy copy so we can have our wicked way with it.
        */
-      new_name = g_strdup_printf (_("Workspace %s%d"),
-                                  number < 10 ? "_" : "",
-                                  number);
+      if (number == 10)
+        new_name = g_strdup_printf (_("Workspace 1_0"));
+      else
+        new_name = g_strdup_printf (_("Workspace %s%d"),
+                                    number < 10 ? "_" : "",
+                                    number);
       return new_name;
     }
   else
     {
       /*
-       * Otherwise this is just a normal name to which we cannot really
-       * add accelerators. Escape any _ characters so that the user's
-       * workspace names do not get mangled.
+       * Otherwise this is just a normal name. Escape any _ characters so that
+       * the user's workspace names do not get mangled.  If the number is less
+       * than 10 we provide an accelerator.
        */
       char *new_name;
       const char *source;
       char *dest;
 
       /*
-       * Assume the worst case, that every character is a _
+       * Assume the worst case, that every character is a _.  We also
+       * provide memory for " (_#)"
        */
-      new_name = g_malloc0 (strlen (name) * 2 + 1);
+      new_name = g_malloc0 (strlen (name) * 2 + 6 + 1);
 
       /*
        * Now iterate down the strings, adding '_' to escape as we go
@@ -190,6 +204,16 @@ get_workspace_name_with_accel (Display *display,
           *dest++ = *source++;
         }
 
+      /* People don't start at workstation 0, but workstation 1 */
+      if (index < 9)
+        {
+          g_snprintf (dest, 6, " (_%d)", index + 1);
+        }
+      else if (index == 9)
+        {
+          g_snprintf (dest, 6, " (_0)");
+        }
+
       return new_name;
     }
 }
@@ -197,13 +221,20 @@ get_workspace_name_with_accel (Display *display,
 static GtkWidget*
 menu_item_new (const char         *label,
                gboolean            with_image,
+	       gboolean		   with_check,
                unsigned int        key,
                MetaVirtualModifier mods)
 {
   GtkWidget *menu_item;
   GtkWidget *accel_label;
 
-  if (with_image)
+  if (with_check)
+    {
+      menu_item = gtk_check_menu_item_new ();    
+      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
+                                      TRUE);
+    }
+  else if (with_image)
     menu_item = gtk_image_menu_item_new ();
   else
     menu_item = gtk_menu_item_new ();
@@ -232,13 +263,16 @@ meta_window_menu_new   (MetaFrames         *frames,
   int i;
   MetaWindowMenu *menu;
 
+  if (n_workspaces < 2)
+    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);
+  
   menu = g_new (MetaWindowMenu, 1);
   menu->frames = frames;
   menu->client_xwindow = client_xwindow;
   menu->func = func;
   menu->data = data;
   menu->ops = ops;
-  menu->insensitive = insensitive;
+  menu->insensitive = insensitive;  
   
   menu->menu = gtk_menu_new ();
 
@@ -274,17 +308,18 @@ meta_window_menu_new   (MetaFrames         *frames,
 
               meta_core_get_menu_accelerator (menuitems[i].op, -1,
                                               &key, &mods);
-              
+
               if (image)
                 {
-                  mi = menu_item_new (_(menuitems[i].label), TRUE, key, mods);
+                  mi = menu_item_new (_(menuitems[i].label), TRUE, FALSE, key, mods);
                   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
                                                  image);
                   gtk_widget_show (image);
                 }
               else
                 {
-                  mi = menu_item_new (_(menuitems[i].label), FALSE, key, mods);
+                  mi = menu_item_new (_(menuitems[i].label), FALSE, 
+                                      menuitems[i].checked, key, mods);
                 }
               
               if (insensitive & menuitems[i].op)
@@ -313,72 +348,74 @@ meta_window_menu_new   (MetaFrames         *frames,
 
   if (ops & META_MENU_OP_WORKSPACES)
     {
+
+      GtkWidget *mi;
+      Display *display;
+      Window xroot;
+      GdkScreen *screen;
+      GtkWidget *submenu;
+      GtkWidget *submenuitem;
+
       meta_verbose ("Creating %d-workspace menu current space %d\n",
                     n_workspaces, active_workspace);
-      
-      if (n_workspaces > 1)
+          
+      display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window);
+          
+      screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window);
+      xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));
+
+      submenu = gtk_menu_new ();
+      submenuitem = menu_item_new (_("Move to Another _Workspace"), FALSE, FALSE, 0, 0);
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (submenuitem), submenu);
+      gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu),
+			     submenuitem);
+      gtk_widget_show (submenuitem);
+           
+      i = 0;
+      while (i < n_workspaces)
         {
-          GtkWidget *mi;
-          Display *display;
-          Window xroot;
-          GdkScreen *screen;
-            
-          display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window);
-          
-          screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window);
-          xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));
-          
-          i = 0;
-          while (i < n_workspaces)
-            {
-              char *label, *name;
-              MenuData *md;
-              unsigned int key;
-              MetaVirtualModifier mods;
+          char *label;
+          MenuData *md;
+          unsigned int key;
+          MetaVirtualModifier mods;
               
-              meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
-                                              i + 1,
-                                              &key, &mods);
+          meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
+                                          i + 1,
+                                          &key, &mods);
               
-              name = get_workspace_name_with_accel (display, xroot, i);
-              if (ops & META_MENU_OP_UNSTICK)
-                label = g_strdup_printf (_("Only on %s"), name);
-              else
-                label = g_strdup_printf(_("Move to %s"), name);
-              mi = menu_item_new (label, FALSE, key, mods);
+          label = get_workspace_name_with_accel (display, xroot, i);
+          mi = menu_item_new (label, FALSE, FALSE, key, mods);
 
-              g_free (name);
-              g_free (label);
+          g_free (label);
 
-              if (!(ops & META_MENU_OP_UNSTICK) &&
-                  (active_workspace == i ||
-                   insensitive & META_MENU_OP_WORKSPACES))
-                gtk_widget_set_sensitive (mi, FALSE);
-	      else if (insensitive & META_MENU_OP_WORKSPACES)
-		gtk_widget_set_sensitive (mi, FALSE);
-              md = g_new (MenuData, 1);
+          if (!(ops & META_MENU_OP_UNSTICK) &&
+              (active_workspace == i ||
+               insensitive & META_MENU_OP_WORKSPACES))
+            gtk_widget_set_sensitive (mi, FALSE);
+          else if (insensitive & META_MENU_OP_WORKSPACES)
+            gtk_widget_set_sensitive (mi, FALSE);
+          md = g_new (MenuData, 1);
 
-              md->menu = menu;
-              md->op = META_MENU_OP_WORKSPACES;
+          md->menu = menu;
+          md->op = META_MENU_OP_WORKSPACES;
 
-              g_object_set_data (G_OBJECT (mi),
-                                 "workspace",
-                                 GINT_TO_POINTER (i));
+          g_object_set_data (G_OBJECT (mi),
+                             "workspace",
+                             GINT_TO_POINTER (i));
           
-              gtk_signal_connect_full (GTK_OBJECT (mi),
-                                       "activate",
-                                       GTK_SIGNAL_FUNC (activate_cb),
-                                       NULL,
-                                       md,
-                                       g_free, FALSE, FALSE);
+          gtk_signal_connect_full (GTK_OBJECT (mi),
+                                   "activate",
+                                   GTK_SIGNAL_FUNC (activate_cb),
+                                   NULL,
+                                   md,
+                                   g_free, FALSE, FALSE);
 
-              gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu),
-                                     mi);
+          gtk_menu_shell_append (GTK_MENU_SHELL (submenu),
+                                 mi);
           
-              gtk_widget_show (mi);
+          gtk_widget_show (mi);
           
-              ++i;
-            }
+          ++i;
         }
     }
   else

src/metacity-dialog.c

@@ -255,6 +255,8 @@ warn_about_no_sm_support (char **lame_apps)
   gtk_window_set_geometry_hints (GTK_WINDOW (dialog),
                                  sw, NULL, 0);
 
+  gtk_window_set_resizable (GTK_WINDOW(dialog), TRUE);
+
   /* applies to geometry widget; try to avoid scrollbars,
    * but don't make the window huge
    */

src/metacity.schemas.in

@@ -66,7 +66,7 @@
       <applyto>/apps/metacity/general/action_double_click_titlebar</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>toggle_shade</default>
+      <default>toggle_maximize</default>
       <locale name="C">
          <short>Action on title bar double-click</short>
          <long>
@@ -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> 
@@ -257,6 +257,25 @@
       </locale>
     </schema>
 
+    <schema>
+      <key>/schemas/apps/metacity/general/reduced_resources</key>
+      <applyto>/apps/metacity/general/reduced_resources</applyto>
+      <owner>metacity</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+         <short>If true, trade off usability for less resource usage</short>
+         <long>
+          If true, metacity will give the user less feedback and 
+        less sense of "direct manipulation", by using wireframes, 
+        avoiding animations, or other means. This is a significant 
+        reduction in usability for many users, but may allow 
+        legacy applications and terminal servers to function 
+        when they would otherwise be impractical.
+         </long>
+      </locale>
+    </schema>
+
     <!-- Window Keybindings -->
 
     <schema>
@@ -269,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
@@ -291,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
@@ -314,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
@@ -335,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
@@ -353,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
@@ -373,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
@@ -391,12 +410,12 @@ you set
       <applyto>/apps/metacity/window_keybindings/toggle_shaded</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>&lt;Alt&gt;F12</default>
+      <default>disabled</default>
       <locale name="C">
          <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
@@ -414,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
@@ -435,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
@@ -456,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
@@ -478,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
@@ -504,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
@@ -527,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
@@ -550,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
@@ -573,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
@@ -596,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
@@ -619,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
@@ -642,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
@@ -666,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
@@ -689,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
@@ -712,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
@@ -735,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
@@ -758,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
@@ -781,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
@@ -798,14 +817,14 @@ you set
       <applyto>/apps/metacity/window_keybindings/move_to_workspace_left</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>&lt;Shift&gt;&lt;Alt&gt;Left</default>
+      <default>&lt;Control&gt;&lt;Shift&gt;&lt;Alt&gt;Left</default>
       <locale name="C">
          <short>Move window one workspace to the left</short>
          <long>
           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
@@ -823,14 +842,14 @@ you set
       <applyto>/apps/metacity/window_keybindings/move_to_workspace_right</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>&lt;Shift&gt;&lt;Alt&gt;Right</default>
+      <default>&lt;Control&gt;&lt;Shift&gt;&lt;Alt&gt;Right</default>
       <locale name="C">
          <short>Move window one workspace to the right</short>
          <long>
           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
@@ -847,14 +866,14 @@ you set
       <applyto>/apps/metacity/window_keybindings/move_to_workspace_up</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>&lt;Shift&gt;&lt;Alt&gt;Up</default>
+      <default>&lt;Control&gt;&lt;Shift&gt;&lt;Alt&gt;Up</default>
       <locale name="C">
          <short>Move window one workspace up</short>
          <long>
           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
@@ -871,14 +890,14 @@ you set
       <applyto>/apps/metacity/window_keybindings/move_to_workspace_down</applyto>
       <owner>metacity</owner>
       <type>string</type>
-      <default>&lt;Shift&gt;&lt;Alt&gt;Down</default>
+      <default>&lt;Control&gt;&lt;Shift&gt;&lt;Alt&gt;Down</default>
       <locale name="C">
          <short>Move window one workspace down</short>
          <long>
           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
@@ -905,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
@@ -928,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
@@ -951,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
@@ -974,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
@@ -997,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
@@ -1026,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
@@ -1051,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
@@ -1075,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
@@ -1099,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
@@ -1125,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
@@ -1150,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
@@ -1174,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
@@ -1198,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
@@ -1222,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
@@ -1245,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
@@ -1268,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
@@ -1291,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
@@ -1315,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
@@ -1339,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
@@ -1364,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
@@ -1389,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
@@ -1413,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
@@ -1438,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
@@ -1463,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
@@ -1487,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
@@ -1510,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
@@ -1535,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
@@ -1561,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
@@ -1586,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
@@ -1611,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
@@ -1634,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
@@ -1652,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
@@ -1681,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
@@ -1705,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
@@ -1740,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/place.c

@@ -668,6 +668,7 @@ meta_window_place (MetaWindow        *window,
       if (parent)
         {
           int w;
+          MetaRectangle area;
 
           meta_window_get_position (parent, &x, &y);
           w = parent->rect.width;
@@ -677,17 +678,25 @@ meta_window_place (MetaWindow        *window,
           /* center of child over center of parent */
           x -= window->rect.width / 2;
 
-          /* put child down 1/5 or so from the top of parent, unless
-           * it makes us have more of parent showing above child than
-           * below
+          /* "visually" center window over parent, leaving twice as
+           * much space below as on top.
            */
-          if (window->rect.height <= (parent->rect.height - (parent->rect.height / 5) * 2))
-            y += parent->rect.height / 5;
+          y += (parent->rect.height - window->rect.height)/3;
 
           /* put top of child's frame, not top of child's client */
           if (fgeom)
             y += fgeom->top_height;
 
+          /* clip to xinerama of parent*/
+          meta_window_get_work_area_current_xinerama (parent, &area);
+
+          if (x + window->rect.width > area.x + area.width) 
+            x = area.x + area.width - window->rect.width;
+          if (y + window->rect.height > area.y + area.height) 
+            y = area.y + area.height - window->rect.height;
+          if (x < area.x) x = area.x;
+          if (y < area.y) y = area.y;     
+
           meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
                       window->desc);
           
@@ -826,9 +835,7 @@ meta_window_place (MetaWindow        *window,
       if (outer.width >= workarea.width &&
           outer.height >= workarea.height)
         {
-          outer.x = x;
-          outer.y = y;
-          meta_window_maximize_internal (window, &outer);
+          window->maximize_after_placement = TRUE;
         }
     }
   

src/prefs.c

@@ -51,6 +51,7 @@
 #define KEY_APPLICATION_BASED "/apps/metacity/general/application_based"
 #define KEY_DISABLE_WORKAROUNDS "/apps/metacity/general/disable_workarounds"
 #define KEY_BUTTON_LAYOUT "/apps/metacity/general/button_layout"
+#define KEY_REDUCED_RESOURCES "/apps/metacity/general/reduced_resources"
 
 #define KEY_COMMAND_PREFIX "/apps/metacity/keybinding_commands/command_"
 #define KEY_SCREEN_BINDINGS_PREFIX "/apps/metacity/global_keybindings"
@@ -83,6 +84,8 @@ static gboolean auto_raise = FALSE;
 static gboolean auto_raise_delay = 500;
 static gboolean provide_visual_bell = TRUE;
 static gboolean bell_is_audible = TRUE;
+static gboolean reduced_resources = FALSE;
+
 static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_INVALID;
 static MetaButtonLayout button_layout = {
   {
@@ -129,6 +132,7 @@ static gboolean update_command            (const char  *name,
                                            const char  *value);
 static gboolean update_workspace_name     (const char  *name,
                                            const char  *value);
+static gboolean update_reduced_resources  (gboolean     value);
 
 static void change_notify (GConfClient    *client,
                            guint           cnxn_id,
@@ -372,7 +376,6 @@ meta_prefs_init (void)
   cleanup_error (&err);
   update_button_layout (str_val);
   g_free (str_val);
-#endif /* HAVE_GCONF */
   
   bool_val = gconf_client_get_bool (default_client, KEY_VISUAL_BELL,
                                     &err);
@@ -388,6 +391,12 @@ meta_prefs_init (void)
   update_visual_bell_type (str_val);
   g_free (str_val);
 
+  bool_val = gconf_client_get_bool (default_client, KEY_REDUCED_RESOURCES,
+				    &err);
+  cleanup_error (&err);
+  update_reduced_resources (bool_val);
+#endif /* HAVE_GCONF */
+  
   /* Load keybindings prefs */
   init_bindings ();
 
@@ -706,6 +715,13 @@ change_notify (GConfClient    *client,
     {
       gboolean b;
 
+      if (value && value->type != GCONF_VALUE_BOOL)
+        {
+          meta_warning (_("GConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
       b = value ? gconf_value_get_bool (value) : provide_visual_bell;      
       if (update_visual_bell (b, bell_is_audible))
 	queue_changed (META_PREF_VISUAL_BELL);	    
@@ -714,6 +730,13 @@ change_notify (GConfClient    *client,
     {
       gboolean b;
 
+      if (value && value->type != GCONF_VALUE_BOOL)
+        {
+          meta_warning (_("GConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
       b = value ? gconf_value_get_bool (value) : bell_is_audible;      
       if (update_visual_bell (provide_visual_bell, b))
 	queue_changed (META_PREF_AUDIBLE_BELL);
@@ -733,6 +756,22 @@ change_notify (GConfClient    *client,
       if (update_visual_bell_type (str))
 	queue_changed (META_PREF_VISUAL_BELL_TYPE);
     }
+  else if (strcmp (key, KEY_REDUCED_RESOURCES) == 0)
+    {
+      gboolean b;
+
+      if (value && value->type != GCONF_VALUE_BOOL)
+        {
+          meta_warning (_("GConf key \"%s\" is set to an invalid type\n"),
+                        KEY_REDUCED_RESOURCES);
+          goto out;
+        }
+
+      b = value ? gconf_value_get_bool (value) : reduced_resources;
+
+      if (update_reduced_resources (b))
+        queue_changed (META_PREF_REDUCED_RESOURCES);
+    }
   else
     {
       meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Metacity\n",
@@ -1239,6 +1278,16 @@ update_auto_raise_delay (int value)
 
   return old != auto_raise_delay;
 }
+
+static gboolean
+update_reduced_resources (gboolean value)
+{
+  gboolean old = reduced_resources;
+
+  reduced_resources = value;
+
+  return old != reduced_resources;
+}
 #endif /* HAVE_GCONF */
 
 #ifdef WITH_VERBOSE_MODE
@@ -1305,6 +1354,10 @@ meta_preference_to_string (MetaPreference pref)
     case META_PREF_VISUAL_BELL_TYPE:
       return "VISUAL_BELL_TYPE";
       break;
+
+    case META_PREF_REDUCED_RESOURCES:
+      return "REDUCED_RESOURCES";
+      break;
     }
 
   return "(unknown)";
@@ -1974,6 +2027,12 @@ meta_prefs_get_auto_raise_delay ()
   return auto_raise_delay;
 }
 
+gboolean
+meta_prefs_get_reduced_resources ()
+{
+  return reduced_resources;
+}
+
 MetaKeyBindingAction
 meta_prefs_get_keybinding_action (const char *name)
 {

src/prefs.h

@@ -45,7 +45,8 @@ typedef enum
   META_PREF_WORKSPACE_NAMES,
   META_PREF_VISUAL_BELL,
   META_PREF_AUDIBLE_BELL,
-  META_PREF_VISUAL_BELL_TYPE
+  META_PREF_VISUAL_BELL_TYPE,
+  META_PREF_REDUCED_RESOURCES
 } MetaPreference;
 
 typedef void (* MetaPrefsChangedFunc) (MetaPreference pref,
@@ -69,6 +70,7 @@ gboolean                    meta_prefs_get_application_based  (void);
 gboolean                    meta_prefs_get_disable_workarounds (void);
 gboolean                    meta_prefs_get_auto_raise         (void);
 int                         meta_prefs_get_auto_raise_delay   (void);
+gboolean                    meta_prefs_get_reduced_resources  (void);
 
 const char*                 meta_prefs_get_command            (int i);
 
@@ -222,7 +224,7 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_COMMAND_9,
   META_KEYBINDING_ACTION_COMMAND_10,
   META_KEYBINDING_ACTION_COMMAND_11,
-  META_KEYBINDING_ACTION_COMMAND_12,
+  META_KEYBINDING_ACTION_COMMAND_12
 } MetaKeyBindingAction;
 
 typedef struct

src/run-metacity.sh

@@ -1,11 +1,11 @@
 #! /bin/bash
 
 if test -z "$XNEST_DISPLAY"; then
-  XNEST_DISPLAY=:1
+  XNEST_DISPLAY=:8
 fi
 
 if test -z "$CLIENT_DISPLAY"; then
-  CLIENT_DISPLAY=:1
+  CLIENT_DISPLAY=:8
 fi
 
 if test -z "$METACITY_DISPLAY"; then

src/screen.c

@@ -34,6 +34,7 @@
 #include "keybindings.h"
 #include "stack.h"
 #include "xprops.h"
+#include "compositor.h"
 
 #ifdef HAVE_SOLARIS_XINERAMA
 #include <X11/extensions/xinerama.h>
@@ -56,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);
@@ -81,7 +85,7 @@ set_wm_check_hint (MetaScreen *screen)
 static int
 set_supported_hint (MetaScreen *screen)
 {
-#define N_SUPPORTED 49
+#define N_SUPPORTED 58
   Atom atoms[N_SUPPORTED];
   
   atoms[0] = screen->display->atom_net_wm_name;
@@ -133,6 +137,17 @@ set_supported_hint (MetaScreen *screen)
   atoms[46] = screen->display->atom_net_wm_state_above;
   atoms[47] = screen->display->atom_net_wm_state_below;
   atoms[48] = screen->display->atom_net_startup_id;
+  atoms[49] = screen->display->atom_net_wm_strut_partial;
+  atoms[50] = screen->display->atom_net_wm_action_fullscreen;
+  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,
@@ -356,7 +371,8 @@ reload_xinerama_infos (MetaScreen *screen)
 
 MetaScreen*
 meta_screen_new (MetaDisplay *display,
-                 int          number)
+                 int          number,
+                 Time         timestamp)
 {
   MetaScreen *screen;
   Window xroot;
@@ -422,24 +438,7 @@ meta_screen_new (MetaDisplay *display,
 
   new_wm_sn_owner = meta_create_offscreen_window (xdisplay, xroot);
 
-  {
-    /* Generate a timestamp */
-    XSetWindowAttributes attrs;
-    XEvent event;
-
-    attrs.event_mask = PropertyChangeMask;
-    XChangeWindowAttributes (xdisplay, new_wm_sn_owner, CWEventMask, &attrs);
-    
-    XChangeProperty (xdisplay,
-                     new_wm_sn_owner, XA_WM_CLASS, XA_STRING, 8,
-                     PropModeAppend, NULL, 0);
-    XWindowEvent (xdisplay, new_wm_sn_owner, PropertyChangeMask, &event);
-    attrs.event_mask = NoEventMask;
-    XChangeWindowAttributes (display->xdisplay,
-                             new_wm_sn_owner, CWEventMask, &attrs);
-
-    manager_timestamp = event.xproperty.time;
-  }
+  manager_timestamp = timestamp;
   
   XSetSelectionOwner (xdisplay, wm_sn_atom, new_wm_sn_owner,
                       manager_timestamp);
@@ -498,6 +497,9 @@ meta_screen_new (MetaDisplay *display,
                 LeaveWindowMask | EnterWindowMask |
                 KeyPressMask | KeyReleaseMask |
                 FocusChangeMask | StructureNotifyMask |
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+                ExposureMask |
+#endif
 		attr.your_event_mask);
   if (meta_error_trap_pop_with_return (display, FALSE) != Success)
     {
@@ -538,19 +540,34 @@ meta_screen_new (MetaDisplay *display,
   screen->starting_corner = META_SCREEN_TOPLEFT;
 
   screen->showing_desktop = FALSE;
+
+  screen->compositor_windows = NULL;
+  screen->damage_region = None;
+  screen->root_picture = None;
+  screen->trans_pixmap = None;
+  screen->trans_picture = None;
+  
+  {
+    XGCValues gc_values;
+    
+    gc_values.subwindow_mode = IncludeInferiors;
+    gc_values.function = GXinvert;
+    gc_values.line_width = META_WIREFRAME_XOR_LINE_WIDTH;
+    
+    screen->root_xor_gc = XCreateGC (screen->display->xdisplay,
+                                     screen->xroot,
+                                     GCSubwindowMode | GCFunction | GCLineWidth,
+                                     &gc_values);
+  }
   
   screen->xinerama_infos = NULL;
   screen->n_xinerama_infos = 0;
-  screen->last_xinerama_index = 0;
+  screen->last_xinerama_index = 0;  
   
   reload_xinerama_infos (screen);
   
   meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
   
-  if (display->leader_window == None)
-    display->leader_window = meta_create_offscreen_window (display->xdisplay,
-                                                           screen->xroot);
-  
   if (display->no_focus_window == None)
     {
       display->no_focus_window = meta_create_offscreen_window (display->xdisplay,
@@ -567,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 */
@@ -622,9 +643,12 @@ meta_screen_new (MetaDisplay *display,
     if (space != NULL)
       meta_workspace_activate (space);
   }
+
+  meta_compositor_manage_screen (screen->display->compositor,
+                                 screen);
   
   meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
-                screen->number, screen->screen_name, screen->xroot);  
+                screen->number, screen->screen_name, screen->xroot);
   
   return screen;
 }
@@ -640,6 +664,9 @@ meta_screen_free (MetaScreen *screen)
   
   meta_display_grab (display);
 
+  meta_compositor_unmanage_screen (screen->display->compositor,
+                                   screen);
+  
   meta_display_unmanage_windows_for_screen (display, screen);
   
   meta_prefs_remove_listener (prefs_changed_callback, screen);
@@ -679,6 +706,9 @@ meta_screen_free (MetaScreen *screen)
   
   if (screen->work_area_idle != 0)
     g_source_remove (screen->work_area_idle);
+
+  XFreeGC (screen->display->xdisplay,
+           screen->root_xor_gc);
   
   g_free (screen->screen_name);
   g_free (screen);
@@ -714,7 +744,26 @@ meta_screen_manage_all_windows (MetaScreen *screen)
   i = 0;
   while (i < n_children)
     {
-      meta_window_new (screen->display, children[i], TRUE);
+      XWindowAttributes attrs;
+      
+      meta_error_trap_push_with_return (screen->display);
+      
+      XGetWindowAttributes (screen->display->xdisplay,
+                            children[i], &attrs);
+      
+      if (meta_error_trap_pop_with_return (screen->display, TRUE) != Success)
+        {
+          meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        children[i]);
+        }
+      else
+        {
+          meta_window_new_with_attrs (screen->display, children[i], TRUE,
+                                      &attrs);
+
+          meta_compositor_add_window (screen->display->compositor,
+                                      children[i], &attrs);
+        }
 
       ++i;
     }
@@ -929,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)
 {
@@ -1188,9 +1282,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;
@@ -1220,22 +1314,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*
@@ -1572,6 +1651,8 @@ meta_screen_update_workspace_layout (MetaScreen *screen)
                     break;
                 }
             }
+          else
+            screen->starting_corner = META_SCREEN_TOPLEFT;
         }
       else
         {
@@ -1679,6 +1760,7 @@ meta_create_offscreen_window (Display *xdisplay,
    * (but on a display we are managing at least one screen for)
    */
   attrs.override_redirect = True;
+  attrs.event_mask = PropertyChangeMask;
   
   return XCreateWindow (xdisplay,
                         parent,
@@ -1687,7 +1769,7 @@ meta_create_offscreen_window (Display *xdisplay,
                         CopyFromParent,
                         CopyFromParent,
                         CopyFromParent,
-                        CWOverrideRedirect,
+                        CWOverrideRedirect | CWEventMask,
                         &attrs);
 }
 
@@ -2077,6 +2159,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);
@@ -2442,6 +2525,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",
@@ -2461,6 +2545,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

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -56,6 +57,8 @@ typedef enum
   META_SCREEN_RIGHT
 } MetaScreenDirection;
 
+#define META_WIREFRAME_XOR_LINE_WIDTH 5
+
 struct _MetaScreen
 {
   MetaDisplay *display;
@@ -108,10 +111,21 @@ struct _MetaScreen
   guint showing_desktop : 1;
   
   int closing;
+
+  /* gc for XOR on root window */
+  GC root_xor_gc;
+
+  /* Managed by compositor.c; top of stack is first in list */
+  GList *compositor_windows;
+  XID root_picture;
+  XID damage_region;
+  XID trans_pixmap;
+  XID trans_picture;
 };
 
 MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
-                                               int                         number);
+                                               int                         number,
+                                               Time                        timestamp);
 void          meta_screen_free                (MetaScreen                 *screen);
 void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
 MetaScreen*   meta_screen_for_x_screen        (Screen                     *xscreen);
@@ -134,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;
     }

src/stack.c

@@ -3,6 +3,7 @@
 /* 
  * Copyright (C) 2001 Havoc Pennington
  * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2004 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -31,7 +32,23 @@
 
 #include <X11/Xatom.h>
 
+#define WINDOW_HAS_TRANSIENT_TYPE(w)                    \
+          (w->type == META_WINDOW_DIALOG ||             \
+	   w->type == META_WINDOW_MODAL_DIALOG ||       \
+           w->type == META_WINDOW_TOOLBAR ||            \
+           w->type == META_WINDOW_MENU ||               \
+           w->type == META_WINDOW_UTILITY)
+
+#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)             \
+         ((w->xtransient_for == None ||                 \
+           w->transient_parent_is_root_window) &&       \
+          WINDOW_HAS_TRANSIENT_TYPE (w))
+
+#define WINDOW_IN_STACK(w) (w->stack_position >= 0)
+
 static void 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)
@@ -107,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;  
 
@@ -147,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);
 }
@@ -157,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);
 }
@@ -280,36 +297,6 @@ get_standalone_layer (MetaWindow *window)
   return layer;
 }
 
-typedef struct
-{
-  MetaStackLayer max;
-} MaxLayerData;
-
-static gboolean
-max_layer_func (MetaWindow *window,
-                void       *data)
-{
-  MaxLayerData *d = data;
-  MetaStackLayer layer;
-  
-  layer = get_standalone_layer (window);
-  if (layer > d->max)
-    d->max = layer;
-
-  return TRUE;
-}
-
-static MetaStackLayer
-get_maximum_layer_of_ancestor (MetaWindow *window)
-{
-  MaxLayerData d;
-
-  d.max = get_standalone_layer (window);
-  meta_window_foreach_ancestor (window, max_layer_func, &d);
-  
-  return d.max;
-}
-
 /* Note that this function can never use window->layer only
  * get_standalone_layer, or we'd have issues.
  */
@@ -359,58 +346,29 @@ compute_layer (MetaWindow *window)
    * windows getting in fullscreen layer if any terminal is
    * fullscreen.
    */
-  if (window->type == META_WINDOW_DIALOG ||
-      window->type == META_WINDOW_MODAL_DIALOG ||
-      window->type == META_WINDOW_UTILITY ||
-      window->type == META_WINDOW_MENU ||
-      window->type == META_WINDOW_TOOLBAR)
+  if (WINDOW_HAS_TRANSIENT_TYPE(window) &&
+      (window->xtransient_for == None ||
+       window->transient_parent_is_root_window))
     {
-      if (window->xtransient_for != None &&
-          !window->transient_parent_is_root_window)
+      /* We only do the group thing if the dialog is NOT transient for
+       * a particular window. Imagine a group with a normal window, a dock,
+       * and a dialog transient for the normal window; you don't want the dialog
+       * above the dock if it wouldn't normally be.
+       */
+      
+      MetaStackLayer group_max;
+      
+      group_max = get_maximum_layer_in_group (window);
+      
+      if (group_max > window->layer)
         {
-          MetaStackLayer ancestor_max;
-
-          ancestor_max = get_maximum_layer_of_ancestor (window);
-          
-          if (ancestor_max > window->layer)
-            {
-              meta_topic (META_DEBUG_STACK,
-                          "Promoting window %s from layer %d to %d due to transiency\n",
-                          window->desc, window->layer, ancestor_max);
-              window->layer = ancestor_max;
-            }
-        }
-      else
-        {
-          /* We only do the group thing if the dialog is NOT transient for
-           * a particular window. Imagine a group with a normal window, a dock,
-           * and a dialog transient for the normal window; you don't want the dialog
-           * above the dock if it wouldn't normally be.
-           */
-
-          /* FIXME when promoting a window here,
-           * it's necessary to promote its transient children
-           * (or other windows constrained to be above it)
-           * as well, but we aren't handling that, and it's
-           * somewhat hard to fix.
-           *
-           * http://bugzilla.gnome.org/show_bug.cgi?id=96140
-           */
-          
-          MetaStackLayer group_max;
-          
-          group_max = get_maximum_layer_in_group (window);
-          
-          if (group_max > window->layer)
-            {
-              meta_topic (META_DEBUG_STACK,
-                          "Promoting window %s from layer %d to %d due to group membership\n",
-                          window->desc, window->layer, group_max);
-              window->layer = group_max;
-            }
+          meta_topic (META_DEBUG_STACK,
+                      "Promoting window %s from layer %d to %d due to group membership\n",
+                      window->desc, window->layer, group_max);
+          window->layer = group_max;
         }
     }
-  
+
   meta_topic (META_DEBUG_STACK, "Window %s on layer %d type = %d has_focus = %d\n",
               window->desc, window->layer,
               window->type, window->has_focus);
@@ -540,20 +498,6 @@ add_constraint (Constraint **constraints,
   constraints[below->stack_position] = c;
 }
 
-#define WINDOW_HAS_TRANSIENT_TYPE(w)                    \
-          (w->type == META_WINDOW_DIALOG ||             \
-	   w->type == META_WINDOW_MODAL_DIALOG ||       \
-           w->type == META_WINDOW_TOOLBAR ||            \
-           w->type == META_WINDOW_MENU ||               \
-           w->type == META_WINDOW_UTILITY)
-
-#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)             \
-         ((w->xtransient_for == None ||                 \
-           w->transient_parent_is_root_window) &&       \
-          WINDOW_HAS_TRANSIENT_TYPE (w))
-
-#define WINDOW_IN_STACK(w) (w->stack_position >= 0)
-
 static void
 create_constraints (Constraint **constraints,
                     GList       *windows)
@@ -715,13 +659,21 @@ static void
 ensure_above (MetaWindow *above,
               MetaWindow *below)
 {  
+  if (WINDOW_HAS_TRANSIENT_TYPE(above) &&
+      above->layer < below->layer)
+    {
+      meta_topic (META_DEBUG_STACK,
+		  "Promoting window %s from layer %d to %d due to contraint\n",
+		  above->desc, above->layer, below->layer);
+      above->layer = below->layer;
+    }
+
   if (above->stack_position < below->stack_position)
     {
       /* move above to below->stack_position bumping below down the stack */
-      meta_window_set_stack_position (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",
               above->desc, above->stack_position,
               below->desc, below->stack_position);
@@ -935,6 +887,7 @@ meta_stack_ensure_sorted (MetaStack *stack)
                           w->desc, old_layer, w->layer);
               
               stack->need_resort = TRUE;
+              stack->need_constrain = TRUE;
               /* don't need to constrain as constraining
                * purely operates in terms of stack_position
                * not layer
@@ -947,7 +900,8 @@ meta_stack_ensure_sorted (MetaStack *stack)
       stack->need_relayer = FALSE;
     }
 
-  /* Update stack_position to reflect transiency constraints */
+  /* Update stack_position and layer to reflect transiency
+     constraints */
   constrain_stacking (stack);
   
   /* Sort stack->sorted with layers having priority over stack_position
@@ -1513,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;
@@ -1565,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
-
-
-
-