2.19.1 release.

2007-04-04 Elijah Newren <newren gmail com> * NEWS: 2.19.1 release. svn path=/trunk/; revision=3165
send synthetic configurenotify events also in response to MapRequest
2007-04-05 01:02:57 +00:00 · 2007-04-04 23:52:21 +00:00 · 2007-04-04 21:54:56 +00:00 · 2007-04-04 03:07:26 +00:00 · 2007-04-04 00:45:58 +00:00 · 2007-04-03 22:26:47 +00:00
164 changed files with 44670 additions and 30248 deletions
--- a/744
+++ b/744
@@ -1,3 +1,747 @@
+2007-04-04  Elijah Newren  <newren gmail com>
+
+        * NEWS: 2.19.1 release.
+
+2007-04-04  Elijah Newren  <newren gmail com>
+
+	* src/window.c (meta_window_move_resize_internal): send synthetic
+	configurenotify events also in response to MapRequest events when
+	the window has a frame and the application specifies PPosition or
+	UPosition hints.  I believe they are already sent for all other
+	cases.  Should fix #322840.  Fixes the testcase at least.  :)
+
+2007-04-04  Elijah Newren  <newren gmail com>
+
+	Fix lots of little issues with min/max constraints and size
+	increment constraints.  Fixes #329152, #418395, and possibly
+	others.
+
+	* src/window-props.c (meta_set_normal_hints):
+	Do more checking to make sure application specified constraints
+	are self-consistent, modifying the size_hints as necessary to
+	achieve self-consistency.
+
+	* src/constraints.c (setup_constraint_info): remove ugly
+	copy-pasto, (constrain_size_increments): be careful that fixing
+	violation of the constraints doesn't cause a violation of the
+	minimum size constraints.
+
+	* src/window.c (ensure_size_hints_satisfied): new function,
+	(meta_window_unmaximize, meta_window_unmake_fullscreen): the
+	saved_rect may no longer be valid (as in the case of #329152) so
+	call ensure_size_hints_satisfied to fix it up.
+
+	* doc/how-to-get-focus-right.txt: Some minor spacing and wording
+	fixes completely unrelated to the rest of this commit
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	* src/window.c (meta_window_unmaximize):
+	Only use saved_rect for determining the position to unmaximize to
+	for the previously-maximized direction(s).  Fixes #355497.
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	* MAINTAINERS: Update.  #412319.
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	* src/display.c (meta_display_update_active_window_hint):
+	_NET_ACTIVE_WINDOW is a single xwindow id, not two.
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	* src/keybindings.c (handle_panel_keybinding): turn mouse_mode off
+	to prevent focus issues with the run application dialog.  Fixes
+	#374752.
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	Avoid some crashes when dragging windows partially offscreen.
+	Possible (or at least partial) fix for #353513.
+
+	* src/edge-resistance.c (apply_edge_resistance): be more careful
+	about calls to find_index_of_edge_near_position() returning
+	possibly invalid indices.  Also, add a warning comment to
+	find_index_of_edge_near_position().
+
+2007-04-03  Elijah Newren  <newren gmail com>
+
+	Patch from Carlo Wood to do some miscellaneous code cleanups found
+	while working on #358311.
+
+	* src/constraints.c (do_screen_and_xinerama_relative_constraints):
+	nicer way of avoiding compilation warning
+
+	* src/boxes.c (meta_rectangle_clamp_to_fit_into_region,
+	  meta_rectangle_clip_to_region, meta_rectangle_shove_into_region):
+	Much cleaner way of ignoring invalid boxes in comparisons
+
+2007-04-02  Elijah Newren  <newren gmail com>
+
+	Patch from Carlo Wood to fix handling of unidirectional
+	maximization and partial struts.  #358311.
+
+	* src/constraints.c (constrain_maximization):
+	determine target size for unidirectionally maximized windows by
+	determining how far they can be maximized without hitting
+	orthogonal struts.  Avoids weird "empty spaces".
+
+	* src/boxes.[ch] (meta_rectangle_expand_to_avoiding_struts):
+	new function
+
+2007-04-02  Elijah Newren  <newren gmail com>
+
+	Make the strut lists (stored in workspaces) record both the
+	rectangle and the side that the strut is on.  Lots of code
+	cleanups relating to struts.
+
+	* src/boxes.h (struct MetaStrut):
+	new struct for struts
+
+	* src/window.[ch] (struct MetaStruts, struct MetaWindow,
+	  meta_window_update_struts):
+	overhaul to make window's struts remember their side as well as
+	their rectangular location, and just use a list instead of several
+	copies of near-identical code for left/right/top/bottom (allowing
+	us to nuke MetaStruts struct as well)
+	
+	* src/testboxes.c (new_meta_strut, get_strut_list):
+	* src/workspace.c (ensure_work_areas_validated):
+	* src/boxes.c (meta_rectangle_get_minimal_spanning_set_for_region,
+	  meta_rectangle_expand_to_avoiding_struts,
+	  get_disjoint_strut_rect_list_in_region, fix_up_edges,
+	  meta_rectangle_find_onscreen_edges,
+	  meta_rectangle_find_nonintersected_xinerama_edges):
+	modify to handle struts being rectangle + side instead of just rectangle
+
+	* src/workspace.c (ensure_work_areas_validated):
+	simplify strut list creation considerably given MetaWindow change,
+	modify work_area computations to take advantage of region
+	computations being done (makes the code shorter as well as more
+	robust against pathological cases).
+
+	* src/util.[ch] (meta_free_gslist_and_elements):
+	new convenience function
+
+	* src/common.h (enum MetaDirection):
+	* src/edge-resistance.c (movement_towards_edge):
+	* src/boxes.c (meta_rectangle_edge_aligns,
+	  rectangle_and_edge_intersection, split_edge):
+	Add more MetaDirection fields for convenience
+
+	* src/boxes.h (enum FixedDirections):
+	* src/constraints.c (setup_constraint_info, place_window_if_needed):
+	add a FIXED_DIRECTION_NONE to the FixedDirections enum to make
+	code more clear
+
+2007-04-01  Bruno Boaventura <brunobol@gnome.org>
+
+	* src/theme.c (kill_window_question): Fallback to NORMAL state after
+	checking for the middle button. Fixes bug #419043.
+	Patch from Benjamin Berg <benjamin@sipsolutions.net>.	
+
+2007-03-31  Elijah Newren  <newren gmail com>
+
+	Clean up event mask handling and meta_create_offscreen_window, to
+	prevent nasty metacity/gdk interactions causing hangs. See #354213.
+
+	* src/screen.[ch] (meta_create_offscreen_window):
+	* src/display.c (meta_display_open):
+	* src/screen.c (meta_screen_new):
+	Add a valuemask parameter to meta_create_offscreen_window
+	
+	* src/display.c (meta_display_open):
+	make it explicit that we can't rely on PropertyNotify events for
+	the leader_window due to nasty metacity/gdk interaction
+
+	* src/session.c (warn_about_lame_clients_and_finish_interact):
+	remove cut-and-paste code for timestamp pinging and just call
+	meta_display_get_current_time_roundtrip
+
+2007-03-30  Elijah Newren  <newren gmail com>
+
+	Add support for _NET_WM_USER_TIME_WINDOW in order to cut down on
+	context switches.  Fixes #354213.
+
+	* src/display.c (meta_display_open):
+	* src/display.h (struct _MetaDisplay):
+	* src/screen.c (set_supported_hint):
+	new atom
+
+	* src/display.c (meta_display_open,
+	  meta_display_get_current_time_roundtrip):
+	* src/display.h (struct _MetaDisplay):
+	create a dedicated timestamp pinging window instead of reusing
+	display->leader_window
+
+	* src/display.c (event_callback):
+	* src/window-props.c (reload_net_wm_user_time_window):
+	* src/window.c (meta_window_new_with_attrs, meta_window_free,
+	  process_property_notify):
+	* src/window.h (struct _MetaWindow):
+	monitor property notify events on _NET_WM_USER_TIME_WINDOW windows too
+	
+	* src/window-props.[ch]:
+	new meta_window_reload_propert(y|ies)_from_xwindow() functions
+
+	* src/window-props.[ch]
+	  (init_net_wm_user_time_window, reload_net_wm_user_time_window,
+	  meta_display_init_window_prop_hooks):
+	* src/window.c (meta_window_new_with_attrs):
+	new hooks to handle new atom
+
+2007-03-26  Josselin Mouette  <joss@malsain.org>
+
+	* src/session.c (meta_session_init): if previous client ID
+	was supplied, use it in filename.
+	* src/session.c (set_clone_restart_commands): use --sm-client-id
+	in command line to restore session, not original file name.
+	* src/session.c (regenerate_save_file): generate filename using
+	client ID and not original file name.
+	* src/session.c (base_save_file): removed function.
+	Closes GNOME 407981, Debian 391287, Debian 315169.
+
+2007-03-25  Elijah Newren  <newren gmail com>
+
+	* configure.in: bump version to 2.19.1; doesn't make sense to have
+	the development version have a version number less than the stable
+	version.  ;-)
+
+2007-03-20  Arthur Taylor  <theycallhimart@gmail.com>
+
+        * src/frames.c (meta_frames_apply_shapes): adjusted the rounded
+          corners so that they fit nicely with the arcs around them.
+	  Fixes #399373.
+
+2007-03-17  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* src/ui.c: Remove #include <pango/pangox.h> since it's
+	apparently not installed anymore. Builds just fine without it too.
+
+2007-03-10  Charlie Brej  <cbrej@cs.man.ac.uk>
+
+	* src/metacity.schemas.in: add action_{middle|right}_click_titlebar.
+	Closes #408903.
+
+2007-03-09  Linus Torvalds  <torvalds@woody.linux-foundation.org>
+
+	* src/frames.c (meta_frame_middle_click_event,
+        meta_frame_right_click_event): honour preferences.
+	* src/prefs.[ch] (meta_prefs_get_action_middle_click_titlebar,
+        meta_prefs_get_action_right_click_titlebar): new functions.
+
+2007-02-20  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* Makefile.am: Add MAINTAINERS to EXTRA_DIST so others
+	can find out where to send patches. Hi Linus :-)
+
+2007-02-17  Linus Torvalds  <torvalds@woody.linux-foundation.org>
+
+        * src/common.h (MetaActionTitleBar): renamed from
+	MetaActionDoubleClickTitleBar; added _LOWER and _MENU.
+	* src/frames.c (meta_frame_titlebar_event): renamed
+	enums as above; added code to handle _LOWER and _MENU,
+	which is moved in from meta_frame_{middle|right}_click_event.
+	* src/frames.c (meta_frame_middle_click_event,
+        meta_frame_right_click_event): rewrote in terms of
+        meta_frame_titlebar_event.
+	* src/prefs.c: removed "DoubleClick" from names as above.
+	* src/prefs.c (action_titlebar_from_string): added cases
+	for "lower" and "menu".
+	Fixes #408902.
+
+2007-02-17  Linus Torvalds  <torvalds@woody.linux-foundation.org>
+
+        * src/frames.c (meta_frames_button_press_event): Split out
+	code for different kinds of click into separate functions.
+	Fixes #408899.
+	* src/frames.c (meta_frame_titlebar_event,
+         meta_frame_double_click_event, meta_frame_middle_click_event,
+         meta_frame_right_click_event): new functions.
+
+2007-01-27  Bruno Boaventura <brunobol@gnome.org>
+
+	* src/metacity-dialog.c (kill_window_question): Change dialog
+	icon because gnome-icon-theme have no more "panel-force-quit".
+	Patch from Jaap A. Haitsma <jaap@haitsma.org>.	
+
+2007-01-16  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * doc/compositor-control.txt: fix silly thinko.
+
+2007-01-16  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * configure.in: post-release bump to 2.17.8.
+
+2007-01-16  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * doc/compositor-control.txt: New file.
+
+2007-01-16  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * src/compositor.c (meta_compositor_new): Removed
+        #ifdef SPIFFY_COMPOSITOR throughout the file. Replaced with check
+	for environment variable METACITY_BLING, which may be temporary.
+
+2007-01-13  Bruno Boaventura  <brunobol@gnome.org>
+
+        * src/frames.c (meta_frames_motion_notify_event): Unmaximize
+        button must keep preesed appearence when clicked (hold down),
+        move off, and back over the button. Fixes #395560. Patch from
+        Mad Alex <madalexonline@yahoo.co.uk>.
+        
+2007-01-02  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * src/c-screen.c (meta_comp_screen_redirect): Remove double unref
+	of stacker object. Fixes #387761.
+
+2006-12-27  Bruno Boaventura  <brunoboaventura@gmail.com>
+
+        Move "On Top" option in menu. Fix #382962.
+
+        * src/common.h, src/core.c: Remove META_MENU_OP_UNABOVE.
+        * src/menu.c: remove unabove menu item and put above item
+        next "Always on Visible Viewport".
+        * src/window.c: remove handles of META_MENU_OP_UNABOVE.
+
+2006-12-21  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * src/compositor.c: Disabled bling for now; added function for
+	handling CirculateNotify XEvent; some commenting.
+	* src/compositor.h, src/c-window.c: fix function prototype visibility.
+
+2006-12-12  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * src/compositor.c (do_effect): Sanity check to avoid dereferencing
+	a null pointer.
+
+2006-12-10  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * configure.in: post-release bump to 2.17.5.
+
+2006-12-10  Thomas Thurman  <thomas@thurman.org.uk>
+
+        * NEWS: 2.17.3 release.
+
+2006-12-05  Christof Krüger  <mail@pop2wap.net>
+
+        * src/window.c (update_move): Fix flickering about when dragging
+	maximised windows between xineramas. Closes #358715.
+
+2006-12-03  Federico Mena Quintero  <federico@novell.com>
+
+	Fix http://bugzilla.gnome.org/show_bug.cgi?id=381127:
+
+	* src/window.c (idle_calc_showing): Grab the server while the
+	windows are being shuffled.  First show the windows to be shown, 
+	and then hide the windows to be hidden, in order to minimize
+	the number of expose events.
+
+2006-11-15  Bruno Boaventura  <brunoboaventura@gmail.com>
+2006-11-15  Björn Lindqvist   <bjourne@gmail.com>
+
+	* src/menu.c: added MetaMenuItemType enum; added it
+	to MenuItem; added values of this type to menuitems
+	array.
+	* src/menu.c (menu_item_new): rewrite to take a MenuItem
+	instead of a set of parameters describing the menu item.
+	* src/menu.c (meta_window_menu_new): use proper checkboxes
+	or radio buttons on the window menu. (#343108)
+	* src/window.c (meta_window_show_menu): unstick and stick
+	are always shown.
+
+2006-11-06  Thomas Thurman  <thomas@thurman.org.uk>
+
+	* configure.in: post-release bump to 2.17.3.
+
+2006-11-06  Thomas Thurman  <thomas@thurman.org.uk>
+
+	* configure.in: pre-release bump to 2.17.2.
+        * NEWS: 2.17.2 release.
+
+2006-11-05  Priit Laes  <amd@store20.com>
+
+	* src/main.c, src/ui.c: remove deprecated gtk stuff.
+
+2006-11-05  Bruno Boaventura  <brunoboaventura@gmail.com>
+
+	* src/theme.c, src/testgradient.c: remove deprecated gtk stuff.
+
+2006-11-05  Kjartan Maraas  <kmaraas@gnome.org>
+
+        * src/ui.c: use g_strdup to allocate a string, not strdup. Fixes
+        #363354.
+        * src/metacity-dialog.c: add missing spaces to string. Fixes
+        #363355.
+
+2006-11-05  Justin Mason  <jm@jmason.org>
+
+        * src/keybindings.c: implement handle_move_to_{side|corner}_* to
+	allow the user to flip a window to the side or corner of the
+	screen. Fixes #317884.
+	* src/prefs.h: keybindings for the above.
+	* src/metacity.schemas.in: keybindings for the above.
+
+2006-11-05  Elijah Newren  <newren gmail com>
+
+        * src/frames.c: improved rounding of rounded corners. Fixes #360542,
+	mostly.
+
+2006-10-30  Dan Mick  <dan.mick@sun.com>
+
+	* src/window.c: (__window_is_terminal): Fix strict focus
+        mode by picking up on res_class. Fixes #361054, strict focus 
+        mode still not working; should look for res_class, not res_name
+
+2006-10-16  Elijah Newren  <newren gmail com>
+
+        * NEWS: 2.17.1 release.
+
+2006-10-13  Carlo Wood <carlo@alinoe.com>
+
+	Fix cases when titlebar is allowed offscreen and shouldn't be (and
+	vice-versa).  #333995.
+
+	* src/display.[ch] (struct _MetaDisplay): add grab_frame_action
+	member
+
+	* src/display.[ch] (meta_display_begin_grab_op):
+	* src/window.[ch] (meta_window_begin_grab_op):
+	* src/core.[ch] (meta_core_begin_grab_op):
+	Add frame_action parameter (core & window versions pass it on to
+	display)
+	
+	* src/display.c (event_callback):
+	* src/window.c (meta_window_begin_grab_op,
+	  meta_window_client_message, menu_callback):
+	* frames.c (meta_frames_button_press_event):
+	* keybindings.c (do_choose_window, handle_begin_move,
+	  handle_begin_resize, handle_workspace_switch):
+	Pass whether the action should be considered a 'frame_action',
+	which will be used to determine whether to force the titlebar to
+	remain onscreen, to meta_*_begin_grab_op
+
+	* constraints.c (constrain_titlebar_visible):
+	Replace previous ugly hack by using grab_frame_action (and whether
+	the action is a user action) to determine whether to enforce the
+	titlebar_visible constraint.
+
+2006-10-10  Elijah Newren  <newren gmail com>
+
+	* src/draw-workspace.c (draw_window, wnck_draw_workspace): Patch
+	from Bruno Boaventura to sync metacity workspace previews with
+	libwnck.  #341893
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * configure.in: post-release bump to 2.17.1.
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * NEWS: 2.17.0 release.
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * src/themes/Crux/metacity-theme-2.xml: removed hide_buttons.
+	Closes #360498.
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * MAINTAINERS: added myself.
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * doc/theme-format.txt: described new theme format.
+
+	* src/themes/Bright, src/themes/Crux: added version 2 themes.
+
+2006-10-07  Thomas Thurman <thomas@thurman.org.uk>
+
+        * common.h: Added "above" to the list of flags a frame can have, so
+	that we know when to mark it as always on top.  Added six grab ops,
+	one to do and one to undo each of the three new titlebar buttons
+	(shade, above, stick).  Added six new button functions, similarly.
+	(#96229)
+
+        * frame.c (meta_frame_get_flags): If a frame has the WM_STATE_ABOVE X
+         attribute, set META_FRAME_ABOVE in its flags.
+
+        * frames.c (meta_frames_apply_shapes): Allow variable amounts of
+         rounding. (#113162)
+
+        * frames.c (show_tip_now, meta_frames_paint_to_drawable, control_rect,
+	 get_control): extend handling of existing buttons to the
+         3*2 new kinds of button. (#96229)
+
+        * frames.c (meta_frames_button_press_event): translate clicks on the 3*2
+         new kinds of button to the new grab ops. (#96229)
+
+        * frames.c (meta_frames_button_release_event): implement the various
+        actions for the 3*2 new kinds of button. (#96229)
+
+        * frames.c (meta_frames_update_prelit_control,
+         meta_frames_motion_notify_event): extend existing motion
+         notifications for buttons to the 3*2 new kinds of button. (#96229)
+
+        * frames.c (meta_frames_set_window_background): handle specified
+         background colours and alpha transparency. (#151261)
+
+        * frames.h (MetaFrameControl): New control types for the 3*2 new kinds
+	 of button.  (#96229)
+
+        * iconcache.[ch] (meta_read_icons): use theme's fallback icons if a
+	 window has no icon; use metacity's fallback icons only if the theme
+         does not provide any. (#11363) 
+
+        * iconcache.[ch] (meta_invalidate_default_icons (new function)): clear
+         icon cache on windows using default icons, and update them. (#11363) 
+
+        * main.c (main): added \n to error message.
+ 
+        * prefs.c (button_function_from_string): extend for 3 new button
+	 types. (#96229) 
+
+        * prefs.c (button_opposite_function (new function)): return a button
+         function's inverse (shade -> unshade, etc) (#96229) 
+
+        * prefs.c (update_button_layout): allocate space for a button's
+	 inverse, if it has one. (#96229) 
+
+        * theme-parser.c (ParseState): add state for fallback icons (#11363) 
+
+        * theme-parser.c (ParseInfo): add format_version; remove
+         menu_icon_* (#114305)
+
+        * theme-parser.c (parse_positive_integer): add lookup for integer
+	 constants (#331356)
+
+        * theme-parser.c (parse_rounding (new function)): parse window
+	 rounding amount (#113162)
+
+        * theme-parser.c (parse_alpha): don't set error if the number can't
+	 be parsed since it'll already be set; change tolerance in comparison
+	 from 1e6 to 1e-6
+
+        * theme-parser.c (parse_color (new function)): parse colour, including
+	 possible constant lookup.
+ 
+        * theme-parser.c (parse_toplevel_element): allow defining of various
+	new kinds of constant; allow
+	hide_buttons (#121639) and more detailed rounding attributes on
+	<frame_geometry> (#113162); allow background and alpha attributes on
+	<frame_style>; (#151261) remove support for <menu_icon> except as
+	stub; (#114305) add support for loading stock images (#113465); add
+        support for <fallback>. (#11363))
+
+        * theme-parser.c (parse_draw_op_element): add from and to attribute
+         for arcs. (#121603)
+
+        * theme-parser.c (parse_style_element): add check for theme version
+         supporting a button function. (#96229) 
+
+        * theme-parser.c (parse_style_set_element): add ability for shaded
+	 windows to be resizable (#114304)
+
+        * theme-parser.c (meta_theme_load): add theme versioning routine.
+
+        * theme.c ( meta_frame_layout_get_borders): return rectangles for
+	 the new 3*2 kinds of button, except where they're
+         inapplicable. (#96229)
+
+        * theme.c (meta_frame_layout_calc_geometry): don't format buttons on
+	windows with no buttons (#121639); strip the 3*2 new kinds of button
+	correctly (#96229); allow variable amounts of rounding (#113162).
+
+        * theme.c (meta_frame_style_new): set alpha to 255 by
+        default. (#151261)
+
+        * theme.c (meta_frame_style_unref): free colour spec if
+        allocated. (#151261)
+
+        * theme.c (meta_frame_style_validate): it's only an error not to
+        include a button if that button is valid in the current
+        theme. (#96229)
+
+        * theme.c (button_rect): return rectangles for the new 3*2 kinds
+	of button. (#96229)
+
+        * theme.c (meta_frame_style_set_unref): free differently resizable
+	shaded styles. (#114304)
+
+        * theme.c (get_style): look up differently resizable styles
+        for shaded windows. (#114304)
+ 
+        * theme.c (free_menu_ops (removed function), get_menu_icon
+	 (removed function), meta_theme_draw_menu_icon (removed function),
+         meta_menu_icon_type_from_string (removed function),
+         meta_menu_icon_type_to_string (removed function),
+         meta_theme_free, meta_theme_validate): removed menu icon code. (#114305)
+   
+        * theme.c (meta_theme_load_image): add size_of_theme_icons
+	parameter. (#113465)
+ 
+        * theme.c (meta_theme_define_color_constant (new function),
+        meta_theme_lookup_color_constant (new function)): allow
+        definition of colour constants. (#129747)
+
+        * theme.c (meta_button_type_from_string, meta_button_type_to_string):
+        add the 3*2 new kinds of button. (#96229)
+
+        * theme.c (meta_theme_earliest_version_with_button (new function)):
+        return the theme version each button was introduced in. (#96229)
+
+        * theme.h ( MetaFrameLayout): add "hide_buttons" flag (#121639) and
+	corner radiuses. (#113162)
+
+        * theme.h (MetaFrameGeometry): add rectangles for the 3*2 new
+	buttons. (#96229)
+
+        * theme.h (MetaButtonType): the 3*2 new buttons. (#96229)
+ 
+        * theme.h (MetaFrameStyle): add window_background_color and
+        window_background_alpha so that we can specify background on a
+        <frame_style>. (#151261)
+
+        * theme.h (MetaFrameStyleSet): shaded_styles gets resize
+	dimension. (#114304)
+
+        * theme.h (MetaTheme): added format_version, color_constants
+        hash, (#129747) fallback_icon and fallback_mini_icon, (#11363)
+        and removed menu_icons. (#114305)
+ 
+        * theme.h (META_THEME_ALLOWS (new macro)): return whether a theme
+        supports a given feature. Also, several macros representing
+        new features in v2.
+
+        * ui.c (meta_ui_set_current_theme)): also invalidate default
+        icons. (#11363) 
+
+        * window.[ch] (meta_window_update_icon_now)): became
+	non-static. (#11363) 
+
+2006-10-06  Elijah Newren  <newren gmail com>
+
+	* src/metacity-dialog.c (kill_window_question): Be nice to
+	translators; remove unnecessary markup from strings marked for
+	translation (oops, I missed this in my review before previous
+	commit)
+
+2006-10-06  Elijah Newren  <newren gmail com>
+
+	* src/metacity-dialog.c (kill_window_question): Patch from Bruno
+	Boaventura to improve the "Force Quit" dialog.  #121936
+
+2006-10-02  Elijah Newren  <newren gmail com>
+
+	Ignore edge resistance for size-increment windows when resizing
+	with the keyboard.  #346782.
+
+	* src/edge-resistance.c (apply_edge_resistance_to_each_side):
+	ignore edge resistance for size-increment windows when resizing
+	with the keyboard, (apply_edge_resistance_to_each_side,
+	meta_window_edge_resistance_for_move,
+	meta_window_edge_resistance_for_resize): pass a is_resize
+	parameter as well
+
+2006-10-01  Elijah Newren  <newren gmail com>
+
+	* src/display.c (meta_display_set_input_focus_window):
+	* src/window.c (meta_window_focus):
+	Don't require a push/pop trap around
+	meta_display_set_input_focus_window(), but rather move the
+	push/pop into that function surrounding the XSetInputFocus() call
+	directly.  Follow up to #358514.
+
+2006-10-01  Elijah Newren  <newren gmail com>
+
+	* src/*.[ch]: Stick an emacs comment directive at the beginning of
+	all the code files so that people using emacs will be more likely
+	to get coding style correct in their patches.  We still need a
+	similar vi directive.  #358866
+
+2006-10-01  Elijah Newren  <newren gmail com>
+
+	Patch from Carlo Wood to ensure that maximized and minimized
+	properties are maintained across restarts.  #358042.
+
+	* src/constraints.c (place_window_if_needed): fix up partial
+	maximization handling and add minimize_after_placement handling.
+
+	* src/display.[ch] (struct MetaDisplay, meta_display_open): add a
+	new display->display_opening flag to allow handling startup
+	differently where needed.
+
+	* src/window-props.c (reload_net_wm_state): handle
+	_net_wm_state_hidden as well, setting
+	window->minimize_after_placement appropriately
+
+	* src/window.[ch] (struct MetaWindow, meta_window_new_with_attrs):
+	add a window->minimize_after_placement field
+
+	* src/window.c (meta_window_new_with_attrs): only unminimize the
+	window and its transients if the display isn't being opened,
+	(unmaximize_window_before_freeing): don't reset the state unless
+	the window is becoming withdrawn, if the screen is being closed be
+	sure to save the unmaximized state of the window so the next
+	window manager can restore it
+
+2006-10-01  Elijah Newren  <newren gmail com>
+
+	* src/window-props.c (set_title_text): surround the
+	XDeleteProperty() call with a
+	meta_error_trap_push/meta_error_trap_pop pair to prevent a crash
+	when closing a remote instance of gedit (and perhaps other apps).
+	#358514.
+
+2006-10-01  Elijah Newren  <newren gmail com>
+
+	Fix longstanding focus bug with mouse (not sloppy) focus mode with
+	popup override-redirect windows, particularly mozilla and
+	firefox's location bar autocompletion.  #357695.
+
+	* src/display.c (event_callback -- EnterNotify & LeaveNotify events):
+	for mouse focus, defocus the focused window when the mouse enters
+	the desktop window rather than when the mouse leaves the focused
+	window.
+
+	* doc/how-to-get-focus-right.txt:
+	update for the slightly nuanced definition of mouse focus (people
+	without a DESKTOP window like nautilus get sloppy focus behavior
+	now)
+
+2006-09-27  Elijah Newren  <newren gmail com>
+
+	* src/menu.c (var menuitems): Patch from Bruno Boaventura to add
+	notes to remind translators to keep translations in sync with
+	libwnck.  #355620.
+
+2006-09-18  Elijah Newren  <newren gmail com>
+
+	* src/window.c (meta_window_show): Patch from Jens Granseuer to
+	fix c89 cleanness, again.  #356631.
+
+2006-09-18  Elijah Newren  <newren gmail com>
+
+	* src/constraints.c (constrain_maximization): Ignore maximum size
+	hints when maximizing.  Should fix #327543 (see comment 4 and comment
+	5).
+
+2006-09-18  Elijah Newren  <newren gmail com>
+
+	* src/ui.c (filter_func): avoid a compilation warning by making
+	sure to return something.  #348067
+
+2006-09-18  Thomas Thurman  <thomas@thurman.org.uk>
+
+	Branched for Gnome 2.17.
+	
+	* configure.in: bump version to 2.17.0.
+
+2006-09-18  Thomas Thurman <thomas@thurman.org.uk>
+
+	* configure.in: post-release bump to 2.16.3
+
 2006-09-18  Thomas Thurman <thomas@thurman.org.uk>

        * NEWS: 2.16.2 release
--- a/35
+++ b/35
@@ -1,11 +1,32 @@
 Currently active maintainers
----------------------------
+--------------------------------
+Elijah Newren (newren  gmail com)
+  - Usually won't touch the theme bugs (isn't interested) or the
+    compositor (until open source nvidia drivers are up to snuff).
+    Tends to be most interested in libwnck/gtk interactions, focus
+    issues, constraints problems, and raising/stacking, but works on
+    just about anything other than themes and the compositor.

-Havoc Pennington
-E-mail: hp@redhat.com
+Thomas Thurman (thomas  thurman org uk)
+  - Responsible for all theme bugs and the compositor (thank goodness
+    Thomas got involved, eh?).  I'm sure he'll replace this sentence
+    with his interests when he reads it.  ;-)

-Elijah Newren
-E-mail: newren@gmail.com

-Søren Sandmann
-E-mail: sandmann@redhat.com
+Semi-active maintainers
+--------------------------------
+Havoc Pennington (hp  redhat com)
+  - Original author.  Doesn't patch metacity anymore, but is active in
+    answering questions, responding to bugs, providing very helpful
+    suggestions and insight, and even assisting with debugging.
+
+
+Important historical figureheads
+--------------------------------
+Rob Adams (readams  readams net)
+  - Was the main maintainer of metacity for a while; particular areas
+    of focus included xinerama, placement, and an older version of the
+    constraints code.  Still responds to bugs every once in a while.
+
+Søren Sandmann (sandmann  redhat com)
+  - Wrote most of the current compositing manager code + libcm
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,7 +1,7 @@

 SUBDIRS=src po doc

-EXTRA_DIST=HACKING rationales.txt \
+EXTRA_DIST = HACKING MAINTAINERS rationales.txt \
 	intltool-extract.in intltool-merge.in intltool-update.in

 DISTCLEANFILES = intltool-extract intltool-merge intltool-update po/stamp-it po/.intltool-merge-cache
--- a/160
+++ b/160
@@ -1,20 +1,156 @@
+2.19.1
+======
+
+Thanks to Jaap Haitsma, Linus Torvalds, Charlie Brej, Kjartan Maraas,
+Arthur Taylor, Elijah Newren, Josselin Mouette, Havoc Pennington,
+Benjamin Berg, and Carlo Wood for improvements in this release.
+
+  - new icon for the force-quit dialog (Jaap) [#396655]
+  - add configureable mouse click action abilities, and clean up lots of
+    related code (Linus) [#408899, #408902, others]
+  - add schemeas for middle and right click titlebar actions (Charlie)
+    [#408903]
+  - remove pango/pangox.h include since it's not needed and not
+    installed anymore (Kjartan)
+  - adjust rounded corners so that they fit nicely with the arcs
+    around them (Arthur) [#399373]
+  - fix session hang when metacity .sm file is missing (Josselin)
+    [#407981]
+  - add support for _NET_WM_USER_TIME_WINDOW in order to cut down on
+    context switches (Elijah, Havoc) [#354213]
+  - prevent nasty metacity/gdk interactions causing hangs with gtk
+    trunk (Elijah) [offshoots of #354213]
+  - fix button middle fallback and the prelight state (Benjamin) [#419043]
+  - Lots of code cleanup for the strut lists (Elijah)
+  - fix handling of unidirectional maximization and partial struts +
+    some miscellaneous cleanups (Carlo) [#358311]
+  - avoid some crashes when dragging windows partially offscreen
+    (Elijah) [#353513]
+  - avoid mousenav vs. keynav focus problems with the run application
+    dialog in mouse/sloppy focus modes (Elijah) [#374752]
+  - _NET_ACTIVE_WINDOW property on the root window should be a single
+    xwindow id, not two (Elijah)
+  - Fix unidirection unmaximization causing jumps (Elijah) [#355497]
+  - fix unfullscreening and unmaximizing with size increment/size
+    constraint windows (such as gnome-terminal) possibly not returning
+    to their "original position" (Elijah) [#329152]
+  - fix some issues with min/max and size increment constraints
+    (Elijah) [#418395]
+  - send synthetic configure notify events in response to appropriate
+    MapRequest events too (Elijah) [#322840]
+
+Translations
+  Ihar Hrachyshka (be@latin), Jordi Mallach (ca), Jakub Friedl (cs),
+  norbu (dz), David Lodge (en_GB), Ivar Smolin (et), Gabor Kelemen (hu),
+  Luca Ferretti (it), Takeshi AIHANA (ja), Erdal Ronahi (ku), Gintautas
+  Miliauskas (lt), Jovan Naumovski (mk), Kjartan Maraas (nb), Reinout van
+  Schouwen (nl), wadim dziedzic (pl), raulpereira (pt_BR), Nickolay V.
+  Shmyrev (ru), Горан Ракић (sr), Woodman Tuen (zh_HK), Woodman Tuen (zh_TW)
+
+2.17.5
+======
+
+Thanks to Bruno Boaventura, Mad Alex, and Thomas Thurman for
+improvements in this release.
+
+   - make window menu arrangement more sensible. (Bruno) [#382962]
+   - unmaximise button keeps pressed appearance when moved off and
+     back. (Alex) [#395560]
+   - fix a couple of compositor crashes (Thomas) [#387761]
+   - new environment variables checked if the compositor is enabled;
+     see the new file doc/compositor-control.txt for details. (Thomas)
+
+Translations
+  Djihed Afifi (ar), Ales Nyakhaychyk (be), Jordi Mallach (ca),
+  Jakub Friedl (cs), David Lodge (en_GB), Raivis Dejus (lv),
+  Kjartan Maraas (nb), Mugurel Tudor (ro), Daniel Nylander (sv),
+  Theppitak Karoonboonyanan (th)
+
+2.17.3
+======
+
+Thanks to Christof Krüger, Federico Mena Quintero, Bruno Boaventura,
+and Björn Lindqvist for improvements in this release.
+
+  - fix longstanding problem about windows flickering in and out of
+    maximised state when dragging between xineramas (Christof) [#358715]
+  - grab server when switching workspaces (Federico) [#381127] 
+  - replace changing text on window menu with pairs of radio buttons
+    and checkboxes (Bruno, Björn) [#343108]
+
+Translations
+  Kjartan Maraas (nb), Jakub Friedl (cs), Yuval Tanny (he), Ivar Smolin (et),
+  Duarte Loreto (pt), Francisco Javier F. Serrador (es)
+
+2.17.2
+======
+
+Thanks to Priit Laes, Bruno Boaventura, Kjartan Maraas, Justin Mason,
+Elijah Newren and Dan Mick for improvements in this release.
+
+  - implement handle_move_to_{side|corner}_* to allow the user to flip a
+    window to the side or corner of the screen. (Justin) [#317884]
+  - fix strict focus mode by picking up on res_class (Dan) [#361054]
+  - remove deprecated gtk stuff (Priit, Bruno)
+  - string fixes (Kjartan) [#363354, #363355]
+
+Translations
+  Jakub Friedl (cs), Francisco Javier F. Serrador (es), Ilkka Tuohela (fi),
+  Christophe Merlet (RedFox) (fr), Kjartan Maraas (nb)
+
+2.17.1
+======
+
+Thanks to Bruno Boaventura and Carlo Wood for improvements in this
+release.
+
+  - sync metacity workspace previous with libwnck (Bruno) [#341893]
+  - fix cases when titlebar is allowed offscreen and shouldn't be, and
+    vice-versa (Carlo) [#333995]
+
+Translations
+  Ilkka Tuohela (fi)
+
+2.17.0
+======
+
+Thanks to Elijah Newren, Jens Granseuer, Bruno Boaventura, Carlo Wood,
+and Thomas Thurman for changes in this release.
+
+  - version 2 of theme format: stick, shade and above buttons on titlebar,
+    variable rounding on corners, variable transparency on window
+    backgrounds, stock icons in themes, can remove all titlebar buttons
+    from certain classes of window, and more (Thomas) [#102547 and
+    dependencies]
+  - improve "Force Quit" dialog (Bruno) [#121936]
+  - ignore edge resistance when resizing with keyboard (Elijah) [#346782]
+  - maintain window size and placement across restarts (Carlo) [#358042]
+  - prevent crash when closing certain remote apps (Elijah) [#358514]
+  - longstanding mouse-focus bug fixed which affected firefox's
+    autocompletion (Elijah) [#357695]
+  - ignore maximum size constraints when maximising (Elijah) [#327543]
+  - warn translators to keep translations in sync with libwnck (Bruno)
+    [#355620]
+  - fixes for compilation warnings, etc (Elijah, Jens) [#348067, #356631]
+
+Translators
+  Ivar Smolin (et), Gabor Kelemen (hu), Luca Ferretti (it),
+  Runa Bhattacharjee (bn_IN)
+
 2.16.2
 ======

 Thanks to Eljah Newren, Maik Beckmann, Christian Hamar, Thomas Andersen,
-and Bruno Boaventura de Olevira for changes in this release.
-
-  - partial audit to fix timestamp usage (partly fixes #355180) (Elijah)
-
-  - remove compilation warnings (#355876) (Maik); (#355490) (Bruno);
-    (#355489) (Bruno).
+and Bruno Boaventura de Oliveira for changes in this release.

+  - partial audit to fix timestamp usage (Elijah) [part of #355180]
+  - remove compilation warnings (Maik) [#355876]; (Bruno) [#355490,
+    #355489]
  - automatic detection of stable/unstable in configure script
-    (#356122) (Christian/Elijah)
-
-  - make windows be stacked correctly before showing them (#332385) (Thomas)
-
-  - use guint32 for timestamps (#348305) (Elijah)
+    (Christian/Elijah) [#356122]
+  - make windows be stacked correctly before showing them (Thomas)
+    [#332385]
+  - use guint32 for timestamps (Elijah) [#348305]

 Translators
  Wouter Bolsterlee (nl), Matic Žgur (sl), Francisco Javier F. Serrador (es),
@@ -25,7 +161,7 @@ Translators
 2.16.1
 ======

-Thanks to Elijah Newren, Colin Watson, and Bruno Boaventura de Olevira
+Thanks to Elijah Newren, Colin Watson, and Bruno Boaventura de Oliveira
 Lacerda for changes in this release.

  - fix stuck grab, letting focus be transferred between windows (Elijah)
--- a/configure.in
+++ b/configure.in
@@ -1,10 +1,10 @@
 AC_PREREQ(2.50)

 m4_define([metacity_major_version], [2])
-m4_define([metacity_minor_version], [16])
+m4_define([metacity_minor_version], [19])
 # Fibonacci sequence for micro version numbering:
 # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987
-m4_define([metacity_micro_version], [2])
+m4_define([metacity_micro_version], [1])

 m4_define([metacity_version],
          [metacity_major_version.metacity_minor_version.metacity_micro_version])
@@ -219,7 +219,7 @@ if test x$enable_compositor = xyes; then
   have_xcomposite=yes
   echo "CompositeExt support forced on"
 elif test x$enable_compositor = xauto; then
-   echo "Not building compositing manager by default now, must enable explicitly to get it. And it doesn't work, so don't bother unless you want to hack on it..."
+   echo "Not building compositing manager by default now, must enable explicitly to get it."
   have_xcomposite=no
 else
   have_xcomposite=no
--- a/doc/compositor-control.txt
+++ b/doc/compositor-control.txt
@@ -0,0 +1,46 @@
+The compositor is the box of tricks inside the window manager which performs
+special effects on the windows on your screen. Metacity's compositor is
+under development. Your help is requested in finding and fixing bugs. This
+document tells you how to configure Metacity so that you can use compositing.
+
+To turn the compositor on initially, you need to pass --enable-compositor to
+the configure script. This will introduce a dependence on libcm, which you
+can get from <URL:http://ftp.gnome.org/pub/GNOME/sources/libcm/>.
+
+When Metacity is compiled, you will need to turn the compositor on in gconf
+for it to have any effect. You will find the boolean switch at
+
+   /apps/metacity/general/compositing_manager
+
+When that's done, you can set some environment variables before you launch
+Metacity to influence how the compositor works. These will eventually become
+configuration options or gconf options when they grow up. Define them to any
+value to turn them on; leave them undefined to turn them off. Currently the
+options you can set are:
+
+   LIBCM_DIRECT
+
+      If this is set, the compositor will bypass the X server and do all its
+      work directly with the hardware. I know of no reason you would want to
+      do so, but perhaps you do.
+
+   LIBCM_TFP
+
+      If this is set ("tfp mode"), the compositor will feel free to use the
+      texture_from_pixmap extension; if this is not set ("non-tfp mode"), the
+      compositor will use a workaround. Many drivers require non-tfp mode in
+      order to work, and will paint all windows clear blue or clear white
+      without it. Thanks to Travis Watkins for suggesting this switch; he
+      cautions that some games or video players may require tfp mode.
+
+   METACITY_BLING
+
+      This turns on several pretty but non-essential animations (dialogues
+      fracturing and exploding, minimisations doing a shrinkydink effect,
+      and so on). If it is not set, the standard non-GL animations are
+      retained. This affects only window event animations; it doesn't change
+      menus zooming, dialogues being semi-transparent, and so on. Try it
+      and see whether you like it.
+
+If you have any problems, ask on metacity-devel-list@gnome.org, or
+#gnome-hackers on gimpnet, or come and find me (tthurman at gnome) and ask.
--- a/doc/how-to-get-focus-right.txt
+++ b/doc/how-to-get-focus-right.txt
@@ -9,7 +9,8 @@ basics are easy:
 Focus method  Behavior
    click     When a user clicks on a window, focus it
   sloppy     When an EnterNotify is received, focus the window
-    mouse     Same as sloppy, but also defocus on LeaveNotify
+    mouse     Same as sloppy, but also defocus when mouse enters DESKTOP
+              window

 Note that these choices (along with the choice that clicking on a
 window raises it for the click focus method) introduces the following
@@ -20,8 +21,8 @@ Focus method  Invariant
   sloppy     If the mouse is in a window, then it is focused; if the
              mouse is not in a window, then the most recently used
              window is focused.
-    mouse     If the mouse is in a window, then it is focused; otherwise,
-              the designated "no_focus_window" is focused
+    mouse     If the mouse is in a non-DESKTOP window, then it is focused;
+              otherwise, the designated "no_focus_window" is focused

 However, there are a number of cases where the current focus window
 becomes invalid and another should be chosen.  Some examples are when
@@ -34,8 +35,9 @@ Focus method  Behavior
              on top)
   sloppy     Focus the window containing the pointer if there is such
              a window, otherwise focus the most recently used window.
-    mouse     Focus the window containing the pointer if there is one,
-              otherwise focus the designated "no_focus_window".
+    mouse     Focus the non-DESKTOP window containing the pointer if
+              there is one, otherwise focus the designated
+              "no_focus_window".

 Note that "most recently used window", as used here, has a slightly
 different connotation than "most recent to have keyboard focus".  This
@@ -62,9 +64,9 @@ cases in which a new window shouldn't be focused:

 To handle these cases, Metacity compares timestamps of the event that
 caused the launch and the timestamp of the last interaction with the
-focused window.  (Case 2 is handled by providing a special timestamp
-of 0 for the launch time, which ensures that the window that appears
-doesn't get focus)
+focused window.  (Case 2 is handled by the application providing a
+special timestamp of 0 for the launch time, which ensures that the
+window that appears doesn't get focus)

 If the newly launched window isn't focused, some things should be done
 to alert the user that there is a window to work with:
@@ -84,10 +86,10 @@ attempt to handle the INHERENTLY CONFLICTING CONSTRAINTS.  Metacity does
 this by having a mouse_mode boolean used to determine which of the two
 sets of invariants holds.  This mode is set according to which method was
 most recently used to choose a focus window:
-  1) When receiving EnterNotify/LeaveNotify events from mouse movement, set
+  1) When receiving EnterNotify events from mouse movement, set
     mouse_mode to TRUE.
  2) When using keynav to choose a focus window (e.g. alt-tab, alt-esc,
-     move-window-to-workspace keybindings), set mouse_mode to FALSE.
+     alt-f2, move-window-to-workspace keybindings), set mouse_mode to FALSE.
  3) When handling events that don't choose a focus window but rather need
     a focus_window chosen for them (e.g. switch-to-workspace keybindings),
     don't change the mouse_mode and just use the current value.
@@ -123,6 +125,7 @@ To read more about the bugs that inspired these choices:
  - Mousenav vs. Keynav in mouse and sloppy focus modes
    http://bugzilla.gnome.org/show_bug.cgi?id=167545
    http://bugzilla.gnome.org/show_bug.cgi?id=101190
+    http://bugzilla.gnome.org/show_bug.cgi?id=357695
  - Not focusing panels
    http://bugzilla.gnome.org/show_bug.cgi?id=160470
    http://bugzilla.gnome.org/show_bug.cgi?id=120100
--- a/doc/theme-format.txt
+++ b/doc/theme-format.txt
@@ -1,6 +1,91 @@
-Docs on the theme format
+Themes are in a simple XML-subset format. There are multiple versions
+of the theme format, and a given theme can support more than one format.

-Themes are in a simple XML-subset format.
+Version 1:     THEMEDIR/metacity-1/metacity-theme-1.xml
+  (original metacity format)
+Version 2:     THEMEDIR/metacity-1/metacity-theme-2.xml
+
+The subdirectory name is "metacity-1" in all versions.
+
+As you might expect, older versions of metacity will not understand
+newer theme formats. However, newer versions will use old themes.
+Metacity will always use the newest theme format it understands that
+the X server supports. Some format versions are only supported if you
+have the right X server features.
+
+Each format *requires* the corresponding filename. If you put version
+2 format features in the metacity-1/metacity-theme-1.xml file, then
+metacity will get angry.
+
+This document has separate sections for each format version. You may
+want to read the document in reverse order, since the base features
+are discussed under version 1.
+
+New Features in Theme Format Version 2
+======================================
+
+The optional attributes rounded_top_left, rounded_top_right,
+rounded_bottom_left and rounded_bottom_right on <frame_geometry>
+should now be the radius of the corner in pixels. You may still use
+the values "false" for 0 and "true" for 5, which means v1 values will
+still work just fine.
+
+<frame_geometry> has a new optional attribute, hide_buttons. If this
+is true, no buttons will be displayed on the titlebar.
+
+Anywhere you can use a positive integer, you can use an integer constant.
+
+As well as constant integers and reals, you may define constant colours,
+thus:
+  <constant name="RevoltingPink" value="#FF00FF"/>
+  <constant name="Background" value="gtk:bg[NORMAL]"/>
+
+<frame_style> has two new optional attributes, background and alpha.
+If you specify alpha, you must specify background. background is a
+colour used for the background of the frame. alpha is the transparency
+as a real between 0.0 and 1.0. If the current X server does not support
+alpha channels, the value is ignored.
+
+The filename attribute of <image> may begin with "theme:". If so, the
+rest of the string is the name of a theme icon. The 64x64 version of the
+icon is used, except for fallback mini_icons, which use the 16x16 version.
+This does not affect ordinary resizing. For example:
+  <button function="close" state="normal">
+    <draw_ops>
+      <include name="active_button"/>
+      <image filename="theme:gnome-logout" x="2" y="2"
+          width="width-4" height="height-4"/>
+      <!-- Note: not "theme:gnome-logout.png" or similar. -->
+    </draw_ops>
+  </button>
+
+<menu_icon>s are parsed but ignored.
+
+Fallback icons can be specified using <fallback>. There are two
+optional arguments, icon and mini_icon. The values of these arguments
+are identical to that of the filename attribute of <image>. Fallback
+icons are used when a window does not supply its own icon. If a fallback
+icon is not specified with <fallback>, Metacity will use a built-in
+icon, as in metacity-theme-1.
+
+The <arc> element, as well as the original start_angle and end_angle
+attributes, may be given from and to attributes. The values of these
+attributes are given in degrees clockwise, with 0 being straight up.
+For example:
+  <arc from="0.0" to="90.0" filled="true" color="#FF00FF"
+      x="0" y="5" width="15" height="15"/>
+
+<frame state="shaded"> may now take an optional resize attribute, with
+the same interpretation as the resize attribute on <frame state="normal">.
+If this attribute is omitted for state="shaded", it defaults to "both".
+(If it is omitted for state="normal", it remains an error.)
+
+In addition to the four <button> functions which are required in
+metacity-theme-1, there are six new functions in metacity-theme-2:
+shade, unshade, above, unabove, stick and unstick.
+      
+Overview of Theme Format Version 1
+==================================

 <?xml version="1.0"?>
 <metacity_theme>
--- a/po/ChangeLog
+++ b/po/ChangeLog
@@ -1,3 +1,304 @@
+2007-04-02  Alessio Frusciante  <algol@firenze.linux.it>
+
+	* it.po: Fixed a typo in translation. Closes #420494.
+
+2007-03-30  Ihar Hrachyshka <iharh@gnome.org>
+
+	* be@latin.po: Added Belarusian Latin translation by Ales Navicki.
+
+2007-03-29  Priit Laes  <plaes@svn.gnome.org>
+
+	* et.po: Updated Estonian translation by Ivar Smolin <okul@linux.ee>.
+
+2007-03-27  Gabor Kelemen  <kelemeng@gnome.hu>
+
+	* hu.po: Translation updated.
+
+2007-03-17  Kjartan Maraas  <kmaraas@gnome.org>
+
+	reviewed by: <delete if not using a buddy>
+
+	* nb.po:
+
+2007-03-14  David Lodge <dave@cirt.net>
+
+	* en_GB.po: Updated English (British) translation
+
+2007-03-12  Jakub Friedl  <jfriedl@suse.cz>
+
+	* cs.po: Updated Czech translation.
+
+2007-03-11  Goran Rakić  <grakic@devbase.net>
+
+	* sr.po, sr@Latn.po: Updated Serbian translation.
+
+2007-03-11  Josep Puigdemont i Casamajó  <josep.puigdemont@gmail.com>
+
+	* ca.po: Updated Catalan translation by
+	Jordi Mallach <jodri@sindominio.net>.
+
+2007-03-10  Artur Flinta  <aflinta@svn.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2007-03-09  Nickolay V. Shmyrev  <nshmyrev@yandex.ru>
+
+	* ru.po: Updated Russian translation.
+
+2007-03-07  Artur Flinta  <aflinta@svn.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2007-03-06  Takeshi AIHANA <takeshi.aihana@gmail.com>
+
+	* ja.po: Updated Japanese translation.
+
+2007-03-06  Jovan Naumovski  <jovan@lugola.net>
+
+	* mk.po: Updated Macedonian translation.
+
+2007-03-05  Vincent van Adrighem  <adrighem@gnome.org>
+
+	* nl.po: Translation updated by Reinout van Schouwen.
+
+2007-03-04  Gintautas Miliauskas  <gintas@akl.lt>
+
+	* lt.po: Updated Lithuanian translation.
+
+2007-03-04  Erdal Ronahi  <erdal dot ronahi at gmail dot com>
+
+	* ku.po: Updated Kurdish translations
+
+2007-03-04  Pema Geyleg  <pema.geyleg@gmail.com>
+
+	* dz.po: Updated Dzongkha Translation.
+
+2007-03-04  Chao-Hsiung Liao  <j_h_liau@yahoo.com.tw>
+
+	* zh_HK.po: Updated Traditional Chinese translation(Hong Kong).
+	* zh_TW.po: Updated Traditional Chinese translation(Taiwan).
+
+2007-03-02  Leonardo Ferreira Fontenelle  <leonardof@svn.gnome.org>
+
+	* pt_BR.po: Updated Brazilian Portuguese translation by Leonardo
+	Ferreira Fontenelle <leo.fontenelle@gmail.com> (me!) and Raul Pereira
+	<contato@raulpereira.com>.
+
+2007-02-27  Gintautas Miliauskas  <gintas@akl.lt>
+
+	* lt.po: Updated Lithuanian translation.
+
+2007-02-26  Luca Ferretti  <elle.uca@libero.it>
+
+	* it.po: Updated Italian translation.
+
+2007-02-25  Gabor Kelemen  <kelemeng@gnome.hu>
+
+	* hu.po: Translation updated.
+
+2007-02-24  Raphael Higino  <raphaelh@svn.gnome.org>
+
+	* pt_BR.po: Updated Brazilian Portuguese translation.
+
+2007-02-24  Nguyễn Thái Ngọc Duy  <pclouds@gmail.com>
+
+	* vi.po: Updated Vietnamese translation.
+
+2007-02-22  Abel Cheung  <abelcheung@gmail.com>
+
+	* zh_CN.po: Updated simplified Chinese translation on behalf of
+	Funda Wang.
+
+2007-02-21 Maxim Dziumanenko <dziumanenko@gmail.com>
+
+	* uk.po: Update Ukrainian translation.
+
+2007-02-21  Artur Flinta  <aflinta@cvs.gnome.org>
+
+	* pl.po: Updated Polish translation by GNOME PL Team.
+
+2007-02-20  Alexander Shopov  <ash@contact.bg>
+
+	* bg.po: Updated Bulgarian translation by
+	Alexander Shopov <ash@contact.bg>
+
+2007-02-16  Ilkka Tuohela  <hile@iki.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2007-02-15  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2007-02-15  Duarte Loreto <happyguy_pt@hotmail.com>
+
+	* pt.po: Updated Portuguese translation.
+
+2007-02-14  Ilkka Tuohela  <hile@iki.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2007-02-09  Changwoo Ryu  <cwryu@debian.org>
+
+	* ko.po: Updated Korean translation.
+
+2007-01-31  Stéphane Raimbault  <stephane.raimbault@gmail.com>
+
+	* fr.po: Updated French translation by Robert-André Mauchin.
+
+2007-01-27  Priit Laes  <plaes@svn.gnome.org>
+
+	* et.po: Updated Estonian translation by Ivar Smolin <okul@linux.ee>.
+
+2007-01-22  Jakub Friedl <jfriedl@suse.cz> 
+
+	* cs.po: Updated Czech translation.
+
+2007-01-16  Hendrik Richter  <hendrikr@gnome.org>
+
+	* de.po: Updated German translation.
+
+2007-01-15  Djihed Afifi <djihed@gmail.com> 
+
+	* ar.po: Updated Arabic Translation by Khaled Hosny.
+
+2007-01-13  Daniel Nylander <po@danielnylander.se>
+
+	* sv.po: Updated Swedish translation.
+
+2007-01-05  Jakub Friedl <jfriedl@suse.cz> 
+
+	* cs.po: Updated Czech translation.
+
+2007-01-3  Djihed Afifi <djihed@gmail.com> 
+
+	* ar.po: Updated Arabic Translation by Djihed Afifi.
+
+2007-01-01  David Lodge <dave@cirt.net>
+
+	* en_GB.po: Updated English (British) translation
+
+2006-12-29  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* nb.po: Updated Norwegian bokmål translation.
+
+2006-12-29  Theppitak Karoonboonyanan  <thep@linux.thai.net>
+
+	* th.po: Updated Thai translation.
+
+2006-12-27  Djihed Afifi <djihed@gmail.com> 
+
+	* ar.po: Updated Arabic Translation.
+
+2006-12-24  Djihed Afifi <djihed@gmail.com> 
+
+	* ar.po: Updated Arabic Translation.
+
+2006-12-23  Raivis Dejus <orvils@gmail.com>
+
+	* lv.po: Updated Latvian Translation.
+
+2006-12-18  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* nb.po: Updated Norwegian bokmål translation.
+
+2006-12-18  Djihed Afifi <djihed@gmail.com> 
+
+	* ar.po: Updated Arabic Translation.
+
+2006-12-18  Ales Nyakhaychyk  <nab@mail.by>
+
+	* be.po: Updated Belarusian Translation by Ihar Hrachyshka.
+
+2006-12-15  Theppitak Karoonboonyanan  <thep@linux.thai.net>
+
+	* th.po: Updated Thai translation.
+
+2006-12-13  Mugurel Tudor  <mugurelu@gnome.ro>
+
+	* ro.po: Updated Romanian translation.
+
+2006-12-11  Jordi Mallach  <jordi@sindominio.net>
+
+	* ca.po: Updated Catalan translation.
+
+2006-12-11  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* nb.po: Updated Norwegian bokmål translation.
+
+2006-12-04  Jakub Friedl  <jfriedl@suse.cz>
+
+	* cs.po: Updated Czech translation.
+
+2006-11-22  Yair Hershkovitz  <yairhr@gmail.com>
+
+	* he.po: Updated Hebrew translation.
+
+2006-11-19  Priit Laes  <plaes@cvs.gnome.org>
+
+	* et.po: Translation updated by Ivar Smolin.
+
+2006-11-19  Duarte Loreto <happyguy_pt@hotmail.com>
+
+	* pt.po: Partial updated Portuguese translation.
+
+2006-11-19  Priit Laes  <plaes@cvs.gnome.org>
+
+	* et.po: Translation updated by Ivar Smolin.
+
+2006-11-18  Priit Laes  <plaes@cvs.gnome.org>
+
+	* et.po: Translation updated by Ivar Smolin.
+
+2006-11-07  Francisco Javier F. Serrador  <serrador@openshine.com>
+
+	* es.po: Updated Spanish translation.
+
+2006-11-03  Jakub Friedl  <jfriedl@suse.cz>
+
+	* cs.po: Updated Czech translation.
+
+2006-10-26  Francisco Javier F. Serrador  <serrador@openshine.com>
+
+	* es.po: Updated Spanish translation.
+
+2006-10-26  Ilkka Tuohela  <hile@iki.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2006-10-26  Ilkka Tuohela  <hile@iki.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2006-10-22  Christophe Merlet  <redfox@redfoxcenter.org>
+
+	* fr.po: Updated French translation.
+
+2006-10-19  Kjartan Maraas  <kmaraas@gnome.org>
+
+	* nb.po: Updated Norwegian bokmål translation.
+
+2006-10-15  Ilkka Tuohela  <hile@iki.fi>
+
+	* fi.po: Updated Finnish translation.
+
+2006-10-02  Josep Puigdemont i Casamajó  <josep.puigdemont@gmail.com>
+
+	* ca.po: Updated Catalan translation.
+
+2006-09-29  Alexander Shopov  <ash@contact.bg>
+
+	* bg.po: Updated Bulgarian translation with
+	bugfixes prompted by Yavor Doganov
+
+2006-09-21  Gabor Kelemen  <kelemeng@gnome.hu>
+
+	* hu.po: Translation updated.
+
+2006-09-19  Runa Bhattacharjee <runabh@gmail.com>
+
+	* bn_IN.po: Updated Bengali India Translation.
+
 2006-09-15  Wouter Bolsterlee  <wbolster@gnome.org>

 	* nl.po: Translation updated by Wouter Bolsterlee.
@@ -93,7 +394,7 @@

 	* mr.po: Added the file and updated Marathi translation.
 	* LINGUAS: Added an entry for Marathi(mr).
-	
+
 2006-09-03  Christophe Merlet  <redfox@redfoxcenter.org>

 	* fr.po: Updated French translation from
--- a/po/LINGUAS
+++ b/po/LINGUAS
@@ -4,6 +4,7 @@ am
 ar
 az
 be
+be@latin
 bg
 bn
 bn_IN
--- a/po/ar.po
+++ b/po/ar.po
--- a/po/be.po
+++ b/po/be.po
--- a/po/be@latin.po
+++ b/po/be@latin.po
--- a/po/bg.po
+++ b/po/bg.po
--- a/po/bn_IN.po
+++ b/po/bn_IN.po
--- a/po/ca.po
+++ b/po/ca.po
--- a/po/cs.po
+++ b/po/cs.po
--- a/po/de.po
+++ b/po/de.po
--- a/po/dz.po
+++ b/po/dz.po
--- a/po/en_GB.po
+++ b/po/en_GB.po
--- a/po/es.po
+++ b/po/es.po
--- a/po/et.po
+++ b/po/et.po
--- a/po/fi.po
+++ b/po/fi.po
--- a/po/fr.po
+++ b/po/fr.po
--- a/po/he.po
+++ b/po/he.po
@@ -9,7 +9,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: metacity.HEAD.he\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-08-03 09:21+0300\n"
+"POT-Creation-Date: 2006-11-22 04:22+0100\n"
 "PO-Revision-Date: 2005-07-31 01:18+0300\n"
 "Last-Translator: Yuval Tanny\n"
 "Language-Team: Hebrew <he@li.org>\n"
@@ -27,35 +27,35 @@ msgstr "שימוש: %s\n"
 msgid "Metacity was compiled without support for verbose mode\n"
 msgstr "Metacity was compiled without support for verbose mode\n"

-#: ../src/delete.c:64 ../src/delete.c:91 ../src/metacity-dialog.c:71
+#: ../src/delete.c:65 ../src/delete.c:92 ../src/metacity-dialog.c:48
 #: ../src/theme-parser.c:467
 #, c-format
 msgid "Could not parse \"%s\" as an integer"
 msgstr "לא ניתן להעביר את \"%s\" כמספר שלם"

-#: ../src/delete.c:71 ../src/delete.c:98 ../src/metacity-dialog.c:78
+#: ../src/delete.c:72 ../src/delete.c:99 ../src/metacity-dialog.c:55
 #: ../src/theme-parser.c:476 ../src/theme-parser.c:530
 #, c-format
 msgid "Did not understand trailing characters \"%s\" in string \"%s\""
 msgstr "לא ניתן להבין את התוים \"%s\" במחרוזת \"%s\""

-#: ../src/delete.c:129
+#: ../src/delete.c:130
 #, c-format
 msgid "Failed to parse message \"%s\" from dialog process\n"
 msgstr "נכשל בהעברת ההודעה \"%s\" מתהליך תיבת דו-השיח\n"

-#: ../src/delete.c:264
+#: ../src/delete.c:265
 #, c-format
 msgid "Error reading from dialog display process: %s\n"
 msgstr "שגיאה בקריאה מתהליך הצגת תיבת דו-שיח: %s\n"

-#: ../src/delete.c:345
+#: ../src/delete.c:346
 #, c-format
 msgid ""
 "Error launching metacity-dialog to ask about killing an application: %s\n"
 msgstr "שגיאה בהפעלת תיבת דו-שיח של מטאסיטי השואלת אם להרוג יישום: %s\n"

-#: ../src/delete.c:453
+#: ../src/delete.c:454
 #, c-format
 msgid "Failed to get hostname: %s\n"
 msgstr "נכשל בקבלת שם המארח: %s\n"
@@ -81,44 +81,44 @@ msgstr ""
 msgid "Fatal IO error %d (%s) on display '%s'.\n"
 msgstr "שגיאת קלט/פלט חמורה %d (%s) בתצוגה '%s'.\n"

-#: ../src/frames.c:1086
+#: ../src/frames.c:1089
 msgid "Close Window"
 msgstr "סגור חלון"

-#: ../src/frames.c:1089
+#: ../src/frames.c:1092
 msgid "Window Menu"
 msgstr "תפריט חלון"

-#: ../src/frames.c:1092
+#: ../src/frames.c:1095
 msgid "Minimize Window"
 msgstr "מזער חלון"

-#: ../src/frames.c:1095
+#: ../src/frames.c:1098
 msgid "Maximize Window"
 msgstr "הגדל חלון"

-#: ../src/frames.c:1098
+#: ../src/frames.c:1101
 msgid "Unmaximize Window"
 msgstr "שחזר חלון"

-#: ../src/keybindings.c:1021
+#: ../src/keybindings.c:1031
 #, c-format
 msgid ""
 "Some other program is already using the key %s with modifiers %x as a "
 "binding\n"
 msgstr "תוכנית אחרת כבר משתמשת במקש %s עם המקש %x כצירוף\n"

-#: ../src/keybindings.c:2588
+#: ../src/keybindings.c:2663
 #, c-format
 msgid "Error launching metacity-dialog to print an error about a command: %s\n"
 msgstr "שגיאה בהפעלת תיבת דו-שיח של מטאסיטי כדי להדפיס שגיאה על הפקודה: %s\n"

-#: ../src/keybindings.c:2693
+#: ../src/keybindings.c:2768
 #, c-format
 msgid "No command %d has been defined.\n"
 msgstr "אף פקודה %d לא הוגדרה.\n"

-#: ../src/keybindings.c:3559
+#: ../src/keybindings.c:3635
 msgid "No terminal command has been defined.\n"
 msgstr "אף פקודת מסוף לא הוגדרה.\n"

@@ -131,50 +131,52 @@ msgid ""
 "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A "
 "PARTICULAR PURPOSE.\n"
 msgstr ""
-"מטאסיטי %s\n"
-"כל הזכויות שמורות (C) 2001-2002 Havoc Pennington, Red Hat, Inc., ואחרים\n"
-"זוהי תוכנה חופשית; ראה קוד מקור לתנאי ההעתקה.\n"
-"אין אחראיות; אפילו לא לאפשרויות מסחר או התאמה למטרה מסויימת.\n"
+"metacity %s\n"
+"Copyright (C) 2001-2002 Havoc Pennington, Red Hat, Inc., and others\n"
+"This is free software; see the source for copying conditions.\n"
+"There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A "
+"PARTICULAR PURPOSE.\n"

 #: ../src/main.c:169
 msgid "Disable connection to session manager"
-msgstr ""
+msgstr "Disable connection to session manager"

 #: ../src/main.c:175
 msgid "Replace the running window manager with Metacity"
-msgstr ""
+msgstr "Replace the running window manager with Metacity"

 #: ../src/main.c:181
 msgid "Specify session management ID"
-msgstr ""
+msgstr "Specify session management ID"

 #: ../src/main.c:186
 msgid "X Display to use"
-msgstr ""
+msgstr "X Display to use"

 #: ../src/main.c:192
 msgid "Initialize session from savefile"
-msgstr ""
+msgstr "Initialize session from savefile"

 #: ../src/main.c:198
 msgid "Print version"
-msgstr ""
+msgstr "Print version"

 #: ../src/main.c:350
 #, c-format
 msgid "Failed to scan themes directory: %s\n"
-msgstr "נכשל בסריקת ספריית ערכות נושא: %s\n"
+msgstr "Failed to scan themes directory: %s\n"

 #: ../src/main.c:366
 #, c-format
 msgid ""
 "Could not find a theme! Be sure %s exists and contains the usual themes."
-msgstr "לא ניתן למצוא ערכת נושא! ודא כי %s קיים ומכיל את ערכות הנושא הרגילות."
+msgstr ""
+"Could not find a theme! Be sure %s exists and contains the usual themes."

-#: ../src/main.c:424
+#: ../src/main.c:426
 #, c-format
 msgid "Failed to restart: %s\n"
-msgstr "נכשל בהפעלה מחדש: %s\n"
+msgstr "Failed to restart: %s\n"

 #: ../src/menu.c:55
 msgid "Mi_nimize"
@@ -242,7 +244,7 @@ msgstr "הזז חלון לסביבת העבודה למעלה"
 msgid "Move to Workspace _Down"
 msgstr "הזז חלון לסביבת העבודה למטה"

-#: ../src/menu.c:164 ../src/prefs.c:2142 ../src/prefs.c:2669
+#: ../src/menu.c:164 ../src/prefs.c:2142 ../src/prefs.c:2677
 #, c-format
 msgid "Workspace %d"
 msgstr "סביבת עבודה %d"
@@ -350,29 +352,29 @@ msgstr "Mod4"
 msgid "Mod5"
 msgstr "Mod5"

-#: ../src/metacity-dialog.c:111
+#: ../src/metacity-dialog.c:88
 #, c-format
 msgid "The window \"%s\" is not responding."
 msgstr "החלון \"%s\" אינו מגיב"

-#: ../src/metacity-dialog.c:119
+#: ../src/metacity-dialog.c:96
 msgid ""
 "Forcing this application to quit will cause you to lose any unsaved changes."
 msgstr "להכריח את ישום זה לסיים יגרום לאיבוד שינויים שלא נשמרו"

-#: ../src/metacity-dialog.c:130
+#: ../src/metacity-dialog.c:107
 msgid "_Force Quit"
 msgstr "_הכרח יציאה"

-#: ../src/metacity-dialog.c:227
+#: ../src/metacity-dialog.c:204
 msgid "Title"
 msgstr "כותרת"

-#: ../src/metacity-dialog.c:239
+#: ../src/metacity-dialog.c:216
 msgid "Class"
 msgstr "מחלקה"

-#: ../src/metacity-dialog.c:265
+#: ../src/metacity-dialog.c:242
 msgid ""
 "These windows do not support \"save current setup\" and will have to be "
 "restarted manually next time you log in."
@@ -380,7 +382,7 @@ msgstr ""
 "חלון זה אינו תומך ב\"שמירת ההגדרות הנוכחיות\", ויהיה צורך באתחול ידני בכניסה "
 "הבאה שלך."

-#: ../src/metacity-dialog.c:331
+#: ../src/metacity-dialog.c:308
 #, c-format
 msgid ""
 "There was an error running \"%s\":\n"
@@ -395,7 +397,8 @@ msgstr "מטאסיטי"

 #: ../src/metacity.schemas.in.h:1
 msgid "(Not implemented) Navigation works in terms of applications not windows"
-msgstr "(Not implemented) Navigation works in terms of applications not windows"
+msgstr ""
+"(Not implemented) Navigation works in terms of applications not windows"

 #: ../src/metacity.schemas.in.h:2
 msgid ""
@@ -2061,7 +2064,7 @@ msgstr "Window title font"
 #: ../src/prefs.c:1014 ../src/prefs.c:1030
 #, c-format
 msgid "GConf key \"%s\" is set to an invalid type\n"
-msgstr "מפתח GConf \"%s\" נקבע לסוג לא תקני\n"
+msgstr "GConf key \"%s\" is set to an invalid type\n"

 #: ../src/prefs.c:1075
 #, c-format
@@ -2069,11 +2072,13 @@ msgid ""
 "\"%s\" found in configuration database is not a valid value for mouse button "
 "modifier\n"
 msgstr ""
+"\"%s\" found in configuration database is not a valid value for mouse button "
+"modifier\n"

 #: ../src/prefs.c:1099 ../src/prefs.c:1120 ../src/prefs.c:1616
 #, c-format
 msgid "GConf key '%s' is set to an invalid value\n"
-msgstr ""
+msgstr "GConf key '%s' is set to an invalid value\n"

 #: ../src/prefs.c:1249
 #, c-format
@@ -2081,11 +2086,13 @@ msgid ""
 "%d stored in GConf key %s is not a reasonable cursor_size; must be in the "
 "range 1..128\n"
 msgstr ""
+"%d stored in GConf key %s is not a reasonable cursor_size; must be in the "
+"range 1..128\n"

 #: ../src/prefs.c:1329
 #, c-format
 msgid "Could not parse font description \"%s\" from GConf key %s\n"
-msgstr ""
+msgstr "Could not parse font description \"%s\" from GConf key %s\n"

 #: ../src/prefs.c:1514
 #, c-format
@@ -2093,46 +2100,52 @@ msgid ""
 "%d stored in GConf key %s is not a reasonable number of workspaces, current "
 "maximum is %d\n"
 msgstr ""
+"%d stored in GConf key %s is not a reasonable number of workspaces, current "
+"maximum is %d\n"

 #: ../src/prefs.c:1574
 msgid ""
 "Workarounds for broken applications disabled. Some applications may not "
 "behave properly.\n"
 msgstr ""
+"Workarounds for broken applications disabled. Some applications may not "
+"behave properly.\n"

 #: ../src/prefs.c:1643
 #, c-format
 msgid "%d stored in GConf key %s is out of range 0 to %d\n"
-msgstr ""
+msgstr "%d stored in GConf key %s is out of range 0 to %d\n"

 #: ../src/prefs.c:1786
 #, c-format
 msgid "Error setting number of workspaces to %d: %s\n"
-msgstr ""
+msgstr "Error setting number of workspaces to %d: %s\n"

-#: ../src/prefs.c:2170 ../src/prefs.c:2335
+#: ../src/prefs.c:2172 ../src/prefs.c:2342
 #, c-format
 msgid ""
 "\"%s\" found in configuration database is not a valid value for keybinding "
 "\"%s\"\n"
 msgstr ""
+"\"%s\" found in configuration database is not a valid value for keybinding "
+"\"%s\"\n"

-#: ../src/prefs.c:2750
+#: ../src/prefs.c:2758
 #, c-format
 msgid "Error setting name for workspace %d to \"%s\": %s\n"
-msgstr ""
+msgstr "Error setting name for workspace %d to \"%s\": %s\n"

 #: ../src/resizepopup.c:111
 #, c-format
 msgid "%d x %d"
 msgstr "%d x %d"

-#: ../src/screen.c:403
+#: ../src/screen.c:404
 #, c-format
 msgid "Screen %d on display '%s' is invalid\n"
 msgstr "Screen %d on display '%s' is invalid\n"

-#: ../src/screen.c:419
+#: ../src/screen.c:420
 #, c-format
 msgid ""
 "Screen %d on display \"%s\" already has a window manager; try using the --"
@@ -2141,19 +2154,19 @@ msgstr ""
 "Screen %d on display \"%s\" already has a window manager; try using the --"
 "replace option to replace the current window manager.\n"

-#: ../src/screen.c:443
+#: ../src/screen.c:444
 #, c-format
 msgid ""
 "Could not acquire window manager selection on screen %d display \"%s\"\n"
 msgstr ""
 "Could not acquire window manager selection on screen %d display \"%s\"\n"

-#: ../src/screen.c:501
+#: ../src/screen.c:502
 #, c-format
 msgid "Screen %d on display \"%s\" already has a window manager\n"
 msgstr "Screen %d on display \"%s\" already has a window manager\n"

-#: ../src/screen.c:705
+#: ../src/screen.c:707
 #, c-format
 msgid "Could not release screen %d on display \"%s\"\n"
 msgstr "Could not release screen %d on display \"%s\"\n"
@@ -2238,7 +2251,7 @@ msgstr "Line %d character %d: %s"
 #: ../src/theme-parser.c:396
 #, c-format
 msgid "Attribute \"%s\" repeated twice on the same <%s> element"
-msgstr ""
+msgstr "Attribute \"%s\" repeated twice on the same <%s> element"

 #: ../src/theme-parser.c:414 ../src/theme-parser.c:439
 #, c-format
@@ -2959,296 +2972,316 @@ msgstr ""

 #: ../src/theme.c:202
 msgid "top"
-msgstr "מעלה"
+msgstr "top"

 #: ../src/theme.c:204
 msgid "bottom"
-msgstr "מטה"
+msgstr "bottom"

 #: ../src/theme.c:206
 msgid "left"
-msgstr "שמאלה"
+msgstr "left"

 #: ../src/theme.c:208
 msgid "right"
-msgstr "ימינה"
+msgstr "right"

 #: ../src/theme.c:222
 #, c-format
 msgid "frame geometry does not specify \"%s\" dimension"
-msgstr ""
+msgstr "frame geometry does not specify \"%s\" dimension"

 #: ../src/theme.c:241
 #, c-format
 msgid "frame geometry does not specify dimension \"%s\" for border \"%s\""
-msgstr ""
+msgstr "frame geometry does not specify dimension \"%s\" for border \"%s\""

 #: ../src/theme.c:278
 #, c-format
 msgid "Button aspect ratio %g is not reasonable"
-msgstr ""
+msgstr "Button aspect ratio %g is not reasonable"

 #: ../src/theme.c:290
 msgid "Frame geometry does not specify size of buttons"
-msgstr ""
+msgstr "Frame geometry does not specify size of buttons"

-#: ../src/theme.c:813
+#: ../src/theme.c:847
 msgid "Gradients should have at least two colors"
-msgstr ""
+msgstr "Gradients should have at least two colors"

-#: ../src/theme.c:939
+#: ../src/theme.c:973
 #, c-format
 msgid ""
 "GTK color specification must have the state in brackets, e.g. gtk:fg[NORMAL] "
 "where NORMAL is the state; could not parse \"%s\""
 msgstr ""
+"GTK color specification must have the state in brackets, e.g. gtk:fg[NORMAL] "
+"where NORMAL is the state; could not parse \"%s\""

-#: ../src/theme.c:953
+#: ../src/theme.c:987
 #, c-format
 msgid ""
 "GTK color specification must have a close bracket after the state, e.g. gtk:"
 "fg[NORMAL] where NORMAL is the state; could not parse \"%s\""
 msgstr ""
+"GTK color specification must have a close bracket after the state, e.g. gtk:"
+"fg[NORMAL] where NORMAL is the state; could not parse \"%s\""

-#: ../src/theme.c:964
+#: ../src/theme.c:998
 #, c-format
 msgid "Did not understand state \"%s\" in color specification"
-msgstr ""
+msgstr "Did not understand state \"%s\" in color specification"

-#: ../src/theme.c:977
+#: ../src/theme.c:1011
 #, c-format
 msgid "Did not understand color component \"%s\" in color specification"
-msgstr ""
+msgstr "Did not understand color component \"%s\" in color specification"

-#: ../src/theme.c:1007
+#: ../src/theme.c:1041
 #, c-format
 msgid ""
 "Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the "
 "format"
 msgstr ""
+"Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the "
+"format"

-#: ../src/theme.c:1018
+#: ../src/theme.c:1052
 #, c-format
 msgid "Could not parse alpha value \"%s\" in blended color"
-msgstr ""
+msgstr "Could not parse alpha value \"%s\" in blended color"

-#: ../src/theme.c:1028
+#: ../src/theme.c:1062
 #, c-format
 msgid "Alpha value \"%s\" in blended color is not between 0.0 and 1.0"
-msgstr ""
+msgstr "Alpha value \"%s\" in blended color is not between 0.0 and 1.0"

-#: ../src/theme.c:1075
+#: ../src/theme.c:1109
 #, c-format
 msgid ""
 "Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format"
 msgstr ""
+"Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format"

-#: ../src/theme.c:1086
+#: ../src/theme.c:1120
 #, c-format
 msgid "Could not parse shade factor \"%s\" in shaded color"
-msgstr ""
+msgstr "Could not parse shade factor \"%s\" in shaded color"

-#: ../src/theme.c:1096
+#: ../src/theme.c:1130
 #, c-format
 msgid "Shade factor \"%s\" in shaded color is negative"
-msgstr ""
+msgstr "Shade factor \"%s\" in shaded color is negative"

-#: ../src/theme.c:1125
+#: ../src/theme.c:1159
 #, c-format
 msgid "Could not parse color \"%s\""
-msgstr ""
+msgstr "Could not parse color \"%s\""

-#: ../src/theme.c:1384
+#: ../src/theme.c:1418
 #, c-format
 msgid "Coordinate expression contains character '%s' which is not allowed"
-msgstr ""
+msgstr "Coordinate expression contains character '%s' which is not allowed"

-#: ../src/theme.c:1411
+#: ../src/theme.c:1445
 #, c-format
 msgid ""
 "Coordinate expression contains floating point number '%s' which could not be "
 "parsed"
 msgstr ""
+"Coordinate expression contains floating point number '%s' which could not be "
+"parsed"

-#: ../src/theme.c:1425
+#: ../src/theme.c:1459
 #, c-format
 msgid "Coordinate expression contains integer '%s' which could not be parsed"
-msgstr ""
+msgstr "Coordinate expression contains integer '%s' which could not be parsed"

-#: ../src/theme.c:1492
+#: ../src/theme.c:1526
 #, c-format
 msgid ""
 "Coordinate expression contained unknown operator at the start of this text: "
 "\"%s\""
 msgstr ""
+"Coordinate expression contained unknown operator at the start of this text: "
+"\"%s\""

-#: ../src/theme.c:1549
+#: ../src/theme.c:1583
 msgid "Coordinate expression was empty or not understood"
-msgstr ""
+msgstr "Coordinate expression was empty or not understood"

-#: ../src/theme.c:1686 ../src/theme.c:1696 ../src/theme.c:1730
+#: ../src/theme.c:1720 ../src/theme.c:1730 ../src/theme.c:1764
 msgid "Coordinate expression results in division by zero"
-msgstr ""
+msgstr "Coordinate expression results in division by zero"

-#: ../src/theme.c:1738
+#: ../src/theme.c:1772
 msgid ""
 "Coordinate expression tries to use mod operator on a floating-point number"
-msgstr ""
+msgstr 
+"Coordinate expression tries to use mod operator on a floating-point number"

-#: ../src/theme.c:1794
+#: ../src/theme.c:1828
 #, c-format
 msgid ""
 "Coordinate expression has an operator \"%s\" where an operand was expected"
 msgstr ""
+"Coordinate expression has an operator \"%s\" where an operand was expected"

-#: ../src/theme.c:1803
+#: ../src/theme.c:1837
 msgid "Coordinate expression had an operand where an operator was expected"
-msgstr ""
+msgstr "Coordinate expression had an operand where an operator was expected"

-#: ../src/theme.c:1811
+#: ../src/theme.c:1845
 msgid "Coordinate expression ended with an operator instead of an operand"
-msgstr ""
+msgstr "Coordinate expression ended with an operator instead of an operand"

-#: ../src/theme.c:1821
+#: ../src/theme.c:1855
 #, c-format
 msgid ""
 "Coordinate expression has operator \"%c\" following operator \"%c\" with no "
 "operand in between"
 msgstr ""
+"Coordinate expression has operator \"%c\" following operator \"%c\" with no "
+"operand in between"

-#: ../src/theme.c:1939
+#: ../src/theme.c:1973
 msgid "Coordinate expression parser overflowed its buffer."
-msgstr ""
+msgstr "Coordinate expression parser overflowed its buffer."

-#: ../src/theme.c:1968
+#: ../src/theme.c:2002
 msgid "Coordinate expression had a close parenthesis with no open parenthesis"
-msgstr ""
+msgstr "Coordinate expression had a close parenthesis with no open parenthesis"

-#: ../src/theme.c:2030
+#: ../src/theme.c:2064
 #, c-format
 msgid "Coordinate expression had unknown variable or constant \"%s\""
-msgstr ""
+msgstr "Coordinate expression had unknown variable or constant \"%s\""

-#: ../src/theme.c:2085
+#: ../src/theme.c:2119
 msgid "Coordinate expression had an open parenthesis with no close parenthesis"
-msgstr ""
+msgstr "Coordinate expression had an open parenthesis with no close parenthesis"

-#: ../src/theme.c:2096
+#: ../src/theme.c:2130
 msgid "Coordinate expression doesn't seem to have any operators or operands"
-msgstr ""
+msgstr "Coordinate expression doesn't seem to have any operators or operands"

-#: ../src/theme.c:2337 ../src/theme.c:2359 ../src/theme.c:2380
+#: ../src/theme.c:2371 ../src/theme.c:2393 ../src/theme.c:2414
 #, c-format
 msgid "Theme contained an expression \"%s\" that resulted in an error: %s\n"
-msgstr "ערכת הנושא מכילה ביטוי \"%s\" שגרם לשגיאה: %s\n"
+msgstr "Theme contained an expression \"%s\" that resulted in an error: %s\n"

-#: ../src/theme.c:3826
+#: ../src/theme.c:3860
 #, c-format
 msgid ""
 "<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be "
 "specified for this frame style"
 msgstr ""
-"<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> חייב להיות "
-"מצויין לסגנון מסגרת זו"
+"<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be "
+"specified for this frame style"

-#: ../src/theme.c:4270 ../src/theme.c:4295
+#: ../src/theme.c:4304 ../src/theme.c:4329
 #, c-format
 msgid ""
 "Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"
 msgstr ""
-"חסר <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"
+"Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"

-#: ../src/theme.c:4341
+#: ../src/theme.c:4375
 #, c-format
 msgid "Failed to load theme \"%s\": %s\n"
-msgstr "נכשל בטעינת ערכת נושא \"%s\": %s\n"
+msgstr "Failed to load theme \"%s\": %s\n"

-#: ../src/theme.c:4481 ../src/theme.c:4488 ../src/theme.c:4495
-#: ../src/theme.c:4502 ../src/theme.c:4509
+#: ../src/theme.c:4515 ../src/theme.c:4522 ../src/theme.c:4529
+#: ../src/theme.c:4536 ../src/theme.c:4543
 #, c-format
 msgid "No <%s> set for theme \"%s\""
-msgstr "לא נקבע <%s> לערכת הנושא \"%s\""
+msgstr "No <%s> set for theme \"%s\""

-#: ../src/theme.c:4517
+#: ../src/theme.c:4551
 #, c-format
 msgid ""
 "No frame style set for window type \"%s\" in theme \"%s\", add a <window "
 "type=\"%s\" style_set=\"whatever\"/> element"
 msgstr ""
+"No frame style set for window type \"%s\" in theme \"%s\", add a <window "
+"type=\"%s\" style_set=\"whatever\"/> element"

-#: ../src/theme.c:4531
+#: ../src/theme.c:4565
 #, c-format
 msgid ""
 "<menu_icon function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be "
 "specified for this theme"
 msgstr ""
-"<menu_icon function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> חייב להיות "
-"מצויין לערכת נושא זו"
+"<menu_icon function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be "
+"specified for this theme"

-#: ../src/theme.c:4911 ../src/theme.c:4973
+#: ../src/theme.c:4945 ../src/theme.c:5007
 #, c-format
 msgid ""
 "User-defined constants must begin with a capital letter; \"%s\" does not"
-msgstr "קבועים מותאמים-אישית חייבים להתחיל באות גדולה; \"%s\" לא"
+msgstr ""
+"User-defined constants must begin with a capital letter; \"%s\" does not"

-#: ../src/theme.c:4919 ../src/theme.c:4981
+#: ../src/theme.c:4953 ../src/theme.c:5015
 #, c-format
 msgid "Constant \"%s\" has already been defined"
-msgstr "הקבוע \"%s\" כבר הוגדר"
+msgstr "Constant \"%s\" has already been defined"

 #: ../src/util.c:96
 #, c-format
 msgid "Failed to open debug log: %s\n"
-msgstr ""
+msgstr "Failed to open debug log: %s\n"

 #: ../src/util.c:106
 #, c-format
 msgid "Failed to fdopen() log file %s: %s\n"
-msgstr ""
+msgstr "Failed to fdopen() log file %s: %s\n"

 #: ../src/util.c:112
 #, c-format
 msgid "Opened log file %s\n"
-msgstr ""
+msgstr "Opened log file %s\n"

 #: ../src/util.c:220
 msgid "Window manager: "
-msgstr "מנהל החלונות: "
+msgstr "Window manager: "

 #: ../src/util.c:368
 msgid "Bug in window manager: "
-msgstr "תקלה במנהל החלונות: "
+msgstr "Bug in window manager: "

 #: ../src/util.c:397
 msgid "Window manager warning: "
-msgstr "אזהרת מנהל החלונות: "
+msgstr "Window manager warning: "

 #: ../src/util.c:421
 msgid "Window manager error: "
-msgstr "שגיאת מנהל החלונות: "
+msgstr "Window manager error: "

-#: ../src/window-props.c:169
+#: ../src/window-props.c:170
 #, c-format
 msgid "Application set a bogus _NET_WM_PID %lu\n"
-msgstr ""
+msgstr "Application set a bogus _NET_WM_PID %lu\n"

-#: ../src/window-props.c:237
+#: ../src/window-props.c:238
 #, c-format
 msgid "%s (on %s)"
-msgstr ""
+msgstr "%s (מעל %s)"

-#: ../src/window-props.c:1159
+#: ../src/window-props.c:1182
 #, c-format
 msgid "Invalid WM_TRANSIENT_FOR window 0x%lx specified for %s.\n"
-msgstr ""
+msgstr "Invalid WM_TRANSIENT_FOR window 0x%lx specified for %s.\n"

 #. first time through
-#: ../src/window.c:5248
+#: ../src/window.c:5359
 #, c-format
 msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
 "window as specified in the ICCCM.\n"
 msgstr ""
+"Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
+"window as specified in the ICCCM.\n"

 #. We ignore mwm_has_resize_func because WM_NORMAL_HINTS is the
 #. * authoritative source for that info. Some apps such as mplayer or
@@ -3257,12 +3290,14 @@ msgstr ""
 #. * MWM but not WM_NORMAL_HINTS are basically broken. We complain
 #. * about these apps but make them work.
 #.
-#: ../src/window.c:5844
+#: ../src/window.c:5955
 #, c-format
 msgid ""
 "Window %s sets an MWM hint indicating it isn't resizable, but sets min size %"
 "d x %d and max size %d x %d; this doesn't make much sense.\n"
 msgstr ""
+"Window %s sets an MWM hint indicating it isn't resizable, but sets min size %"
+"d x %d and max size %d x %d; this doesn't make much sense.\n"

 #: ../src/xprops.c:153
 #, c-format
@@ -3273,14 +3308,20 @@ msgid ""
 "This is most likely an application bug, not a window manager bug.\n"
 "The window has title=\"%s\" class=\"%s\" name=\"%s\"\n"
 msgstr ""
+"Window 0x%lx has property %s\n"
+"that was expected to have type %s format %d\n"
+"and actually has type %s format %d n_items %d.\n"
+"This is most likely an application bug, not a window manager bug.\n"
+"The window has title=\"%s\" class=\"%s\" name=\"%s\"\n"

 #: ../src/xprops.c:399
 #, c-format
 msgid "Property %s on window 0x%lx contained invalid UTF-8\n"
-msgstr "המאפיין %s של החלון 0x%lx מכיל UTF-8 לא תקני\n"
+msgstr "Property %s on window 0x%lx contained invalid UTF-8\n"

 #: ../src/xprops.c:482
 #, c-format
 msgid ""
 "Property %s on window 0x%lx contained invalid UTF-8 for item %d in the list\n"
-msgstr "המאפיין %s של החלון 0x%lx מכיל UTF-8 לא תקני לפריט %d ברשימה\n"
+msgstr ""
+"Property %s on window 0x%lx contained invalid UTF-8 for item %d in the list\n"
--- a/po/hu.po
+++ b/po/hu.po
--- a/po/it.po
+++ b/po/it.po
--- a/po/ja.po
+++ b/po/ja.po
--- a/po/ko.po
+++ b/po/ko.po
--- a/po/ku.po
+++ b/po/ku.po
--- a/po/lt.po
+++ b/po/lt.po
--- a/po/lv.po
+++ b/po/lv.po
--- a/po/mk.po
+++ b/po/mk.po
--- a/po/nb.po
+++ b/po/nb.po
--- a/po/nl.po
+++ b/po/nl.po
--- a/po/pa.po
+++ b/po/pa.po
--- a/po/pl.po
+++ b/po/pl.po
--- a/po/pt.po
+++ b/po/pt.po
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
--- a/po/ro.po
+++ b/po/ro.po
@@ -260,7 +260,7 @@ msgstr "Ecranul %s%d"

 #: ../src/menu.c:370
 msgid "Move to Another _Workspace"
-msgstr "Mută ferestra către un alt _ecran"
+msgstr "Mută fereastra către un alt _ecran"

 #. This is the text that should appear next to menu accelerators
 #. * that use the shift key. If the text on this key isn't typically
@@ -456,7 +456,7 @@ msgid ""
 "for example."
 msgstr ""
 "Efectuănd un click pe o fereastră având apăsată această tastă modificator va "
-"muta fereastra (click normal), va redimensiona ferestra (click cu butonul "
+"muta fereastra (click normal), va redimensiona fereastra (click cu butonul "
 "din mijloc), sau va arăta meniul ferestrei (click cu butonul din dreapta). "
 "Modificatorul este scris ca „&lt;Alt&gt;” sau „&lt;Super&gt;”, de exemplu."

@@ -599,7 +599,7 @@ msgstr ""

 #: ../src/metacity.schemas.in.h:24
 msgid "Maximize window"
-msgstr "Maximizează ferestra"
+msgstr "Maximizează fereastra"

 #: ../src/metacity.schemas.in.h:25
 msgid "Maximize window horizontally"
@@ -667,7 +667,7 @@ msgstr "Mută fereastra un ecran la dreapta"

 #: ../src/metacity.schemas.in.h:41
 msgid "Move window one workspace up"
-msgstr "Mută ferestra un ecran mai sus"
+msgstr "Mută fereastra un ecran mai sus"

 #: ../src/metacity.schemas.in.h:42
 msgid "Move window to workspace 1"
@@ -1932,7 +1932,7 @@ msgid ""
 "option to the special string \"disabled\", then there will be no keybinding "
 "for this action."
 msgstr ""
-"Combinaţia de taste folosită pentru a maximiza o ferestră la totalul "
+"Combinaţia de taste folosită pentru a maximiza o fereastră la totalul "
 "spaţiului disponibil pe verticală. Formatul arată ca de exemplu „&lt;"
 "Control&gt;a” sau „&lt;Shift&gt;&lt;Alt&gt;F1”. Este permisă folosirea "
 "majusculelor şi a minusculelor, precum şi a abrevierilor gen „&lt;Ctl&gt;” "
@@ -2877,7 +2877,7 @@ msgstr "Test de performanţă"

 #: ../src/theme-viewer.c:900
 msgid "Window Title Goes Here"
-msgstr "Titlul de ferestră vine aici"
+msgstr "Titlul de fereastră vine aici"

 #: ../src/theme-viewer.c:1004
 #, c-format
@@ -3235,7 +3235,7 @@ msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
 "window as specified in the ICCCM.\n"
 msgstr ""
-"Ferestra %s setează SM_CLIENT_ID asupra sa, în loc să o facă asupra "
+"Fereastra %s setează SM_CLIENT_ID asupra sa, în loc să o facă asupra "
 "ferestrei WM_CLIENT_LEADER aşa cum este specificat în ICCCM.\n"

 #. We ignore mwm_has_resize_func because WM_NORMAL_HINTS is the
--- a/po/ru.po
+++ b/po/ru.po
--- a/po/sr.po
+++ b/po/sr.po
--- a/po/sr@Latn.po
+++ b/po/sr@Latn.po
--- a/po/sv.po
+++ b/po/sv.po
--- a/po/th.po
+++ b/po/th.po
--- a/po/uk.po
+++ b/po/uk.po
--- a/po/vi.po
+++ b/po/vi.po
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
--- a/po/zh_HK.po
+++ b/po/zh_HK.po
--- a/po/zh_TW.po
+++ b/po/zh_TW.po
--- a/src/api.c
+++ b/src/api.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity misc. public entry points */

 /* 
--- a/src/api.h
+++ b/src/api.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity misc. public entry points */

 /* 
--- a/src/async-getprop.c
+++ b/src/async-getprop.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Asynchronous X property getting hack */

 /*
--- a/src/async-getprop.h
+++ b/src/async-getprop.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Asynchronous X property getting hack */

 /*
--- a/src/bell.c
+++ b/src/bell.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity visual bell */

 /* 
--- a/src/bell.h
+++ b/src/bell.h
@@ -1,5 +1,6 @@
 /* Metacity visual bell */

+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /* 
 * Copyright (C) 2002 Sun Microsystems Inc.
 * 
--- a/src/boxes.c
+++ b/src/boxes.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Simple box operations */

 /* 
@@ -545,10 +547,10 @@ meta_rectangle_get_minimal_spanning_set_for_region (
  ret = g_list_prepend (NULL, temp_rect);

  strut_iter = all_struts;
-  while (strut_iter)
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
    {
      GList *rect_iter; 
-      MetaRectangle *strut = (MetaRectangle*) strut_iter->data;
+      MetaRectangle *strut_rect = &((MetaStrut*)strut_iter->data)->rect;

      tmp_list = ret;
      ret = NULL;
@@ -556,45 +558,45 @@ meta_rectangle_get_minimal_spanning_set_for_region (
      while (rect_iter)
        {
          MetaRectangle *rect = (MetaRectangle*) rect_iter->data;
-          if (!meta_rectangle_overlap (rect, strut))
+          if (!meta_rectangle_overlap (rect, strut_rect))
            ret = g_list_prepend (ret, rect);
          else
            {
              /* If there is area in rect left of strut */
-              if (rect->x < strut->x)
+              if (BOX_LEFT (*rect) < BOX_LEFT (*strut_rect))
                {
                  temp_rect = g_new (MetaRectangle, 1);
                  *temp_rect = *rect;
-                  temp_rect->width = strut->x - rect->x;
+                  temp_rect->width = BOX_LEFT (*strut_rect) - BOX_LEFT (*rect);
                  ret = g_list_prepend (ret, temp_rect);
                }
              /* If there is area in rect right of strut */
-              if (rect->x + rect->width > strut->x + strut->width)
+              if (BOX_RIGHT (*rect) > BOX_RIGHT (*strut_rect))
                {
                  int new_x;
                  temp_rect = g_new (MetaRectangle, 1);
                  *temp_rect = *rect;
-                  new_x = strut->x + strut->width;
-                  temp_rect->width = rect->x + rect->width - new_x;
+                  new_x = BOX_RIGHT (*strut_rect);
+                  temp_rect->width = BOX_RIGHT(*rect) - new_x;
                  temp_rect->x = new_x;
                  ret = g_list_prepend (ret, temp_rect);
                }
              /* If there is area in rect above strut */
-              if (rect->y < strut->y)
+              if (BOX_TOP (*rect) < BOX_TOP (*strut_rect))
                {
                  temp_rect = g_new (MetaRectangle, 1);
                  *temp_rect = *rect;
-                  temp_rect->height = strut->y - rect->y;
+                  temp_rect->height = BOX_TOP (*strut_rect) - BOX_TOP (*rect);
                  ret = g_list_prepend (ret, temp_rect);
                }
              /* If there is area in rect below strut */
-              if (rect->y + rect->height > strut->y + strut->height)
+              if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*strut_rect))
                {
                  int new_y;
                  temp_rect = g_new (MetaRectangle, 1);
                  *temp_rect = *rect;
-                  new_y = strut->y + strut->height;
-                  temp_rect->height = rect->y + rect->height - new_y;
+                  new_y = BOX_BOTTOM (*strut_rect);
+                  temp_rect->height = BOX_BOTTOM (*rect) - new_y;
                  temp_rect->y = new_y;
                  ret = g_list_prepend (ret, temp_rect);
                }
@@ -603,7 +605,6 @@ meta_rectangle_get_minimal_spanning_set_for_region (
          rect_iter = rect_iter->next;
        }
      g_list_free (tmp_list);
-      strut_iter = strut_iter->next;
    }

  /* Sort by maximal area, just because I feel like it... */
@@ -660,6 +661,76 @@ meta_rectangle_expand_region_conditionally (GList     *region,
  return region;
 }

+void
+meta_rectangle_expand_to_avoiding_struts (MetaRectangle       *rect,
+                                          const MetaRectangle *expand_to,
+                                          const MetaDirection  direction,
+                                          const GSList        *all_struts)
+{
+  const GSList *strut_iter;
+
+  /* If someone wants this function to handle more fine-grained
+   * direction expanding in the future (e.g. only left, or fully
+   * horizontal plus upward), feel free.  But I'm hard-coding for both
+   * horizontal directions (exclusive-)or both vertical directions.
+   */
+  g_assert ((direction == META_DIRECTION_HORIZONTAL) ^
+            (direction == META_DIRECTION_VERTICAL  ));
+ 
+  if (direction == META_DIRECTION_HORIZONTAL)
+    {
+      rect->x      = expand_to->x;
+      rect->width  = expand_to->width;
+    }
+  else
+    {
+      rect->y      = expand_to->y;
+      rect->height = expand_to->height;
+    }
+
+ 
+  /* Run over all struts */
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      MetaStrut *strut = (MetaStrut*) strut_iter->data;
+ 
+      /* Skip struts that don't overlap */
+      if (!meta_rectangle_overlap (&strut->rect, rect))
+        continue;
+
+      if (direction == META_DIRECTION_HORIZONTAL)
+        {
+          if (strut->side == META_SIDE_LEFT)
+            {
+              int offset = BOX_RIGHT(strut->rect) - BOX_LEFT(*rect);
+              rect->x     += offset;
+              rect->width -= offset;
+            }
+          else if (strut->side == META_SIDE_RIGHT)
+            {
+              int offset = BOX_RIGHT (*rect) - BOX_LEFT(strut->rect);
+              rect->width -= offset;
+            }
+          /* else ignore the strut */
+        }
+      else /* direction == META_DIRECTION_VERTICAL */
+        {
+          if (strut->side == META_SIDE_TOP)
+            {
+              int offset = BOX_BOTTOM(strut->rect) - BOX_TOP(*rect);
+              rect->y      += offset;
+              rect->height -= offset;
+            }
+          else if (strut->side == META_SIDE_BOTTOM)
+            {
+              int offset = BOX_BOTTOM(*rect) - BOX_TOP(strut->rect);
+              rect->height -= offset;
+            }
+          /* else ignore the strut */
+        }
+    } /* end loop over struts */
+} /* end meta_rectangle_expand_to_avoiding_struts */
+
 void
 meta_rectangle_free_list_and_elements (GList *filled_list)
 {
@@ -737,39 +808,36 @@ meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
  /* First, find best rectangle from spanning_rects to which we can clamp
   * rect to fit into.
   */
-  temp = spanning_rects;
-  while (temp)
+  for (temp = spanning_rects; temp; temp = temp->next)
    {
-      int factor = 1;
      MetaRectangle *compare_rect = temp->data;
      int            maximal_overlap_amount_for_compare;
      
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_X) &&
          (compare_rect->x > rect->x || 
           compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
        
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_Y) &&
          (compare_rect->y > rect->y || 
           compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;

-      /* If compare can't hold the min_size window, set factor to 0 */
+      /* If compare can't hold the min_size window, skip this rectangle. */
      if (compare_rect->width  < min_size->width ||
          compare_rect->height < min_size->height)
-        factor = 0;
+        continue;

      /* Determine maximal overlap amount */
      maximal_overlap_amount_for_compare =
        MIN (rect->width,  compare_rect->width) *
        MIN (rect->height, compare_rect->height);
-      maximal_overlap_amount_for_compare *= factor;

      /* See if this is the best rect so far */
      if (maximal_overlap_amount_for_compare > best_overlap)
@@ -777,8 +845,6 @@ meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
          best_rect    = compare_rect;
          best_overlap = maximal_overlap_amount_for_compare;
        }
-
-      temp = temp->next;
    }

  /* Clamp rect appropriately */
@@ -811,34 +877,31 @@ meta_rectangle_clip_to_region (const GList         *spanning_rects,
  /* First, find best rectangle from spanning_rects to which we will clip
   * rect into.
   */
-  temp = spanning_rects;
-  while (temp)
+  for (temp = spanning_rects; temp; temp = temp->next)
    {
-      int factor = 1;
      MetaRectangle *compare_rect = temp->data;
      MetaRectangle  overlap;
      int            maximal_overlap_amount_for_compare;
-      
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+     
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip the rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_X) &&
          (compare_rect->x > rect->x || 
           compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
        
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip the rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_Y) &&
          (compare_rect->y > rect->y || 
           compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;

      /* Determine maximal overlap amount */
      meta_rectangle_intersect (rect, compare_rect, &overlap);
      maximal_overlap_amount_for_compare = meta_rectangle_area (&overlap);
-      maximal_overlap_amount_for_compare *= factor;

      /* See if this is the best rect so far */
      if (maximal_overlap_amount_for_compare > best_overlap)
@@ -846,8 +909,6 @@ meta_rectangle_clip_to_region (const GList         *spanning_rects,
          best_rect    = compare_rect;
          best_overlap = maximal_overlap_amount_for_compare;
        }
-
-      temp = temp->next;
    }

  /* Clip rect appropriately */
@@ -894,36 +955,35 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
  /* First, find best rectangle from spanning_rects to which we will shove
   * rect into.
   */
-  temp = spanning_rects;
-  while (temp)
+  
+  for (temp = spanning_rects; temp; temp = temp->next)
    {
-      int factor = 1;
      MetaRectangle *compare_rect = temp->data;
      int            maximal_overlap_amount_for_compare;
      int            dist_to_compare;
      
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_X) &&
          (compare_rect->x > rect->x || 
           compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
        
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
       */
      if ((fixed_directions & FIXED_DIRECTION_Y) &&
          (compare_rect->y > rect->y || 
           compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;

      /* Determine maximal overlap amount between rect & compare_rect */
      maximal_overlap_amount_for_compare =
        MIN (rect->width,  compare_rect->width) *
        MIN (rect->height, compare_rect->height);

-      /* Determine distance necessary to put rect into comapre_rect */
+      /* Determine distance necessary to put rect into compare_rect */
      dist_to_compare = 0;
      if (compare_rect->x > rect->x)
        dist_to_compare += compare_rect->x - rect->x;
@@ -936,13 +996,6 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
        dist_to_compare += (rect->y + rect->height) -
                           (compare_rect->y + compare_rect->height);

-      /* If we'd have to move in the wrong direction, disqualify compare_rect */
-      if (factor == 0)
-        {
-          maximal_overlap_amount_for_compare = 0;
-          dist_to_compare = G_MAXINT;
-        }
-
      /* See if this is the best rect so far */
      if ((maximal_overlap_amount_for_compare > best_overlap) ||
          (maximal_overlap_amount_for_compare == best_overlap &&
@@ -952,8 +1005,6 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
          best_overlap      = maximal_overlap_amount_for_compare;
          shortest_distance = dist_to_compare;
        }
-
-      temp = temp->next;
    }

  /* Shove rect appropriately */
@@ -1073,9 +1124,9 @@ meta_rectangle_edge_aligns (const MetaRectangle *rect, const MetaEdge *edge)
    case META_DIRECTION_BOTTOM:
      return BOX_LEFT (*rect)      <= BOX_RIGHT (edge->rect) &&
             BOX_LEFT (edge->rect) <= BOX_RIGHT (*rect);
+    default:
+      g_assert_not_reached ();
    }
-
-  g_assert_not_reached ();
 }

 static GList*
@@ -1159,27 +1210,27 @@ replace_rect_with_list (GList *old_element,
 }

 /* Make a copy of the strut list, make sure that copy only contains parts
- * of the old_struts that intersect with the rection rect, and then do some
+ * of the old_struts that intersect with the region rect, and then do some
 * magic to make all the new struts disjoint (okay, we we break up struts
 * that aren't disjoint in a way that the overlapping part is only included
 * once, so it's not really magic...).
 */
 static GList*
-get_disjoint_strut_list_in_region (const GSList        *old_struts,
-                                   const MetaRectangle *region)
+get_disjoint_strut_rect_list_in_region (const GSList        *old_struts,
+                                        const MetaRectangle *region)
 {
-  GList *struts;
+  GList *strut_rects;
  GList *tmp;

  /* First, copy the list */
-  struts = NULL;
+  strut_rects = NULL;
  while (old_struts)
    {
-      MetaRectangle *cur = old_struts->data;
+      MetaRectangle *cur = &((MetaStrut*)old_struts->data)->rect;
      MetaRectangle *copy = g_new (MetaRectangle, 1);
      *copy = *cur;
      if (meta_rectangle_intersect (copy, region, copy))
-        struts = g_list_prepend (struts, copy);
+        strut_rects = g_list_prepend (strut_rects, copy);
      else
        g_free (copy);

@@ -1189,7 +1240,7 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
  /* Now, loop over the list and check for intersections, fixing things up
   * where they do intersect.
   */
-  tmp = struts;
+  tmp = strut_rects;
  while (tmp)
    {
      GList *compare;
@@ -1216,10 +1267,10 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
              cur_leftover = g_list_prepend (cur_leftover, overlap_allocated);

              /* Fix up tmp, compare, and cur -- maybe struts too */
-              if (struts == tmp)
+              if (strut_rects == tmp)
                {
-                  struts = replace_rect_with_list (tmp, cur_leftover);
-                  tmp = struts;
+                  strut_rects = replace_rect_with_list (tmp, cur_leftover);
+                  tmp = strut_rects;
                }
              else
                tmp   = replace_rect_with_list (tmp,     cur_leftover);
@@ -1237,7 +1288,7 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
      tmp = tmp->next;
    }

-  return struts;
+  return strut_rects;
 }

 gint
@@ -1345,7 +1396,7 @@ rectangle_and_edge_intersection (const MetaRectangle *rect,
  /* Find out if the intersection is empty; have to do it this way since
   * edges have a thickness of 0
   */
-  if ((result->width < 0 || result->height < 0) ||
+  if ((result->width <  0 || result->height <  0) ||
      (result->width == 0 && result->height == 0))
    {
      result->width = 0;
@@ -1395,6 +1446,8 @@ rectangle_and_edge_intersection (const MetaRectangle *rect,
          else
            *handle_type = 0;
          break;
+        default:
+          g_assert_not_reached ();
        }
    }
  return intersect;
@@ -1501,23 +1554,25 @@ split_edge (GList *cur_list,
          cur_list = g_list_prepend (cur_list, temp_edge);
        }
      break;
+    default:
+      g_assert_not_reached ();
    }

  return cur_list;
 }

 /* Split up edge and remove preliminary edges from strut_edges depending on
- * if and how strut and edge intersect.
+ * if and how rect and edge intersect.
 */
 static void
-fix_up_edges (MetaRectangle *strut,        MetaEdge *edge, 
+fix_up_edges (MetaRectangle *rect,         MetaEdge *edge, 
              GList         **strut_edges, GList    **edge_splits,
              gboolean      *edge_needs_removal)
 {
  MetaEdge overlap;
  int      handle_type;

-  if (!rectangle_and_edge_intersection (strut, edge, &overlap, &handle_type))
+  if (!rectangle_and_edge_intersection (rect, edge, &overlap, &handle_type))
    return;

  if (handle_type == 0 || handle_type == 1)
@@ -1626,9 +1681,9 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
                                    const GSList        *all_struts)
 {
  GList        *ret;
-  GList        *fixed_struts;
+  GList        *fixed_strut_rects;
  GList        *edge_iter; 
-  const GList  *strut_iter;
+  const GList  *strut_rect_iter;

  /* The algorithm is basically as follows:
   *   Make sure the struts are disjoint
@@ -1646,18 +1701,19 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
   */

  /* Make sure the struts are disjoint */
-  fixed_struts = get_disjoint_strut_list_in_region (all_struts, basic_rect);
+  fixed_strut_rects =
+    get_disjoint_strut_rect_list_in_region (all_struts, basic_rect);

  /* Start off the list with the edges of basic_rect */
  ret = add_edges (NULL, basic_rect, TRUE);

-  strut_iter = fixed_struts;
-  while (strut_iter)
+  strut_rect_iter = fixed_strut_rects;
+  while (strut_rect_iter)
    {
-      MetaRectangle *strut = (MetaRectangle*) strut_iter->data;
+      MetaRectangle *strut_rect = (MetaRectangle*) strut_rect_iter->data;

      /* Get the new possible edges we may need to add from the strut */
-      GList *new_strut_edges = add_edges (NULL, strut, FALSE);
+      GList *new_strut_edges = add_edges (NULL, strut_rect, FALSE);

      edge_iter = ret;
      while (edge_iter)
@@ -1666,7 +1722,7 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
          GList *splits_of_cur_edge = NULL;
          gboolean edge_needs_removal = FALSE;

-          fix_up_edges (strut,            cur_edge, 
+          fix_up_edges (strut_rect,       cur_edge, 
                        &new_strut_edges, &splits_of_cur_edge,
                        &edge_needs_removal);

@@ -1690,14 +1746,14 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
        }

      ret = g_list_concat (new_strut_edges, ret);
-      strut_iter = strut_iter->next;
+      strut_rect_iter = strut_rect_iter->next;
    }

  /* Sort the list */
  ret = g_list_sort (ret, meta_rectangle_edge_cmp);

  /* Free the fixed struts list */
-  meta_rectangle_free_list_and_elements (fixed_struts);
+  meta_rectangle_free_list_and_elements (fixed_strut_rects);

  return ret;
 }
@@ -1714,6 +1770,7 @@ meta_rectangle_find_nonintersected_xinerama_edges (
   */
  GList *ret;
  const GList  *cur;
+  GSList *temp_rects;

  /* Initialize the return list to be empty */
  ret = NULL;
@@ -1821,8 +1878,13 @@ meta_rectangle_find_nonintersected_xinerama_edges (
      cur = cur->next;
    }

+  temp_rects = NULL;
+  for (; all_struts; all_struts = all_struts->next)
+    temp_rects = g_slist_prepend (temp_rects,
+                                  &((MetaStrut*)all_struts->data)->rect);
  ret = meta_rectangle_remove_intersections_with_boxes_from_edges (ret, 
-                                                                   all_struts);
+                                                                   temp_rects);
+  g_slist_free (temp_rects);

  /* Sort the list */
  ret = g_list_sort (ret, meta_rectangle_edge_cmp);
--- a/src/boxes.h
+++ b/src/boxes.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Simple box operations */

 /* 
@@ -26,7 +28,6 @@
 #include "common.h"

 typedef struct _MetaRectangle MetaRectangle;
-
 struct _MetaRectangle
 {
  int x;
@@ -35,6 +36,13 @@ struct _MetaRectangle
  int height;
 };

+typedef struct _MetaStrut MetaStrut;
+struct _MetaStrut
+{
+  MetaRectangle rect;
+  MetaDirection side;
+};
+
 #define BOX_LEFT(box)    ((box).x)                /* Leftmost pixel of rect */
 #define BOX_RIGHT(box)   ((box).x + (box).width)  /* One pixel past right   */
 #define BOX_TOP(box)     ((box).y)                /* Topmost pixel of rect  */
@@ -42,8 +50,9 @@ struct _MetaRectangle

 typedef enum
 {
-  FIXED_DIRECTION_X = 1 << 0,
-  FIXED_DIRECTION_Y = 1 << 1,
+  FIXED_DIRECTION_NONE = 0,
+  FIXED_DIRECTION_X    = 1 << 0,
+  FIXED_DIRECTION_Y    = 1 << 1,
 } FixedDirections;

 typedef enum
@@ -164,6 +173,16 @@ GList*   meta_rectangle_expand_region_conditionally (
                                         const int            min_x,
                                         const int            min_y);

+/* Expand rect in direction to the size of expand_to, and then clip out any
+ * overlapping struts oriented orthognal to the expansion direction.  (Think
+ * horizontal or vertical maximization)
+ */
+void     meta_rectangle_expand_to_avoiding_struts (
+                                         MetaRectangle       *rect,
+                                         const MetaRectangle *expand_to,
+                                         const MetaDirection  direction,
+                                         const GSList        *all_struts);
+
 /* Free the list created by
 *   meta_rectangle_get_minimal_spanning_set_for_region()
 * or
--- a/src/c-screen.c
+++ b/src/c-screen.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* 
 * Copyright (C) 2006 Red Hat, Inc.
 * 
@@ -336,8 +338,6 @@ meta_comp_screen_redirect (MetaCompScreen *info)
  
  info->magnifier = cm_magnifier_new (CM_NODE (info->stacker), &source, &target);
  
-  g_object_unref (info->stacker);
-  
  if (g_getenv ("USE_MAGNIFIER"))
    cm_magnifier_set_active (info->magnifier, TRUE);
  else
--- a/src/c-screen.h
+++ b/src/c-screen.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 #include "screen.h"
 #include "c-window.h"

--- a/src/c-window.c
+++ b/src/c-window.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* 
 * Copyright (C) 2006 Red Hat, Inc.
 * 
@@ -34,7 +36,8 @@
 #include "c-window.h"
 #include "window.h"
 #include "frame.h"
-#include "spring-model.h"
+#include "compositor.h"
+#include "workspace.h"

 typedef struct UnminimizeInfo UnminimizeInfo;

@@ -1184,10 +1187,6 @@ typedef struct
    gdouble	    last_time;
 } FocusInfo;

-/* XXX HATE */
-extern void get_patch_points (Model *model, CmPoint points[4][4]);
-extern void compute_window_rect (MetaWindow *window, MetaRectangle *rect);
-
 static gboolean
 update_focus (gpointer data)
 {
--- a/src/c-window.h
+++ b/src/c-window.h
@@ -1,3 +1,4 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /* 
 * Copyright (C) 2006 Red Hat, Inc.
 * 
@@ -27,7 +28,7 @@
 typedef struct _MetaCompWindow MetaCompWindow;

 typedef void (* MetaCompWindowDestroy) (MetaCompWindow *window,
-					gpointer        closure);
+                                        gpointer        closure);

 MetaCompWindow *meta_comp_window_new (MetaScreen *screen,
 				      WsDrawable *drawable,
--- a/src/colors.c
+++ b/src/colors.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity RGB color stuff */

 /* 
--- a/src/colors.h
+++ b/src/colors.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity RGB color stuff */

 /* 
--- a/src/common.h
+++ b/src/common.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity common types shared by core.h and ui.h */

 /* 
@@ -44,7 +46,8 @@ typedef enum
  META_FRAME_ALLOWS_SHADE             = 1 << 10,
  META_FRAME_ALLOWS_MOVE              = 1 << 11,
  META_FRAME_FULLSCREEN               = 1 << 12,
-  META_FRAME_IS_FLASHING              = 1 << 13
+  META_FRAME_IS_FLASHING              = 1 << 13,
+  META_FRAME_ABOVE                    = 1 << 14
 } MetaFrameFlags;

 typedef enum
@@ -61,12 +64,11 @@ typedef enum
  META_MENU_OP_MOVE        = 1 << 9,
  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,
-  META_MENU_OP_RECOVER     = 1 << 17
+  META_MENU_OP_MOVE_LEFT   = 1 << 12,
+  META_MENU_OP_MOVE_RIGHT  = 1 << 13,
+  META_MENU_OP_MOVE_UP     = 1 << 14,
+  META_MENU_OP_MOVE_DOWN   = 1 << 15,
+  META_MENU_OP_RECOVER     = 1 << 16
 } MetaMenuOp;

 typedef struct _MetaWindowMenu MetaWindowMenu;
@@ -129,7 +131,13 @@ typedef enum
  META_GRAB_OP_CLICKING_MAXIMIZE,
  META_GRAB_OP_CLICKING_UNMAXIMIZE,
  META_GRAB_OP_CLICKING_DELETE,
-  META_GRAB_OP_CLICKING_MENU
+  META_GRAB_OP_CLICKING_MENU,
+  META_GRAB_OP_CLICKING_SHADE,
+  META_GRAB_OP_CLICKING_UNSHADE,
+  META_GRAB_OP_CLICKING_ABOVE,
+  META_GRAB_OP_CLICKING_UNABOVE,
+  META_GRAB_OP_CLICKING_STICK,
+  META_GRAB_OP_CLICKING_UNSTICK
 } MetaGrabOp;

 typedef enum
@@ -163,12 +171,14 @@ typedef enum

 typedef enum
 {
-  META_ACTION_DOUBLE_CLICK_TITLEBAR_TOGGLE_SHADE,
-  META_ACTION_DOUBLE_CLICK_TITLEBAR_TOGGLE_MAXIMIZE,
-  META_ACTION_DOUBLE_CLICK_TITLEBAR_MINIMIZE,
-  META_ACTION_DOUBLE_CLICK_TITLEBAR_NONE,
-  META_ACTION_DOUBLE_CLICK_TITLEBAR_LAST
-} MetaActionDoubleClickTitlebar;
+  META_ACTION_TITLEBAR_TOGGLE_SHADE,
+  META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE,
+  META_ACTION_TITLEBAR_MINIMIZE,
+  META_ACTION_TITLEBAR_NONE,
+  META_ACTION_TITLEBAR_LOWER,
+  META_ACTION_TITLEBAR_MENU,
+  META_ACTION_TITLEBAR_LAST
+} MetaActionTitlebar;

 typedef enum
 {
@@ -206,12 +216,24 @@ typedef enum
 */
 typedef enum
 {
-  META_DIRECTION_LEFT      = 1 << 0,
-  META_DIRECTION_RIGHT     = 1 << 1,
-  META_DIRECTION_TOP       = 1 << 2,
-  META_DIRECTION_BOTTOM    = 1 << 3,
-  META_DIRECTION_UP        = 1 << 2, /* Alternate name for TOP */
-  META_DIRECTION_DOWN      = 1 << 3  /* Alternate name for BOTTOM */
+  META_DIRECTION_LEFT       = 1 << 0,
+  META_DIRECTION_RIGHT      = 1 << 1,
+  META_DIRECTION_TOP        = 1 << 2,
+  META_DIRECTION_BOTTOM     = 1 << 3,
+
+  /* Some aliases for making code more readable for various circumstances. */
+  META_DIRECTION_UP         = META_DIRECTION_TOP,
+  META_DIRECTION_DOWN       = META_DIRECTION_BOTTOM,
+
+  /* A few more definitions using aliases */
+  META_DIRECTION_HORIZONTAL = META_DIRECTION_LEFT | META_DIRECTION_RIGHT,
+  META_DIRECTION_VERTICAL   = META_DIRECTION_UP   | META_DIRECTION_DOWN,
+
+  /* And a few more aliases */
+  META_SIDE_LEFT            = META_DIRECTION_LEFT,
+  META_SIDE_RIGHT           = META_DIRECTION_RIGHT,
+  META_SIDE_TOP             = META_DIRECTION_TOP,
+  META_SIDE_BOTTOM          = META_DIRECTION_BOTTOM
 } MetaDirection;

 /* Function a window button can have.  Note, you can't add stuff here
@@ -224,6 +246,12 @@ typedef enum
  META_BUTTON_FUNCTION_MINIMIZE,
  META_BUTTON_FUNCTION_MAXIMIZE,
  META_BUTTON_FUNCTION_CLOSE,
+  META_BUTTON_FUNCTION_SHADE,
+  META_BUTTON_FUNCTION_ABOVE,
+  META_BUTTON_FUNCTION_STICK,
+  META_BUTTON_FUNCTION_UNSHADE,
+  META_BUTTON_FUNCTION_UNABOVE,
+  META_BUTTON_FUNCTION_UNSTICK,
  META_BUTTON_FUNCTION_LAST
 } MetaButtonFunction;

--- a/src/compositor.c
+++ b/src/compositor.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* 
 * Copyright (C) 2003, 2004, 2005, 2006 Red Hat, Inc.
 * Copyright (C) 2003 Keith Packard
@@ -47,7 +49,6 @@
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrender.h>
-#include "spring-model.h"
 #include <cm/state.h>

 #include "effects.h"
@@ -111,6 +112,10 @@ get_xid (MetaWindow *window)

 #ifdef HAVE_COMPOSITE_EXTENSIONS

+/* This is called by Metacity's effect code when an effect needs to happen.
+ * In compositor-less Metacity, this includes things like the wireframe
+ * zoom when a window is minimised. We have a rather larger box of tricks.
+ */
 static void
 do_effect (MetaEffect *effect,
 	   gpointer data)
@@ -119,6 +124,15 @@ do_effect (MetaEffect *effect,
    MetaCompWindow *window;

    screen = meta_comp_screen_get_by_xwindow (get_xid (effect->window));
+
+    if (!screen)
+      {
+        /* sanity check: if no screen is found, bail */
+        meta_warning ("No screen found for %s (%ld); aborting effect.\n",
+            effect->window->desc, get_xid (effect->window));
+        return;
+      }
+
    window = meta_comp_screen_lookup_window (screen, get_xid (effect->window));
    
    switch (effect->type)
@@ -156,6 +170,9 @@ do_effect (MetaEffect *effect,

 #endif /* HAVE_COMPOSITE_EXTENSIONS */

+/* Constructs a new compositor. The rest of Metacity knows whether the
+ * compositor is turned on by whether this function returns NULL or not.
+ */
 MetaCompositor *
 meta_compositor_new (MetaDisplay *display)
 {
@@ -200,7 +217,11 @@ meta_compositor_new (MetaDisplay *display)
  
  compositor->enabled = TRUE;
  
-  meta_push_effect_handler (do_effect, compositor);
+  /* Compositor without bling is the default, but leave the bling
+   * accessible for now.
+   */
+  if (getenv("METACITY_BLING")!=NULL)
+    meta_push_effect_handler (do_effect, compositor);
  
  return compositor;
 #else /* HAVE_COMPOSITE_EXTENSIONS */
@@ -208,6 +229,7 @@ meta_compositor_new (MetaDisplay *display)
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 }

+#if 0
 void
 meta_compositor_set_debug_updates (MetaCompositor *compositor,
 				   gboolean	   debug_updates)
@@ -216,6 +238,7 @@ meta_compositor_set_debug_updates (MetaCompositor *compositor,
  compositor->debug_updates = !!debug_updates;
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 }
+#endif /* 0 */

 #ifdef HAVE_COMPOSITE_EXTENSIONS
 static void
@@ -244,8 +267,29 @@ meta_compositor_unref (MetaCompositor *compositor)
 #endif /* HAVE_COMPOSITE_EXTENSIONS */
 }

-#ifdef HAVE_COMPOSITE_EXTENSIONS
+/****************************************************************************
+ *
+ *                             HANDLING X EVENTS
+ *
+ * Here are several process_* functions, which are all called by
+ * meta_compositor_process_event at the bottom.
+ *
+ ****************************************************************************/

+#ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the CirculateNotify XEvent.
+ */
+static void
+process_circulate_notify (MetaCompositor *compositor,
+                          XCirculateEvent* event)
+{
+  /* FIXME: Do something here. */
+}
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
+ 
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the ConfigureNotify XEvent.
+ */
 static void
 process_configure_notify (MetaCompositor  *compositor,
                          XConfigureEvent *event)
@@ -279,6 +323,9 @@ process_configure_notify (MetaCompositor  *compositor,


 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the Expose XEvent.
+ * XXX FIXME: This looks like it quite urgently needs looking into. --tthurman
+ */
 static void
 process_expose (MetaCompositor     *compositor,
                XExposeEvent       *event)
@@ -290,6 +337,10 @@ process_expose (MetaCompositor     *compositor,

 #ifdef HAVE_COMPOSITE_EXTENSIONS

+#if 0
+
+/* Apparently never used. */
+
 typedef struct
 {
  CmDrawableNode *node;
@@ -329,9 +380,12 @@ fade_out (gpointer data)
      return TRUE;
    }
 }
+#endif /* 0 */
 #endif

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the MapNotify XEvent.
+ */
 static void
 process_map (MetaCompositor     *compositor,
             XMapEvent          *event)
@@ -345,13 +399,13 @@ process_map (MetaCompositor     *compositor,
  /* See if window was mapped as child of root */
  screen = meta_display_screen_for_root (compositor->meta_display,
 					 event->event);
-  
+
  if (screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
 		  "MapNotify received on non-root 0x%lx for 0x%lx\n",
 		  event->event, event->window);
-      
+
      /* MapNotify wasn't for a child of the root */
      return; 
    }
@@ -363,6 +417,8 @@ process_map (MetaCompositor     *compositor,
 #endif /* HAVE_COMPOSITE_EXTENSIONS */

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the UnmapNotify XEvent.
+ */
 static void
 process_unmap (MetaCompositor     *compositor,
               XUnmapEvent        *event)
@@ -389,6 +445,8 @@ process_unmap (MetaCompositor     *compositor,
 #endif /* HAVE_COMPOSITE_EXTENSIONS */

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the CreateNotify XEvent.
+ */
 static void
 process_create (MetaCompositor     *compositor,
                XCreateWindowEvent *event)
@@ -430,6 +488,8 @@ process_create (MetaCompositor     *compositor,
 #endif /* HAVE_COMPOSITE_EXTENSIONS */

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the DestroyNotify XEvent.
+ */
 static void
 process_destroy (MetaCompositor      *compositor,
                 XDestroyWindowEvent *event)
@@ -463,6 +523,8 @@ process_destroy (MetaCompositor      *compositor,


 #ifdef HAVE_COMPOSITE_EXTENSIONS
+/* Handles the ReparentNotify XEvent.
+ */
 static void
 process_reparent (MetaCompositor      *compositor,
                  XReparentEvent      *event)
@@ -505,6 +567,9 @@ process_reparent (MetaCompositor      *compositor,

 #endif /* HAVE_COMPOSITE_EXTENSIONS */

+/* If the compositor is enabled, this function gets called with any XEvent
+ * in case we want to deal with it specially.
+ */
 void
 meta_compositor_process_event (MetaCompositor *compositor,
                               XEvent         *event,
@@ -514,9 +579,12 @@ meta_compositor_process_event (MetaCompositor *compositor,
  if (!compositor->enabled)
    return; /* no extension */
  
-  /* FIXME support CirculateNotify */
-  
-  if (event->type == ConfigureNotify)
+  if (event->type == CirculateNotify)
+    {
+      process_circulate_notify (compositor,
+                                (XCirculateEvent*) event);
+    }
+  else if (event->type == ConfigureNotify)
    {
      process_configure_notify (compositor,
 				(XConfigureEvent*) event);
@@ -556,10 +624,13 @@ meta_compositor_process_event (MetaCompositor *compositor,
 }

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+#if 0
 static GTimer *timer;
+#endif /* 0 */
 #endif /* HAVE_COMPOSITE_EXTENSIONS */

 #ifdef HAVE_COMPOSITE_EXTENSIONS
+#if 0
 static void
 dump_stacking_order (GList *nodes)
 {
@@ -573,6 +644,7 @@ dump_stacking_order (GList *nodes)
    }
  g_print ("\n");
 }
+#endif /* 0 */
 #endif

 /* This is called when metacity does its XQueryTree() on startup
@@ -759,7 +831,7 @@ struct MoveInfo

 void
 get_patch_points (Model   *model,
-		  CmPoint  points[4][4])
+		  CmPoint points[4][4])
 {
  int i, j;
  
--- a/src/compositor.h
+++ b/src/compositor.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity compositing manager */

 /* 
@@ -24,6 +26,13 @@

 #include "util.h"
 #include "display.h"
+#include "spring-model.h"
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#include "cm/deform.h"
+/* FIXME: Needs namespacing. */
+void get_patch_points (Model *model, CmPoint points[4][4]);
+#endif

 typedef void (* MetaAnimationFinishedFunc) (gpointer data);

--- a/src/constraints.c
+++ b/src/constraints.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity size/position constraints */

 /*
@@ -348,7 +350,7 @@ setup_constraint_info (ConstraintInfo      *info,
  else if (flags & META_IS_RESIZE_ACTION)
    info->action_type = ACTION_RESIZE;
  else if (flags & META_IS_MOVE_ACTION)
-    info->action_type = ACTION_MOVE_AND_RESIZE;
+    info->action_type = ACTION_MOVE;
  else
    g_error ("BAD, BAD developer!  No treat for you!  (Fix your calls to "
             "meta_window_move_resize_internal()).\n");
@@ -363,7 +365,7 @@ setup_constraint_info (ConstraintInfo      *info,
   * and (b) ignored it for aspect ratio windows -- at least in those
   * cases where both directions do actually change size.
   */
-  info->fixed_directions = 0;
+  info->fixed_directions = FIXED_DIRECTION_NONE;
  /* If x directions don't change but either y direction does */
  if ( orig->x == new->x && orig->x + orig->width  == new->x + new->width   &&
      (orig->y != new->y || orig->y + orig->height != new->y + new->height))
@@ -383,7 +385,7 @@ setup_constraint_info (ConstraintInfo      *info,
   * aren't explicit user interaction, though, so just clear it out.
   */
  if (!info->is_user_action)
-    info->fixed_directions = 0;
+    info->fixed_directions = FIXED_DIRECTION_NONE;

  xinerama_info =
    meta_screen_get_xinerama_for_rect (window->screen, &info->current);
@@ -439,7 +441,7 @@ setup_constraint_info (ConstraintInfo      *info,
                "Freakin' Invalid Stupid",
              (info->is_user_action) ? "true" : "false",
              meta_gravity_to_string (info->resize_gravity),
-              (info->fixed_directions == 0) ? "None" :
+              (info->fixed_directions == FIXED_DIRECTION_NONE) ? "None" :
                (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
                (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
                "Freakin' Invalid Stupid",
@@ -458,13 +460,15 @@ place_window_if_needed(MetaWindow     *window,

  /* Do placement if any, so we go ahead and apply position
   * constraints in a move-only context. Don't place
-   * maximized/fullscreen windows until they are unmaximized
-   * and unfullscreened
+   * maximized/minimized/fullscreen windows until they are
+   * unmaximized, unminimized and unfullscreened.
   */
  did_placement = FALSE;
  if (!window->placed &&
      window->calc_placement &&
-      !META_WINDOW_MAXIMIZED (window) &&
+      !(window->maximized_horizontally ||
+        window->maximized_vertically) &&
+      !window->minimized &&
      !window->fullscreen)
    {
      MetaRectangle placed_rect = info->orig;
@@ -496,56 +500,50 @@ place_window_if_needed(MetaWindow     *window,
      /* Since we just barely placed the window, there's no reason to
       * consider any of the directions fixed.
       */
-      info->fixed_directions = 0;
+      info->fixed_directions = FIXED_DIRECTION_NONE;
    }

-  if ((window->maximize_horizontally_after_placement ||
-       window->maximize_vertically_after_placement) &&
-      (window->placed || did_placement))
+  if (window->placed || did_placement)
    {
-      /* define a sane saved_rect so that the user can unmaximize to
-       * something reasonable.
-       */
-      if (info->current.width >= info->work_area_xinerama.width)
-        {
-          info->current.width = .75 * info->work_area_xinerama.width;
-          info->current.x = info->work_area_xinerama.x +
-                   .125 * info->work_area_xinerama.width;
-        }
-      if (info->current.height >= info->work_area_xinerama.height)
-        {
-          info->current.height = .75 * info->work_area_xinerama.height;
-          info->current.y = info->work_area_xinerama.y +
-                   .083 * info->work_area_xinerama.height;
-        }
-
-      if (window->maximize_horizontally_after_placement &&
+      if (window->maximize_horizontally_after_placement ||
          window->maximize_vertically_after_placement)
-        meta_window_maximize_internal (window,   
-                                       META_MAXIMIZE_HORIZONTAL |
-                                       META_MAXIMIZE_VERTICAL,
-                                       &info->current);
-      else if (window->maximize_horizontally_after_placement)
        {
-          info->current.x = info->work_area_xinerama.x
-            + info->fgeom->left_width;
-          info->current.width = info->work_area_xinerama.width
-            - info->fgeom->left_width - info->fgeom->right_width;
+          /* define a sane saved_rect so that the user can unmaximize to
+           * something reasonable.
+           */
+          if (info->current.width >= info->work_area_xinerama.width)
+            {
+              info->current.width = .75 * info->work_area_xinerama.width;
+              info->current.x = info->work_area_xinerama.x +
+                       .125 * info->work_area_xinerama.width;
+            }
+          if (info->current.height >= info->work_area_xinerama.height)
+            {
+              info->current.height = .75 * info->work_area_xinerama.height;
+              info->current.y = info->work_area_xinerama.y +
+                       .083 * info->work_area_xinerama.height;
+            }
+
+          if (window->maximize_horizontally_after_placement ||
+              window->maximize_vertically_after_placement)
+            meta_window_maximize_internal (window,   
+                (window->maximize_horizontally_after_placement ?
+                 META_MAXIMIZE_HORIZONTAL : 0 ) |
+                (window->maximize_vertically_after_placement ?
+                 META_MAXIMIZE_VERTICAL : 0), &info->current);
+
+          /* maximization may have changed frame geometry */
+          if (window->frame && !window->fullscreen)
+            meta_frame_calc_geometry (window->frame, info->fgeom);
+
+          window->maximize_horizontally_after_placement = FALSE;
+          window->maximize_vertically_after_placement = FALSE;
        }
-      else if (window->maximize_vertically_after_placement);
+      if (window->minimize_after_placement)
        {
-          info->current.y = info->work_area_xinerama.y
-            + info->fgeom->top_height;
-          info->current.height = info->work_area_xinerama.height
-            - info->fgeom->top_height - info->fgeom->bottom_height;
+          meta_window_minimize (window);
+          window->minimize_after_placement = FALSE;
        }
-
-      /* maximization may have changed frame geometry */
-      if (window->frame && !window->fullscreen)
-        meta_frame_calc_geometry (window->frame, info->fgeom);
-
-      window->maximize_horizontally_after_placement = FALSE;
-      window->maximize_vertically_after_placement = FALSE;
    }
 }

@@ -693,8 +691,9 @@ constrain_maximization (MetaWindow         *window,
                        ConstraintPriority  priority,
                        gboolean            check_only)
 {
-  MetaRectangle min_size, max_size, work_area;
-  gboolean hminbad, vminbad, hmaxbad, vmaxbad;
+  MetaRectangle target_size;
+  MetaRectangle min_size, max_size;
+  gboolean hminbad, vminbad;
  gboolean horiz_equal, vert_equal;
  gboolean constraint_already_satisfied;

@@ -705,22 +704,51 @@ constrain_maximization (MetaWindow         *window,
  if (!window->maximized_horizontally && !window->maximized_vertically)
    return TRUE;

-  work_area = info->work_area_xinerama;
-  unextend_by_frame (&work_area, info->fgeom);
-  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  /* Calculate target_size = maximized size of (window + frame) */
+  if (window->maximized_horizontally && window->maximized_vertically)
+    target_size = info->work_area_xinerama;
+  else
+    {
+      /* Amount of maximization possible in a single direction depends
+       * on which struts could occlude the window given its current
+       * position.  For example, a vertical partial strut on the right
+       * is only relevant for a horizontally maximized window when the
+       * window is at a vertical position where it could be occluded
+       * by that partial strut.
+       */
+      MetaDirection  direction;
+      GSList        *active_workspace_struts;

-  hminbad = work_area.width < min_size.width && window->maximized_horizontally;
-  vminbad = work_area.height < min_size.height && window->maximized_vertically;
-  hmaxbad = work_area.width > max_size.width && window->maximized_horizontally;
-  vmaxbad = work_area.height > max_size.height && window->maximized_vertically;
-  if (hminbad || vminbad || hmaxbad || vmaxbad)
+      if (window->maximized_horizontally)
+        direction = META_DIRECTION_HORIZONTAL;
+      else
+        direction = META_DIRECTION_VERTICAL;
+      active_workspace_struts = window->screen->active_workspace->all_struts;
+
+      target_size = info->current;
+      extend_by_frame (&target_size, info->fgeom);
+      meta_rectangle_expand_to_avoiding_struts (&target_size,
+                                                &info->entire_xinerama,
+                                                direction,
+                                                active_workspace_struts);
+   }
+  /* Now make target_size = maximized size of client window */
+  unextend_by_frame (&target_size, info->fgeom);
+
+  /* Check min size constraints; max size constraints are ignored for maximized
+   * windows, as per bug 327543.
+   */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
+  vminbad = target_size.height < min_size.height && window->maximized_vertically;
+  if (hminbad || vminbad)
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is */
-  horiz_equal = work_area.x      == info->current.x &&
-                work_area.width  == info->current.width;
-  vert_equal  = work_area.y      == info->current.y &&
-                work_area.height == info->current.height;
+  horiz_equal = target_size.x      == info->current.x &&
+                target_size.width  == info->current.width;
+  vert_equal  = target_size.y      == info->current.y &&
+                target_size.height == info->current.height;
  constraint_already_satisfied =
    (horiz_equal || !window->maximized_horizontally) &&
    (vert_equal  || !window->maximized_vertically);
@@ -730,13 +758,13 @@ constrain_maximization (MetaWindow         *window,
  /*** Enforce constraint ***/
  if (window->maximized_horizontally)
    {
-      info->current.x      = work_area.x;
-      info->current.width  = work_area.width;
+      info->current.x      = target_size.x;
+      info->current.width  = target_size.width;
    }
  if (window->maximized_vertically)
    {
-      info->current.y      = work_area.y;
-      info->current.height = work_area.height;
+      info->current.y      = target_size.y;
+      info->current.height = target_size.height;
    }
  return TRUE;
 }
@@ -781,6 +809,7 @@ constrain_size_increments (MetaWindow         *window,
                           gboolean            check_only)
 {
  int bh, hi, bw, wi, extra_height, extra_width;
+  int new_width, new_height;
  gboolean constraint_already_satisfied;

  if (priority > PRIORITY_SIZE_HINTS_INCREMENTS)
@@ -798,10 +827,12 @@ constrain_size_increments (MetaWindow         *window,
  wi = window->size_hints.width_inc;
  extra_height = (info->current.height - bh) % hi;
  extra_width  = (info->current.width  - bw) % wi;
+  /* ignore size increments for maximized windows */
  if (window->maximized_horizontally)
    extra_width *= 0;
  if (window->maximized_vertically)
    extra_height *= 0;
+  /* constraint is satisfied iff there is no extra height or width */
  constraint_already_satisfied = 
    (extra_height == 0 && extra_width == 0);

@@ -809,12 +840,24 @@ constrain_size_increments (MetaWindow         *window,
    return constraint_already_satisfied;

  /*** Enforce constraint ***/
-  /* Shrink to base + N * inc */
+  new_width  = info->current.width  - extra_width;
+  new_height = info->current.height - extra_height;
+
+  /* Adjusting down instead of up (as done in the above two lines) may
+   * violate minimum size constraints; fix the adjustment if this
+   * happens.
+   */
+  if (new_width  < window->size_hints.min_width)
+    new_width  += ((window->size_hints.min_width  - new_width)/wi  + 1)*wi;
+  if (new_height < window->size_hints.min_height)
+    new_height += ((window->size_hints.min_height - new_height)/hi + 1)*hi;
+
+  /* Resize to the new size */
  meta_rectangle_resize_with_gravity (&info->orig,
                                      &info->current, 
                                      info->resize_gravity,
-                                      info->current.width - extra_width,
-                                      info->current.height - extra_height);
+                                      new_width,
+                                      new_height);
  return TRUE;
 }

@@ -841,8 +884,13 @@ constrain_size_limits (MetaWindow         *window,

  /* Determine whether constraint is already satisfied; exit if it is */
  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
-  too_big = !meta_rectangle_could_fit_rect (&info->current, &min_size);
-  too_small = !meta_rectangle_could_fit_rect (&max_size, &info->current);
+  /* We ignore max-size limits for maximized windows; see #327543 */
+  if (window->maximized_horizontally)
+    max_size.width = MAX (max_size.width, info->current.width);
+  if (window->maximized_vertically)
+    max_size.height = MAX (max_size.height, info->current.height);
+  too_small = !meta_rectangle_could_fit_rect (&info->current, &min_size);
+  too_big   = !meta_rectangle_could_fit_rect (&max_size, &info->current);
  constraint_already_satisfied = !too_big && !too_small;
  if (check_only || constraint_already_satisfied)
    return constraint_already_satisfied;
@@ -993,13 +1041,15 @@ do_screen_and_xinerama_relative_constraints (
  gboolean exit_early = FALSE, constraint_satisfied;
  MetaRectangle how_far_it_can_be_smushed, min_size, max_size;

+#ifdef WITH_VERBOSE_MODE
  /* First, log some debugging information */
  char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
-  (void) spanning_region;  /* Avoid stupid & incorrect compiler warnings... */
+
  meta_topic (META_DEBUG_GEOMETRY,
              "screen/xinerama constraint; region_spanning_rectangles: %s\n",
              meta_rectangle_region_to_string (region_spanning_rectangles, ", ", 
                                               spanning_region));
+#endif

  /* Determine whether constraint applies; exit if it doesn't */
  how_far_it_can_be_smushed = info->current;
@@ -1124,13 +1174,10 @@ constrain_titlebar_visible (MetaWindow         *window,
    return TRUE;

  /* Allow the titlebar beyond the top of the screen only if the user wasn't
-   * clicking on the titlebar to start the move.
-   * FIXME: This is kind of a hack; nearly as ugly as the old infinite edge
-   * resistance.
+   * clicking on the frame to start the move.
   */
  unconstrained_user_action =
-    info->is_user_action &&
-    window->display->grab_anchor_root_y >= window->display->grab_initial_window_pos.y;
+    info->is_user_action && !window->display->grab_frame_action;

  /* Exit early if we know the constraint won't apply--note that this constraint
   * is only meant for normal windows (e.g. we don't want docks to be shoved 
--- a/src/constraints.h
+++ b/src/constraints.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity size/position constraints */

 /* 
--- a/src/core.c
+++ b/src/core.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity interface used by GTK+ UI to talk to core */

 /* 
@@ -27,6 +29,17 @@
 #include "workspace.h"
 #include "prefs.h"

+/* Looks up the MetaWindow representing the frame of the given X window.
+ * Used as a helper function by a bunch of the functions below.
+ *
+ * FIXME: The functions that use this function throw the result away
+ * after use. Many of these functions tend to be called in small groups,
+ * which results in get_window() getting called several times in succession
+ * with the same parameters. We should profile to see whether this wastes
+ * much time, and if it does we should look into a generalised
+ * meta_core_get_window_info() which takes a bunch of pointers to variables
+ * to put its results in, and only fills in the non-null ones.
+ */
 static MetaWindow *
 get_window (Display *xdisplay,
 	    Window   frame_xwindow)
@@ -60,6 +73,19 @@ meta_core_get_client_size (Display *xdisplay,
    *height = window->rect.height;
 }

+gboolean
+meta_core_window_has_frame (Display *xdisplay,
+                            Window frame_xwindow)
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  
+  display = meta_display_for_x_display (xdisplay);
+  window = meta_display_lookup_x_window (display, frame_xwindow);
+
+  return window != NULL && window->frame != NULL;
+}
+
 gboolean
 meta_core_titlebar_is_onscreen (Display *xdisplay,
                                Window   frame_xwindow)
@@ -366,6 +392,24 @@ meta_core_unstick (Display *xdisplay,
  meta_window_unstick (window);
 }

+void
+meta_core_make_above (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_make_above (window);
+}
+
+void
+meta_core_unmake_above (Display *xdisplay,
+                        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unmake_above (window);
+}
+
 void
 meta_core_stick (Display *xdisplay,
                 Window   frame_xwindow)
@@ -487,7 +531,6 @@ meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
      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:
@@ -586,6 +629,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
                         Window      frame_xwindow,
                         MetaGrabOp  op,
                         gboolean    pointer_already_grabbed,
+                         gboolean    frame_action,
                         int         event_serial,
                         int         button,
                         gulong      modmask,
@@ -604,6 +648,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
  
  return meta_display_begin_grab_op (display, screen, window,
                                     op, pointer_already_grabbed,
+                                     frame_action,
                                     event_serial,
                                     button, modmask,
                                     timestamp, root_x, root_y);
@@ -710,3 +755,31 @@ meta_core_increment_event_serial (Display *xdisplay)
  meta_display_increment_event_serial (display);
 }

+void
+meta_invalidate_default_icons (void)
+{
+  GSList *displays, *windows;
+
+  for (displays = meta_displays_list ();
+       displays != NULL;
+       displays = displays->next)
+    {
+
+      for (windows = meta_display_list_windows (displays->data);
+           windows != NULL;
+           windows = windows->next)
+        {
+
+          MetaWindow *window = (MetaWindow*)windows->data;
+
+          if (window->icon_cache.origin == USING_FALLBACK_ICON)
+            {
+              meta_icon_cache_free (&(window->icon_cache));
+              meta_window_update_icon_now (window);
+            }
+        }
+
+      g_slist_free (windows);
+    }
+}
+
--- a/src/core.h
+++ b/src/core.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity interface used by GTK+ UI to talk to core */

 /* 
@@ -35,6 +37,10 @@ void meta_core_get_client_size (Display *xdisplay,
 gboolean meta_core_titlebar_is_onscreen (Display *xdisplay,
                                         Window   frame_xwindow);

+gboolean meta_core_window_has_frame (Display *xdisplay,
+                                     Window   frame_xwindow);
+
+
 Window meta_core_get_client_xwindow (Display *xdisplay,
                                     Window   frame_xwindow);

@@ -104,6 +110,10 @@ void meta_core_unstick          (Display *xdisplay,
                                 Window   frame_xwindow);
 void meta_core_stick            (Display *xdisplay,
                                 Window   frame_xwindow);
+void meta_core_unmake_above     (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_make_above       (Display *xdisplay,
+                                 Window   frame_xwindow);
 void meta_core_change_workspace (Display *xdisplay,
                                 Window   frame_xwindow,
                                 int      new_workspace);
@@ -140,6 +150,7 @@ gboolean   meta_core_begin_grab_op (Display    *xdisplay,
                                    Window      frame_xwindow,
                                    MetaGrabOp  op,
                                    gboolean    pointer_already_grabbed,
+                                    gboolean    frame_action,
                                    int         event_serial,
                                    int         button,
                                    gulong      modmask,
@@ -173,6 +184,8 @@ void meta_core_increment_event_serial (Display *display);

 int meta_ui_get_last_event_serial (Display *xdisplay);

+void meta_invalidate_default_icons (void);
+
 #endif


--- a/src/delete.c
+++ b/src/delete.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window deletion */

 /* 
--- a/src/display.c
+++ b/src/display.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X display handler */

 /* 
@@ -331,7 +333,8 @@ meta_display_open (void)
    "_NET_DESKTOP_VIEWPORT",
    "_METACITY_VERSION",
    "_NET_WM_VISIBLE_NAME",
-    "_NET_WM_VISIBLE_ICON_NAME"
+    "_NET_WM_VISIBLE_ICON_NAME",
+    "_NET_WM_USER_TIME_WINDOW"
  };
  Atom atoms[G_N_ELEMENTS(atom_names)];
  
@@ -363,6 +366,7 @@ meta_display_open (void)
  display->error_traps = 0;
  display->error_trap_handler = NULL;
  display->server_grab_count = 0;
+  display->display_opening = TRUE;

  display->pending_pings = NULL;
  display->autoraise_timeout_id = 0;
@@ -489,6 +493,7 @@ meta_display_open (void)
  display->atom_metacity_version = atoms[91];
  display->atom_net_wm_visible_name = atoms[92];
  display->atom_net_wm_visible_icon_name = atoms[93];
+  display->atom_net_wm_user_time_window = atoms[94];

  display->prop_hooks = NULL;
  meta_display_init_window_prop_hooks (display);
@@ -499,6 +504,7 @@ meta_display_open (void)
   * created in screen_new
   */
  display->leader_window = None;
+  display->timestamp_pinging_window = None;

  display->xinerama_cache_invalidated = TRUE;

@@ -654,8 +660,15 @@ meta_display_open (void)
    gulong data[1];
    XEvent event;

-    display->leader_window = meta_create_offscreen_window (display->xdisplay,
-                                                           DefaultRootWindow (display->xdisplay));                                                           
+    /* We only care about the PropertyChangeMask in the next 30 or so lines of
+     * code.  Note that gdk will at some point unset the PropertyChangeMask for
+     * this window, so we can't rely on it still being set later.  See bug
+     * 354213 for details.
+     */
+    display->leader_window =
+      meta_create_offscreen_window (display->xdisplay,
+                                    DefaultRootWindow (display->xdisplay),
+                                    PropertyChangeMask);

    meta_prop_set_utf8_string_hint (display,
                                    display->leader_window,
@@ -680,8 +693,23 @@ meta_display_open (void)
                  &event);

    timestamp = event.xproperty.time;
+
+    /* Make it painfully clear that we can't rely on PropertyNotify events on
+     * this window, as per bug 354213.
+     */
+    XSelectInput(display->xdisplay,
+                 display->leader_window,
+                 NoEventMask);
  }

+  /* Make a little window used only for pinging the server for timestamps; note
+   * that meta_create_offscreen_window already selects for PropertyChangeMask.
+   */
+  display->timestamp_pinging_window =
+    meta_create_offscreen_window (display->xdisplay,
+                                  DefaultRootWindow (display->xdisplay),
+                                  PropertyChangeMask);
+
  display->last_focus_time = timestamp;
  display->last_user_time = timestamp;
  display->compositor = NULL;
@@ -767,6 +795,9 @@ meta_display_open (void)
  if (meta_prefs_get_compositing_manager ())
    enable_compositor (display);
  
+  /* Done opening new display */
+  display->display_opening = FALSE;
+
  return TRUE;
 }

@@ -1186,14 +1217,13 @@ meta_display_get_current_time_roundtrip (MetaDisplay *display)
       * would use it as a property. The type doesn't matter.
       */
      XChangeProperty (display->xdisplay,
-                       display->leader_window,
+                       display->timestamp_pinging_window,
                       XA_PRIMARY, XA_STRING, 8,
                       PropModeAppend, NULL, 0);
      XWindowEvent (display->xdisplay,
-                    display->leader_window,
+                    display->timestamp_pinging_window,
                    PropertyChangeMask,
                    &property_event);
-
      timestamp = property_event.xproperty.time;
    }

@@ -1451,6 +1481,7 @@ event_callback (XEvent   *event,
                gpointer  data)
 {
  MetaWindow *window;
+  MetaWindow *property_for_window;
  MetaDisplay *display;
  Window modified;
  gboolean frame_was_receiver;
@@ -1504,6 +1535,18 @@ event_callback (XEvent   *event,
  else
    window = NULL;

+  /* We only want to respond to _NET_WM_USER_TIME property notify
+   * events on _NET_WM_USER_TIME_WINDOW windows; in particular,
+   * responding to UnmapNotify events is kind of bad.
+   */
+  property_for_window = NULL;
+  if (window && modified == window->user_time_window)
+    {
+      property_for_window = window;
+      window = NULL;
+    }
+    
+
  frame_was_receiver = FALSE;
  if (window &&
      window->frame &&
@@ -1732,6 +1775,7 @@ event_callback (XEvent   *event,
                                                window,
                                                op,
                                                TRUE,
+                                                FALSE,
                                                event->xbutton.serial,
                                                event->xbutton.button,
                                                0,
@@ -1789,6 +1833,7 @@ event_callback (XEvent   *event,
                                          window,
                                          META_GRAB_OP_MOVING,
                                          TRUE,
+                                          FALSE,
                                          event->xbutton.serial,
                                          event->xbutton.button,
                                          0,
@@ -1847,6 +1892,7 @@ event_callback (XEvent   *event,
            {
            case META_FOCUS_MODE_SLOPPY:
            case META_FOCUS_MODE_MOUSE:
+              display->mouse_mode = TRUE;
              if (window->type != META_WINDOW_DOCK &&
                  window->type != META_WINDOW_DESKTOP)
                {
@@ -1858,21 +1904,41 @@ event_callback (XEvent   *event,
                              event->xany.serial,
                              event->xcrossing.time);

-                  display->mouse_mode = TRUE;
                  meta_window_focus (window, event->xcrossing.time);

-		  /* stop ignoring stuff */
-		  reset_ignores (display);
-		  
-		  if (meta_prefs_get_auto_raise ()) 
-		    {
+                  /* stop ignoring stuff */
+                  reset_ignores (display);
+                  
+                  if (meta_prefs_get_auto_raise ()) 
+                    {
                      meta_display_queue_autoraise_callback (display, window);
-		    }
-		  else
-		    {
-		      meta_topic (META_DEBUG_FOCUS,
-				  "Auto raise is disabled\n");		      
-		    }
+                    }
+                  else
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Auto raise is disabled\n");		      
+                    }
+                }
+              /* In mouse focus mode, we defocus when the mouse *enters*
+               * the DESKTOP window, instead of defocusing on LeaveNotify.
+               * This is because having the mouse enter override-redirect
+               * child windows unfortunately causes LeaveNotify events that
+               * we can't distinguish from the mouse actually leaving the
+               * toplevel window as we expect.  But, since we filter out
+               * EnterNotify events on override-redirect windows, this
+               * alternative mechanism works great.
+               */
+              if (window->type == META_WINDOW_DESKTOP &&
+                  meta_prefs_get_focus_mode() == META_FOCUS_MODE_MOUSE &&
+                  display->expected_focus_window != NULL)
+                {
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Unsetting focus from %s due to mouse entering "
+                              "the DESKTOP window\n",
+                              display->expected_focus_window->desc);
+                  meta_display_focus_the_no_focus_window (display, 
+                                                          window->screen,
+                                                          event->xcrossing.time);
                }
              break;
            case META_FOCUS_MODE_CLICK:
@@ -1890,40 +1956,6 @@ event_callback (XEvent   *event,
        meta_window_handle_mouse_grab_op_event (window, event);
      else if (window != NULL)
        {
-          switch (meta_prefs_get_focus_mode ())
-            {
-            case META_FOCUS_MODE_MOUSE:
-              if ((window->frame == NULL || frame_was_receiver) &&
-                  event->xcrossing.mode != NotifyGrab && 
-                  event->xcrossing.mode != NotifyUngrab &&
-                  event->xcrossing.detail != NotifyInferior &&
-                  meta_display_focus_sentinel_clear (display))
-                {
-                  if (window == display->expected_focus_window)
-                    {
-                      meta_topic (META_DEBUG_FOCUS,
-                                  "Unsetting focus from %s due to LeaveNotify\n",
-                                  window->desc);
-                      meta_display_focus_the_no_focus_window (display, 
-                                                              window->screen,
-                                                              event->xcrossing.time);
-                    }
-                  if (window->type != META_WINDOW_DOCK &&
-                      window->type != META_WINDOW_DESKTOP)
-                    {
-                      meta_topic (META_DEBUG_FOCUS,
-                                  "Setting display->mouse_mode to TRUE due to "
-                                  "LeaveNotify at time %lu.\n",
-                                  event->xcrossing.time);
-                      display->mouse_mode = TRUE;
-                    }
-                }
-              break;
-            case META_FOCUS_MODE_SLOPPY:
-            case META_FOCUS_MODE_CLICK:
-              break;
-            }
-          
          if (window->type == META_WINDOW_DOCK &&
              event->xcrossing.mode != NotifyGrab &&
              event->xcrossing.mode != NotifyUngrab &&
@@ -2178,6 +2210,8 @@ event_callback (XEvent   *event,
        
        if (window && !frame_was_receiver)
          meta_window_property_notify (window, event);
+        else if (property_for_window && !frame_was_receiver)
+          meta_window_property_notify (property_for_window, event);

        group = meta_display_lookup_group (display,
                                           event->xproperty.window);
@@ -3270,6 +3304,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
                            MetaWindow  *window,
                            MetaGrabOp   op,
                            gboolean     pointer_already_grabbed,
+                            gboolean     frame_action,
                            int          event_serial,
                            int          button,
                            gulong       modmask,
@@ -3387,7 +3422,8 @@ meta_display_begin_grab_op (MetaDisplay *display,
  display->grab_last_user_action_was_snap = FALSE;
 #endif
  display->grab_was_cancelled = FALSE;
-  
+  display->grab_frame_action = frame_action;
+
  if (display->grab_resize_timeout_id)
    {
      g_source_remove (display->grab_resize_timeout_id);
@@ -3923,13 +3959,12 @@ meta_display_update_active_window_hint (MetaDisplay *display)
 {
  GSList *tmp;
  
-  unsigned long data[2];
+  gulong data[1];

  if (display->focus_window)
    data[0] = display->focus_window->xwindow;
  else
    data[0] = None;
-  data[1] = None;
  
  tmp = display->screens;
  while (tmp != NULL)
@@ -3940,7 +3975,8 @@ meta_display_update_active_window_hint (MetaDisplay *display)
      XChangeProperty (display->xdisplay, screen->xroot,
                       display->atom_net_active_window,
                       XA_WINDOW,
-                       32, PropModeReplace, (guchar*) data, 2);
+                       32, PropModeReplace, (guchar*) data, 1);
+
      meta_error_trap_pop (display, FALSE);

      tmp = tmp->next;
@@ -5009,10 +5045,13 @@ meta_display_set_input_focus_window (MetaDisplay *display,
  if (timestamp_too_old (display, window, &timestamp))
    return;

+  meta_error_trap_push (display);
  XSetInputFocus (display->xdisplay,
                  focus_frame ? window->frame->xwindow : window->xwindow,
                  RevertToPointerRoot,
                  timestamp);
+  meta_error_trap_pop (display, FALSE);
+
  display->expected_focus_window = window;
  display->last_focus_time = timestamp;
  display->active_screen = window->screen;
--- a/src/display.h
+++ b/src/display.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X display handler */

 /* 
@@ -83,6 +85,7 @@ struct _MetaDisplay
  Display *xdisplay;

  Window leader_window;
+  Window timestamp_pinging_window;
  
  Atom atom_net_wm_name;
  Atom atom_wm_protocols;
@@ -178,6 +181,7 @@ struct _MetaDisplay
  Atom atom_metacity_version;
  Atom atom_net_wm_visible_name;
  Atom atom_net_wm_visible_icon_name;
+  Atom atom_net_wm_user_time_window;

  /* This is the actual window from focus events,
   * not the one we last set
@@ -262,6 +266,7 @@ struct _MetaDisplay
  guint       grab_have_keyboard : 1;
  guint       grab_wireframe_active : 1;
  guint       grab_was_cancelled : 1;    /* Only used in wireframe mode */
+  guint       grab_frame_action : 1;
  MetaRectangle grab_wireframe_rect;
  MetaRectangle grab_wireframe_last_xor_rect;
  MetaRectangle grab_initial_window_pos;
@@ -311,6 +316,9 @@ struct _MetaDisplay
  /* Xinerama cache */
  unsigned int xinerama_cache_invalidated : 1;

+  /* Opening the display */
+  unsigned int display_opening : 1;
+
  /* Closing down the display */
  int closing;

@@ -441,6 +449,7 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display,
                                     MetaWindow  *window,
                                     MetaGrabOp   op,
                                     gboolean     pointer_already_grabbed,
+                                     gboolean     frame_action,
                                     int          event_serial,
                                     int          button,
                                     gulong       modmask,
--- a/src/draw-workspace.c
+++ b/src/draw-workspace.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Draw a workspace */

 /* This file should not be modified to depend on other files in
@@ -64,21 +66,38 @@ get_window_rect (const WnckWindowDisplayInfo *win,
 }

 static void
-draw_window (GtkWidget             *widget,
-             GdkDrawable           *drawable,
+draw_window (GtkWidget                   *widget,
+             GdkDrawable                 *drawable,
             const WnckWindowDisplayInfo *win,
-             const GdkRectangle    *winrect)
+             const GdkRectangle          *winrect,
+             GtkStateType                state)
 {
+  cairo_t *cr;
  GdkPixbuf *icon;
  int icon_x, icon_y, icon_w, icon_h;
-          
-  gdk_draw_rectangle (drawable,
-                      win->is_active ?
-                      widget->style->bg_gc[GTK_STATE_SELECTED] :
-                      widget->style->bg_gc[GTK_STATE_NORMAL],
-                      TRUE,
-                      winrect->x + 1, winrect->y + 1,
-                      winrect->width - 2, winrect->height - 2);
+  gboolean is_active;
+  GdkColor *color;
+
+  is_active = win->is_active;
+  
+  cr = gdk_cairo_create (drawable);
+  cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height);
+  cairo_clip (cr);
+
+  if (is_active)
+    color = &widget->style->light[state];
+  else
+    color = &widget->style->bg[state];
+  cairo_set_source_rgb (cr,
+                        color->red / 65535.,
+                        color->green / 65535.,
+                        color->blue / 65535.);
+
+  cairo_rectangle (cr,
+                   winrect->x + 1, winrect->y + 1,
+                   MAX (0, winrect->width - 2), MAX (0, winrect->height - 2));
+  cairo_fill (cr);
+

  icon = win->icon;

@@ -101,7 +120,7 @@ draw_window (GtkWidget             *widget,
            {
              icon_w = gdk_pixbuf_get_width (icon);
              icon_h = gdk_pixbuf_get_height (icon);
-
+        
              /* Give up. */
              if (icon_w > (winrect->width - 2) ||
                  icon_h > (winrect->height - 2))
@@ -114,44 +133,31 @@ draw_window (GtkWidget             *widget,
    {
      icon_x = winrect->x + (winrect->width - icon_w) / 2;
      icon_y = winrect->y + (winrect->height - icon_h) / 2;
-                
-      {
-        /* render_to_drawable should take a clip rect to save
-         * us this mess...
-         */
-        GdkRectangle pixbuf_rect;
-        GdkRectangle draw_rect;
-
-        pixbuf_rect.x = icon_x;
-        pixbuf_rect.y = icon_y;
-        pixbuf_rect.width = icon_w;
-        pixbuf_rect.height = icon_h;
-        
-        if (gdk_rectangle_intersect ((GdkRectangle *)winrect, &pixbuf_rect,
-                                     &draw_rect))
-          {
-            gdk_pixbuf_render_to_drawable_alpha (icon,
-                                                 drawable,
-                                                 draw_rect.x - pixbuf_rect.x,
-                                                 draw_rect.y - pixbuf_rect.y,
-                                                 draw_rect.x, draw_rect.y,
-                                                 draw_rect.width,
-                                                 draw_rect.height,
-                                                 GDK_PIXBUF_ALPHA_FULL,
-                                                 128,
-                                                 GDK_RGB_DITHER_NORMAL,
-                                                 0, 0);
-          }
-      }
+      
+      cairo_save (cr);
+      gdk_cairo_set_source_pixbuf (cr, icon, icon_x, icon_y);
+      cairo_rectangle (cr, icon_x, icon_y, icon_w, icon_h);
+      cairo_clip (cr);
+      cairo_paint (cr);
+      cairo_restore (cr);
    }
          
-  gdk_draw_rectangle (drawable,
-                      win->is_active ?
-                      widget->style->fg_gc[GTK_STATE_SELECTED] :
-                      widget->style->fg_gc[GTK_STATE_NORMAL],
-                      FALSE,
-                      winrect->x, winrect->y,
-                      winrect->width - 1, winrect->height - 1);
+  if (is_active)
+    color = &widget->style->fg[state];
+  else
+    color = &widget->style->fg[state];
+
+  cairo_set_source_rgb (cr,
+                        color->red / 65535.,
+                        color->green / 65535.,
+                        color->blue / 65535.);
+  cairo_set_line_width (cr, 1.0);
+  cairo_rectangle (cr,
+                   winrect->x + 0.5, winrect->y + 0.5,
+                   MAX (0, winrect->width - 1), MAX (0, winrect->height - 1));
+  cairo_stroke (cr);
+  
+  cairo_destroy (cr);
 }

 void
@@ -170,48 +176,56 @@ wnck_draw_workspace (GtkWidget                   *widget,
 {
  int i;
  GdkRectangle workspace_rect;
-  
+  GtkStateType state;
+
  workspace_rect.x = x;
  workspace_rect.y = y;
  workspace_rect.width = width;
  workspace_rect.height = height;

-  
  if (is_active)
-    gdk_draw_rectangle (drawable,
-                        GTK_WIDGET (widget)->style->dark_gc[GTK_STATE_SELECTED],
-                        TRUE,
-                        x, y, width, height);
-  else if (workspace_background)
+    state = GTK_STATE_SELECTED;
+  else if (workspace_background) 
+    state = GTK_STATE_PRELIGHT;
+  else
+    state = GTK_STATE_NORMAL;
+  
+  if (workspace_background)
    {
-      gdk_pixbuf_render_to_drawable (workspace_background,
-                                     drawable,
-                                     GTK_WIDGET (widget)->style->dark_gc[GTK_STATE_SELECTED],
-                                     0, 0,
-                                     x, y,
-                                     -1, -1,
-                                     GDK_RGB_DITHER_MAX,
-                                     0, 0);
+      gdk_draw_pixbuf (drawable,
+                       GTK_WIDGET (widget)->style->dark_gc[state],
+                       workspace_background,
+                       0, 0,
+                       x, y,
+                       -1, -1,
+                       GDK_RGB_DITHER_MAX,
+                       0, 0);
    }
  else
-    gdk_draw_rectangle (drawable,
-                        GTK_WIDGET (widget)->style->dark_gc[GTK_STATE_NORMAL],
-                        TRUE,
-                        x, y, width, height);
-
-
+    {
+      cairo_t *cr;
+      
+      cr = gdk_cairo_create (widget->window);
+      gdk_cairo_set_source_color (cr, &widget->style->dark[state]);
+      cairo_rectangle (cr, x, y, width, height);
+      cairo_fill (cr);
+      cairo_destroy (cr);
+    }
+  
  i = 0;
  while (i < n_windows)
    {
      const WnckWindowDisplayInfo *win = &windows[i];
      GdkRectangle winrect;
      
-      get_window_rect (win, screen_width, screen_height, &workspace_rect, &winrect);
+      get_window_rect (win, screen_width,
+                       screen_height, &workspace_rect, &winrect);
      
      draw_window (widget,
                   drawable,
                   win,
-                   &winrect);
+                   &winrect,
+                   state);
      
      ++i;
    }
--- a/src/draw-workspace.h
+++ b/src/draw-workspace.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Draw a workspace */

 /* This file should not be modified to depend on other files in
--- a/src/edge-resistance.c
+++ b/src/edge-resistance.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Edge resistance for move/resize operations */

 /* 
@@ -60,6 +62,9 @@ struct MetaEdgeResistanceData
  ResistanceDataForAnEdge bottom_data;
 };

+/* !WARNING!: this function can return invalid indices (namely, either -1 or
+ * edges->len); this is by design, but you need to remember this.
+ */
 static int
 find_index_of_edge_near_position (const GArray *edges,
                                  int           position,
@@ -298,9 +303,9 @@ movement_towards_edge (MetaDirection side, int increment)
    case META_DIRECTION_RIGHT:
    case META_DIRECTION_BOTTOM:
      return increment > 0;
+    default:
+      g_assert_not_reached ();
    }
-
-  g_assert_not_reached ();
 }

 static gboolean
@@ -328,6 +333,7 @@ apply_edge_resistance (MetaWindow                *window,
                       gboolean                   keyboard_op)
 {
  int i, begin, end;
+  int last_edge;
  gboolean increasing = new_pos > old_pos;
  int      increment = increasing ? 1 : -1;

@@ -364,6 +370,13 @@ apply_edge_resistance (MetaWindow                *window,
  begin = find_index_of_edge_near_position (edges, old_pos,  increasing, xdir);
  end   = find_index_of_edge_near_position (edges, new_pos, !increasing, xdir);

+  /* begin and end can be outside the array index, if the window is partially
+   * off the screen
+   */
+  last_edge = edges->len - 1;
+  begin = CLAMP (begin, 0, last_edge);
+  end   = CLAMP (end,   0, last_edge);
+
  /* Loop over all these edges we're moving past/to. */
  i = begin;
  while ((increasing  && i <= end) ||
@@ -528,7 +541,8 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                    MetaRectangle       *new_outer,
                                    GSourceFunc          timeout_func,
                                    gboolean             auto_snap,
-                                    gboolean             keyboard_op)
+                                    gboolean             keyboard_op,
+                                    gboolean             is_resize)
 {
  MetaEdgeResistanceData *edge_data;
  MetaRectangle           modified_rect;
@@ -575,47 +589,68 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
    }
  else
    {
-      /* Now, apply the normal edge resistance */
-      new_left   = apply_edge_resistance (window,
-                                          BOX_LEFT (*old_outer),
-                                          BOX_LEFT (*new_outer),
-                                          old_outer,
-                                          new_outer,
-                                          edge_data->left_edges,
-                                          &edge_data->left_data,
-                                          timeout_func,
-                                          TRUE,
-                                          keyboard_op);
-      new_right  = apply_edge_resistance (window,
-                                          BOX_RIGHT (*old_outer),
-                                          BOX_RIGHT (*new_outer),
-                                          old_outer,
-                                          new_outer,
-                                          edge_data->right_edges,
-                                          &edge_data->right_data,
-                                          timeout_func,
-                                          TRUE,
-                                          keyboard_op);
-      new_top    = apply_edge_resistance (window,
-                                          BOX_TOP (*old_outer),
-                                          BOX_TOP (*new_outer),
-                                          old_outer,
-                                          new_outer,
-                                          edge_data->top_edges,
-                                          &edge_data->top_data,
-                                          timeout_func,
-                                          FALSE,
-                                          keyboard_op);
-      new_bottom = apply_edge_resistance (window,
-                                          BOX_BOTTOM (*old_outer),
-                                          BOX_BOTTOM (*new_outer),
-                                          old_outer,
-                                          new_outer,
-                                          edge_data->bottom_edges,
-                                          &edge_data->bottom_data,
-                                          timeout_func,
-                                          FALSE,
-                                          keyboard_op);
+      /* Disable edge resistance for resizes when windows have size
+       * increment hints; see #346782.  For all other cases, apply
+       * them.
+       */
+      if (!is_resize || window->size_hints.width_inc == 1)
+        {
+          /* Now, apply the normal horizontal edge resistance */
+          new_left   = apply_edge_resistance (window,
+                                              BOX_LEFT (*old_outer),
+                                              BOX_LEFT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->left_edges,
+                                              &edge_data->left_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+          new_right  = apply_edge_resistance (window,
+                                              BOX_RIGHT (*old_outer),
+                                              BOX_RIGHT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->right_edges,
+                                              &edge_data->right_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_left  = new_outer->x;
+          new_right = new_outer->x + new_outer->width;
+        }
+      /* Same for vertical resizes... */
+      if (!is_resize || window->size_hints.height_inc == 1)
+        {
+          new_top    = apply_edge_resistance (window,
+                                              BOX_TOP (*old_outer),
+                                              BOX_TOP (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->top_edges,
+                                              &edge_data->top_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+          new_bottom = apply_edge_resistance (window,
+                                              BOX_BOTTOM (*old_outer),
+                                              BOX_BOTTOM (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->bottom_edges,
+                                              &edge_data->bottom_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_top    = new_outer->y;
+          new_bottom = new_outer->y + new_outer->height;
+        }
    }

  /* Determine whether anything changed, and save the changes */
@@ -1102,6 +1137,7 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
                                      gboolean     is_keyboard_op)
 {
  MetaRectangle old_outer, proposed_outer, new_outer;
+  gboolean is_resize;

  if (window == window->display->grab_window &&
      window->display->grab_wireframe_active)
@@ -1120,13 +1156,15 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
  new_outer = proposed_outer;

  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = FALSE;
  if (apply_edge_resistance_to_each_side (window->display,
                                          window,
                                          &old_outer,
                                          &new_outer,
                                          timeout_func,
                                          snap,
-                                          is_keyboard_op))
+                                          is_keyboard_op,
+                                          is_resize))
    {
      /* apply_edge_resistance_to_each_side independently applies
       * resistance to both the right and left edges of new_outer as both
@@ -1194,6 +1232,7 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
 {
  MetaRectangle old_outer, new_outer;
  int proposed_outer_width, proposed_outer_height;
+  gboolean is_resize;

  if (window == window->display->grab_window &&
      window->display->grab_wireframe_active)
@@ -1215,13 +1254,15 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
                                      proposed_outer_height);

  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = TRUE;
  if (apply_edge_resistance_to_each_side (window->display,
                                          window,
                                          &old_outer,
                                          &new_outer,
                                          timeout_func,
                                          snap,
-                                          is_keyboard_op))
+                                          is_keyboard_op,
+                                          is_resize))
    {
      *new_width  = old_width  + (new_outer.width  - old_outer.width);
      *new_height = old_height + (new_outer.height - old_outer.height);
--- a/src/edge-resistance.h
+++ b/src/edge-resistance.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Edge resistance for move/resize operations */

 /* 
--- a/src/effects.c
+++ b/src/effects.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity animation effects */

 /* 
--- a/src/effects.h
+++ b/src/effects.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity animation effects */

 /* 
--- a/src/errors.c
+++ b/src/errors.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X error handling */

 /* 
--- a/src/errors.h
+++ b/src/errors.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X error handling */

 /* 
@@ -26,8 +28,8 @@
 #include "display.h"

 typedef void (* ErrorHandler) (Display *dpy,
-			       XErrorEvent *error,
-			       gpointer data);
+                               XErrorEvent *error,
+                               gpointer data);

 void      meta_errors_init     (void);
 void	  meta_errors_register_foreign_display (Display      *foreign_dpy,
--- a/src/eventqueue.c
+++ b/src/eventqueue.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X event source for main loop */

 /* 
--- a/src/eventqueue.h
+++ b/src/eventqueue.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X event source for main loop */

 /* 
--- a/src/fixedtip.c
+++ b/src/fixedtip.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity fixed tooltip routine */

 /* 
--- a/src/fixedtip.h
+++ b/src/fixedtip.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity fixed tooltip routine */

 /* 
--- a/src/frame.c
+++ b/src/frame.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X window decorations */

 /* 
@@ -277,6 +279,9 @@ meta_frame_get_flags (MetaFrame *frame)
  if (frame->is_flashing)
    flags |= META_FRAME_IS_FLASHING;

+  if (frame->window->wm_state_above)
+    flags |= META_FRAME_ABOVE;
+  
  return flags;
 }

--- a/src/frame.h
+++ b/src/frame.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity X window decorations */

 /* 
--- a/src/frames.c
+++ b/src/frames.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window frame manager widget */

 /* 
@@ -22,6 +24,7 @@
 */

 #include <config.h>
+#include <math.h>
 #include "boxes.h"
 #include "frames.h"
 #include "util.h"
@@ -755,10 +758,10 @@ meta_frames_apply_shapes (MetaFrames *frames,

  meta_frames_calc_geometry (frames, frame, &fgeom);

-  if (!(fgeom.top_left_corner_rounded ||
-        fgeom.top_right_corner_rounded ||
-        fgeom.bottom_left_corner_rounded ||
-        fgeom.bottom_right_corner_rounded ||
+  if (!(fgeom.top_left_corner_rounded_radius != 0 ||
+        fgeom.top_right_corner_rounded_radius != 0 ||
+        fgeom.bottom_left_corner_rounded_radius != 0 ||
+        fgeom.bottom_right_corner_rounded_radius != 0 ||
        window_has_shape))
    {
      if (frame->shape_applied)
@@ -783,102 +786,76 @@ meta_frames_apply_shapes (MetaFrames *frames,
  
  corners_xregion = XCreateRegion ();
  
-  if (fgeom.top_left_corner_rounded)
+  if (fgeom.top_left_corner_rounded_radius != 0)
    {
-      xrect.x = 0;
-      xrect.y = 0;
-      xrect.width = 5;
-      xrect.height = 1;
-      
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      const int corner = fgeom.top_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;

-      xrect.y = 1;
-      xrect.width = 3;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = 2;
-      xrect.width = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-
-      xrect.y = 3;
-      xrect.width = 1;
-      xrect.height = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+          
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
    }

-  if (fgeom.top_right_corner_rounded)
+  if (fgeom.top_right_corner_rounded_radius != 0)
    {
-      xrect.x = new_window_width - 5;
-      xrect.y = 0;
-      xrect.width = 5;
-      xrect.height = 1;
-      
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      const int corner = fgeom.top_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;

-      xrect.y = 1;
-      xrect.x = new_window_width - 3;
-      xrect.width = 3;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = 2;
-      xrect.x = new_window_width - 2;
-      xrect.width = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-
-      xrect.y = 3;
-      xrect.x = new_window_width - 1;
-      xrect.width = 1;
-      xrect.height = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+          
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
    }

-  if (fgeom.bottom_left_corner_rounded)
+  if (fgeom.bottom_left_corner_rounded_radius != 0)
    {
-      xrect.x = 0;
-      xrect.y = new_window_height - 1;
-      xrect.width = 5;
-      xrect.height = 1;
-      
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = new_window_height - 2;
-      xrect.width = 3;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = new_window_height - 3;
-      xrect.width = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      const int corner = fgeom.bottom_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;

-      xrect.y = new_window_height - 5;
-      xrect.width = 1;
-      xrect.height = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+          
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
    }

-  if (fgeom.bottom_right_corner_rounded)
+  if (fgeom.bottom_right_corner_rounded_radius != 0)
    {
-      xrect.x = new_window_width - 5;
-      xrect.y = new_window_height - 1;
-      xrect.width = 5;
-      xrect.height = 1;
-      
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = new_window_height - 2;
-      xrect.x = new_window_width - 3;
-      xrect.width = 3;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
-      
-      xrect.y = new_window_height - 3;
-      xrect.x = new_window_width - 2;
-      xrect.width = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      const int corner = fgeom.bottom_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;

-      xrect.y = new_window_height - 5;
-      xrect.x = new_window_width - 1;
-      xrect.width = 1;
-      xrect.height = 2;
-      XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+          
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
    }
  
  window_xregion = XCreateRegion ();
@@ -1100,6 +1077,24 @@ show_tip_now (MetaFrames *frames)
    case META_FRAME_CONTROL_UNMAXIMIZE:
      tiptext = _("Unmaximize Window");
      break;
+    case META_FRAME_CONTROL_SHADE:
+      tiptext = _("Roll Up Window");
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      tiptext = _("Unroll Window");
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      tiptext = _("Keep Window On Top");
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      tiptext = _("Remove Window From Top");
+      break;
+    case META_FRAME_CONTROL_STICK:
+      tiptext = _("Always On Visible Workspace");
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      tiptext = _("Put Window On Only One Workspace");
+      break;
    case META_FRAME_CONTROL_RESIZE_SE:
      break;
    case META_FRAME_CONTROL_RESIZE_S:
@@ -1196,6 +1191,108 @@ redraw_control (MetaFrames *frames,
  invalidate_cache (frames, frame);
 }

+static gboolean
+meta_frame_titlebar_event (MetaUIFrame    *frame,
+                           GdkEventButton *event,
+                           int            action)
+{
+  MetaFrameFlags flags;
+  
+  switch (action)
+    {
+    case META_ACTION_TITLEBAR_TOGGLE_SHADE:
+      {
+        flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
+        
+        if (flags & META_FRAME_ALLOWS_SHADE)
+          {
+            if (flags & META_FRAME_SHADED)
+              meta_core_unshade (gdk_display,
+                                 frame->xwindow,
+                                 event->time);
+            else
+              meta_core_shade (gdk_display,
+                               frame->xwindow,
+                               event->time);
+          }
+      }
+      break;          
+      
+    case META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE:
+      {
+        flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
+        
+        if (flags & META_FRAME_ALLOWS_MAXIMIZE)
+          {
+            meta_core_toggle_maximize (gdk_display, frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_MINIMIZE:
+      {
+        flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
+        
+        if (flags & META_FRAME_ALLOWS_MINIMIZE)
+          {
+            meta_core_minimize (gdk_display, frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_NONE:
+      /* Yaay, a sane user that doesn't use that other weird crap! */
+      break;
+    
+    case META_ACTION_TITLEBAR_LOWER:
+      meta_core_user_lower_and_unfocus (gdk_display,
+                                        frame->xwindow,
+                                        event->time);
+      break;
+
+    case META_ACTION_TITLEBAR_MENU:
+      meta_core_show_window_menu (gdk_display,
+                                  frame->xwindow,
+                                  event->x_root,
+                                  event->y_root,
+                                  event->button,
+                                  event->time);
+      break;
+
+    case META_ACTION_TITLEBAR_LAST:
+      break;
+    }
+  
+  return TRUE;
+}
+
+static gboolean
+meta_frame_double_click_event (MetaUIFrame    *frame,
+                               GdkEventButton *event)
+{
+  int action = meta_prefs_get_action_double_click_titlebar ();
+  
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
+static gboolean
+meta_frame_middle_click_event (MetaUIFrame    *frame,
+                               GdkEventButton *event)
+{
+  int action = meta_prefs_get_action_middle_click_titlebar();
+  
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
+static gboolean
+meta_frame_right_click_event(MetaUIFrame     *frame,
+                             GdkEventButton  *event)
+{
+  int action = meta_prefs_get_action_right_click_titlebar();
+  
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
 static gboolean
 meta_frames_button_press_event (GtkWidget      *widget,
                                GdkEventButton *event)
@@ -1242,59 +1339,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
      event->button == 1 &&
      event->type == GDK_2BUTTON_PRESS)
    {
-      MetaFrameFlags flags;
-      
-      switch (meta_prefs_get_action_double_click_titlebar ())
-        {
-        case META_ACTION_DOUBLE_CLICK_TITLEBAR_TOGGLE_SHADE:
-          {
-            flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
-            
-            if (flags & META_FRAME_ALLOWS_SHADE)
-              {
-                if (flags & META_FRAME_SHADED)
-                  meta_core_unshade (gdk_display,
-                                     frame->xwindow,
-                                     event->time);
-                else
-                  meta_core_shade (gdk_display,
-                                   frame->xwindow,
-                                   event->time);
-              }
-          }
-          break;          
-          
-        case META_ACTION_DOUBLE_CLICK_TITLEBAR_TOGGLE_MAXIMIZE:
-          {
-            flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
-            
-            if (flags & META_FRAME_ALLOWS_MAXIMIZE)
-              {
-                meta_core_toggle_maximize (gdk_display, frame->xwindow);
-              }
-          }
-          break;
-
-        case META_ACTION_DOUBLE_CLICK_TITLEBAR_MINIMIZE:
-          {
-            flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
-            
-            if (flags & META_FRAME_ALLOWS_MINIMIZE)
-              {
-                meta_core_minimize (gdk_display, frame->xwindow);
-              }
-          }
-          break;
-
-        case META_ACTION_DOUBLE_CLICK_TITLEBAR_NONE:
-          /* Yaay, a sane user that doesn't use that other weird crap! */
-          break;
-
-        case META_ACTION_DOUBLE_CLICK_TITLEBAR_LAST:
-          break;
-        }
-      
-      return TRUE;
+      return meta_frame_double_click_event (frame, event);
    }

  if (meta_core_get_grab_op (gdk_display) !=
@@ -1306,6 +1351,12 @@ meta_frames_button_press_event (GtkWidget      *widget,
       control == META_FRAME_CONTROL_UNMAXIMIZE ||
       control == META_FRAME_CONTROL_MINIMIZE ||
       control == META_FRAME_CONTROL_DELETE ||
+       control == META_FRAME_CONTROL_SHADE ||
+       control == META_FRAME_CONTROL_UNSHADE ||
+       control == META_FRAME_CONTROL_ABOVE ||
+       control == META_FRAME_CONTROL_UNABOVE ||
+       control == META_FRAME_CONTROL_STICK ||
+       control == META_FRAME_CONTROL_UNSTICK ||
       control == META_FRAME_CONTROL_MENU))
    {
      MetaGrabOp op = META_GRAB_OP_NONE;
@@ -1327,6 +1378,24 @@ meta_frames_button_press_event (GtkWidget      *widget,
        case META_FRAME_CONTROL_MENU:
          op = META_GRAB_OP_CLICKING_MENU;
          break;
+        case META_FRAME_CONTROL_SHADE:
+          op = META_GRAB_OP_CLICKING_SHADE;
+          break;
+        case META_FRAME_CONTROL_UNSHADE:
+          op = META_GRAB_OP_CLICKING_UNSHADE;
+          break;
+        case META_FRAME_CONTROL_ABOVE:
+          op = META_GRAB_OP_CLICKING_ABOVE;
+          break;
+        case META_FRAME_CONTROL_UNABOVE:
+          op = META_GRAB_OP_CLICKING_UNABOVE;
+          break;
+        case META_FRAME_CONTROL_STICK:
+          op = META_GRAB_OP_CLICKING_STICK;
+          break;
+        case META_FRAME_CONTROL_UNSTICK:
+          op = META_GRAB_OP_CLICKING_UNSTICK;
+          break;
        default:
          g_assert_not_reached ();
          break;
@@ -1336,6 +1405,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                               frame->xwindow,
                               op,
                               TRUE,
+                               TRUE,
                               meta_ui_get_last_event_serial (gdk_display),
                               event->button,
                               0,
@@ -1426,6 +1496,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                 frame->xwindow,
                                 op,
                                 TRUE,
+                                 TRUE,
                                 meta_ui_get_last_event_serial (gdk_display),
                                 event->button,
                                 0,
@@ -1446,6 +1517,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                   frame->xwindow,
                                   META_GRAB_OP_MOVING,
                                   TRUE,
+                                   TRUE,
                                   meta_ui_get_last_event_serial (gdk_display),
                                   event->button,
                                   0,
@@ -1456,18 +1528,11 @@ meta_frames_button_press_event (GtkWidget      *widget,
    }
  else if (event->button == 2)
    {
-      meta_core_user_lower_and_unfocus (gdk_display,
-                                        frame->xwindow,
-                                        event->time);
+      return meta_frame_middle_click_event (frame, event);
    }
  else if (event->button == 3)
    {
-      meta_core_show_window_menu (gdk_display,
-                                  frame->xwindow,
-                                  event->x_root,
-                                  event->y_root,
-                                  event->button,
-                                  event->time);
+      return meta_frame_right_click_event (frame, event);
    }
  
  return TRUE;
@@ -1565,6 +1630,48 @@ meta_frames_button_release_event    (GtkWidget           *widget,
          meta_core_end_grab_op (gdk_display, event->time);
          break;

+        case META_GRAB_OP_CLICKING_SHADE:
+          if (control == META_FRAME_CONTROL_SHADE)
+            meta_core_shade (gdk_display, frame->xwindow, event->time);
+          
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+ 
+        case META_GRAB_OP_CLICKING_UNSHADE:
+          if (control == META_FRAME_CONTROL_UNSHADE)
+            meta_core_unshade (gdk_display, frame->xwindow, event->time);
+
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_ABOVE:
+          if (control == META_FRAME_CONTROL_ABOVE)
+            meta_core_make_above (gdk_display, frame->xwindow);
+          
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+ 
+        case META_GRAB_OP_CLICKING_UNABOVE:
+          if (control == META_FRAME_CONTROL_UNABOVE)
+            meta_core_unmake_above (gdk_display, frame->xwindow);
+
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_STICK:
+          if (control == META_FRAME_CONTROL_STICK)
+            meta_core_stick (gdk_display, frame->xwindow);
+
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+ 
+        case META_GRAB_OP_CLICKING_UNSTICK:
+          if (control == META_FRAME_CONTROL_UNSTICK)
+            meta_core_unstick (gdk_display, frame->xwindow);
+
+          meta_core_end_grab_op (gdk_display, event->time);
+          break;
+          
        default:
          break;
        }
@@ -1588,6 +1695,7 @@ meta_frames_update_prelit_control (MetaFrames      *frames,
  MetaFrameControl old_control;
  MetaCursor cursor;

+
  meta_verbose ("Updating prelit control from %u to %u\n",
                frame->prelit_control, control);
  
@@ -1611,6 +1719,18 @@ meta_frames_update_prelit_control (MetaFrames      *frames,
      break;
    case META_FRAME_CONTROL_UNMAXIMIZE:
      break;
+    case META_FRAME_CONTROL_SHADE:
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      break;
+    case META_FRAME_CONTROL_STICK:
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      break;
    case META_FRAME_CONTROL_RESIZE_SE:
      cursor = META_CURSOR_SE_RESIZE;
      break;
@@ -1648,6 +1768,12 @@ meta_frames_update_prelit_control (MetaFrames      *frames,
    case META_FRAME_CONTROL_MINIMIZE:
    case META_FRAME_CONTROL_MAXIMIZE:
    case META_FRAME_CONTROL_DELETE:
+    case META_FRAME_CONTROL_SHADE:
+    case META_FRAME_CONTROL_UNSHADE:
+    case META_FRAME_CONTROL_ABOVE:
+    case META_FRAME_CONTROL_UNABOVE:
+    case META_FRAME_CONTROL_STICK:
+    case META_FRAME_CONTROL_UNSTICK:
    case META_FRAME_CONTROL_UNMAXIMIZE:
      /* leave control set */
      break;
@@ -1696,6 +1822,12 @@ meta_frames_motion_notify_event     (GtkWidget           *widget,
    case META_GRAB_OP_CLICKING_MINIMIZE:
    case META_GRAB_OP_CLICKING_MAXIMIZE:
    case META_GRAB_OP_CLICKING_UNMAXIMIZE:
+    case META_GRAB_OP_CLICKING_SHADE:
+    case META_GRAB_OP_CLICKING_UNSHADE:
+    case META_GRAB_OP_CLICKING_ABOVE:
+    case META_GRAB_OP_CLICKING_UNABOVE:
+    case META_GRAB_OP_CLICKING_STICK:
+    case META_GRAB_OP_CLICKING_UNSTICK:
      {
        MetaFrameControl control;
        int x, y;
@@ -1712,10 +1844,23 @@ meta_frames_motion_notify_event     (GtkWidget           *widget,
                grab_op == META_GRAB_OP_CLICKING_DELETE) ||
               (control == META_FRAME_CONTROL_MINIMIZE &&
                grab_op == META_GRAB_OP_CLICKING_MINIMIZE) ||
-               (control == META_FRAME_CONTROL_MAXIMIZE &&
+               ((control == META_FRAME_CONTROL_MAXIMIZE ||
+                 control == META_FRAME_CONTROL_UNMAXIMIZE) &&
                (grab_op == META_GRAB_OP_CLICKING_MAXIMIZE ||
-                 grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE))))
-          control = META_FRAME_CONTROL_NONE;
+                 grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE)) ||
+               (control == META_FRAME_CONTROL_SHADE &&
+                grab_op == META_GRAB_OP_CLICKING_SHADE) ||
+               (control == META_FRAME_CONTROL_UNSHADE &&
+                grab_op == META_GRAB_OP_CLICKING_UNSHADE) ||
+               (control == META_FRAME_CONTROL_ABOVE &&
+                grab_op == META_GRAB_OP_CLICKING_ABOVE) ||
+               (control == META_FRAME_CONTROL_UNABOVE &&
+                grab_op == META_GRAB_OP_CLICKING_UNABOVE) ||
+               (control == META_FRAME_CONTROL_STICK &&
+                grab_op == META_GRAB_OP_CLICKING_STICK) ||
+               (control == META_FRAME_CONTROL_UNSTICK &&
+                grab_op == META_GRAB_OP_CLICKING_UNSTICK)))
+           control = META_FRAME_CONTROL_NONE;
        
        /* Update prelit control and cursor */
 	meta_frames_update_prelit_control (frames, frame, control);
@@ -2095,6 +2240,42 @@ meta_frames_paint_to_drawable (MetaFrames   *frames,
      else
        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
      break;
+    case META_FRAME_CONTROL_SHADE:
+      if (grab_op == META_GRAB_OP_CLICKING_SHADE)
+        button_states[META_BUTTON_TYPE_SHADE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_SHADE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      if (grab_op == META_GRAB_OP_CLICKING_UNSHADE)
+        button_states[META_BUTTON_TYPE_UNSHADE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNSHADE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      if (grab_op == META_GRAB_OP_CLICKING_ABOVE)
+        button_states[META_BUTTON_TYPE_ABOVE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_ABOVE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      if (grab_op == META_GRAB_OP_CLICKING_UNABOVE)
+        button_states[META_BUTTON_TYPE_UNABOVE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNABOVE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_STICK:
+      if (grab_op == META_GRAB_OP_CLICKING_STICK)
+        button_states[META_BUTTON_TYPE_STICK] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_STICK] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      if (grab_op == META_GRAB_OP_CLICKING_UNSTICK)
+        button_states[META_BUTTON_TYPE_UNSTICK] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNSTICK] = META_BUTTON_STATE_PRELIGHT;
+      break;
    case META_FRAME_CONTROL_DELETE:
      if (grab_op == META_GRAB_OP_CLICKING_DELETE)
        button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRESSED;
@@ -2180,17 +2361,52 @@ static void
 meta_frames_set_window_background (MetaFrames   *frames,
                                   MetaUIFrame  *frame)
 {
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-                            frame->window, GTK_STATE_NORMAL);
+  MetaFrameFlags flags;
+  MetaFrameType type;
+  MetaFrameStyle *style;
+  gboolean frame_exists;

-#if 0
-  /* This is what we want for transparent background */
-  {
-    col.pixel = 0;
-    gdk_window_set_background (window, &col);
-  }
-#endif
-}
+  frame_exists = meta_core_window_has_frame (gdk_display, frame->xwindow);
+
+  if (frame_exists)
+    {
+      flags = meta_core_get_frame_flags (gdk_display, frame->xwindow);
+      type = meta_core_get_frame_type (gdk_display, frame->xwindow);
+      style = meta_theme_get_frame_style (meta_theme_get_current (),
+                                          type, flags);
+    }
+
+  if (frame_exists && style->window_background_color != NULL)
+    {
+      GdkColor color;
+      GdkVisual *visual;
+
+      meta_color_spec_render (style->window_background_color,
+                              GTK_WIDGET (frames),
+                              &color);
+
+      /* Fill in color.pixel */
+
+      gdk_rgb_find_color (gtk_widget_get_colormap (GTK_WIDGET (frames)),
+                          &color);
+
+      /* Set A in ARGB to window_background_alpha, if we have ARGB */
+
+      visual = gtk_widget_get_visual (GTK_WIDGET (frames));
+      if (visual->depth == 32) /* we have ARGB */
+        {
+          color.pixel = (color.pixel & 0xffffff) &
+            style->window_background_alpha << 24;
+        }
+
+      gdk_window_set_background (frame->window, &color);
+    }
+  else
+    {
+      gtk_style_set_background (GTK_WIDGET (frames)->style,
+                                frame->window, GTK_STATE_NORMAL);
+    }
+ }

 static gboolean
 meta_frames_enter_notify_event      (GtkWidget           *widget,
@@ -2257,6 +2473,24 @@ control_rect (MetaFrameControl control,
    case META_FRAME_CONTROL_UNMAXIMIZE:
      rect = &fgeom->max_rect.visible;
      break;
+    case META_FRAME_CONTROL_SHADE:
+      rect = &fgeom->shade_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      rect = &fgeom->unshade_rect.visible;
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      rect = &fgeom->above_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      rect = &fgeom->unabove_rect.visible;
+      break;
+    case META_FRAME_CONTROL_STICK:
+      rect = &fgeom->stick_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      rect = &fgeom->unstick_rect.visible;
+      break;
    case META_FRAME_CONTROL_RESIZE_SE:
      break;
    case META_FRAME_CONTROL_RESIZE_S:
@@ -2334,6 +2568,36 @@ get_control (MetaFrames *frames,
        return META_FRAME_CONTROL_MAXIMIZE;
    }
      
+  if (POINT_IN_RECT (x, y, fgeom.shade_rect.clickable))
+    {
+      return META_FRAME_CONTROL_SHADE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unshade_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNSHADE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.above_rect.clickable))
+    {
+      return META_FRAME_CONTROL_ABOVE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unabove_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNABOVE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.stick_rect.clickable))
+    {
+      return META_FRAME_CONTROL_STICK;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unstick_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNSTICK;
+    }
+
  /* South resize always has priority over north resize,
   * in case of overlap.
   */
--- a/src/frames.h
+++ b/src/frames.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window frame manager widget */

 /* 
@@ -36,6 +38,12 @@ typedef enum
  META_FRAME_CONTROL_MINIMIZE,
  META_FRAME_CONTROL_MAXIMIZE,
  META_FRAME_CONTROL_UNMAXIMIZE,
+  META_FRAME_CONTROL_SHADE,
+  META_FRAME_CONTROL_UNSHADE,
+  META_FRAME_CONTROL_ABOVE,
+  META_FRAME_CONTROL_UNABOVE,
+  META_FRAME_CONTROL_STICK,
+  META_FRAME_CONTROL_UNSTICK,
  META_FRAME_CONTROL_RESIZE_SE,
  META_FRAME_CONTROL_RESIZE_S,
  META_FRAME_CONTROL_RESIZE_SW,
--- a/src/gradient.c
+++ b/src/gradient.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity gradient rendering */

 /* 
--- a/src/gradient.h
+++ b/src/gradient.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity gradient rendering */

 /* 
--- a/src/group-private.h
+++ b/src/group-private.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window group private header */

 /* 
--- a/src/group-props.c
+++ b/src/group-props.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* MetaGroup property handling */

 /* 
--- a/src/group-props.h
+++ b/src/group-props.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* MetaGroup property handling */

 /* 
--- a/src/group.c
+++ b/src/group.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window groups */

 /* 
--- a/src/group.h
+++ b/src/group.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window groups */

 /* 
--- a/src/iconcache.c
+++ b/src/iconcache.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window icons */

 /*
@@ -23,6 +25,7 @@
 #include "iconcache.h"
 #include "ui.h"
 #include "errors.h"
+#include "theme.h"

 #include <X11/Xatom.h>

@@ -497,19 +500,6 @@ get_kwm_win_icon (MetaDisplay *display,
  return;
 }

-typedef enum
-{
-  /* These MUST be in ascending order of preference;
-   * i.e. if we get _NET_WM_ICON and already have
-   * WM_HINTS, we prefer _NET_WM_ICON
-   */
-  USING_NO_ICON,
-  USING_FALLBACK_ICON,
-  USING_KWM_WIN_ICON,
-  USING_WM_HINTS,
-  USING_NET_WM_ICON
-} IconOrigin;
-
 void
 meta_icon_cache_init (MetaIconCache *icon_cache)
 {
@@ -828,13 +818,23 @@ meta_read_icons (MetaScreen     *screen,
  if (icon_cache->want_fallback &&
      icon_cache->origin < USING_FALLBACK_ICON)
    {
-      get_fallback_icons (screen,
-                          iconp,
-                          ideal_width,
-                          ideal_height,
-                          mini_iconp,
-                          ideal_mini_width,
-                          ideal_mini_height);
+      MetaTheme *theme = meta_theme_get_current ();
+
+      if (theme->fallback_icon == NULL || theme->fallback_mini_icon == NULL)
+        {
+          get_fallback_icons (screen,
+                              iconp,
+                              ideal_width,
+                              ideal_height,
+                              mini_iconp,
+                              ideal_mini_width,
+                              ideal_mini_height);
+        }
+
+      if (theme->fallback_icon != NULL)
+        *iconp = theme->fallback_icon;
+      if (theme->fallback_mini_icon != NULL)
+        *mini_iconp = theme->fallback_mini_icon;

      replace_cache (icon_cache, USING_FALLBACK_ICON,
                     *iconp, *mini_iconp);
--- a/src/iconcache.h
+++ b/src/iconcache.h
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window icons */

 /* 
@@ -26,6 +28,19 @@

 typedef struct _MetaIconCache MetaIconCache;

+typedef enum
+{
+  /* These MUST be in ascending order of preference;
+   * i.e. if we get _NET_WM_ICON and already have
+   * WM_HINTS, we prefer _NET_WM_ICON
+   */
+  USING_NO_ICON,
+  USING_FALLBACK_ICON,
+  USING_KWM_WIN_ICON,
+  USING_WM_HINTS,
+  USING_NET_WM_ICON
+} IconOrigin;
+
 struct _MetaIconCache
 {
  int origin;
--- a/src/keybindings.c
+++ b/src/keybindings.c
@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity Keybindings */ 
 /* 
 * Copyright (C) 2001 Havoc Pennington
@@ -189,6 +191,46 @@ static void handle_maximize_horiz     (MetaDisplay    *display,
                                       MetaWindow     *window,
                                       XEvent         *event,
                                       MetaKeyBinding *binding);
+static void handle_move_to_side_n     (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_side_w     (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_side_s     (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_side_e     (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_corner_nw          (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_corner_ne          (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_corner_sw          (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
+static void handle_move_to_corner_se          (MetaDisplay    *display,
+                                       MetaScreen     *screen,
+                                       MetaWindow     *window,
+                                       XEvent         *event,
+                                       MetaKeyBinding *binding);
 static void handle_run_terminal       (MetaDisplay    *display,
                                       MetaScreen     *screen,
                                       MetaWindow     *window,
@@ -430,6 +472,14 @@ static const MetaKeyHandler window_handlers[] = {
  { META_KEYBINDING_LOWER, handle_lower, NULL},
  { META_KEYBINDING_MAXIMIZE_VERTICALLY, handle_maximize_vert, NULL },
  { META_KEYBINDING_MAXIMIZE_HORIZONTALLY, handle_maximize_horiz, NULL },
+  { META_KEYBINDING_MOVE_TO_SIDE_N, handle_move_to_side_n, NULL },
+  { META_KEYBINDING_MOVE_TO_SIDE_S, handle_move_to_side_s, NULL },
+  { META_KEYBINDING_MOVE_TO_SIDE_E, handle_move_to_side_e, NULL },
+  { META_KEYBINDING_MOVE_TO_SIDE_W, handle_move_to_side_w, NULL },
+  { META_KEYBINDING_MOVE_TO_CORNER_NW, handle_move_to_corner_nw, NULL },
+  { META_KEYBINDING_MOVE_TO_CORNER_NE, handle_move_to_corner_ne, NULL },
+  { META_KEYBINDING_MOVE_TO_CORNER_SW, handle_move_to_corner_sw, NULL },
+  { META_KEYBINDING_MOVE_TO_CORNER_SE, handle_move_to_corner_se, NULL },
  { NULL, NULL, NULL }
 };

@@ -2815,6 +2865,162 @@ handle_maximize_horiz (MetaDisplay    *display,
    }
 }

+/* Move a window to a corner; to_bottom/to_right are FALSE for the
+ * top or left edge, or TRUE for the bottom/right edge.  xchange/ychange
+ * are FALSE if that dimension is not to be changed, TRUE otherwise.
+ * Together they describe which of the four corners, or four sides,
+ * is desired.
+ */
+static void
+handle_move_to_corner_backend (MetaDisplay    *display,
+           MetaScreen     *screen,
+           MetaWindow     *window,
+           gboolean        xchange,
+           gboolean        ychange,
+           gboolean        to_right,
+           gboolean        to_bottom)
+{
+  MetaRectangle work_area;
+  MetaRectangle outer;
+  int orig_x, orig_y;
+  int new_x, new_y;
+  int frame_width, frame_height;
+
+  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_position (window, &orig_x, &orig_y);
+
+  frame_width = (window->frame ? window->frame->child_x : 0);
+  frame_height = (window->frame ? window->frame->child_y : 0);
+
+  if (xchange) {
+    new_x = work_area.x + (to_right ?
+            (work_area.width + frame_width) - outer.width :
+            0);
+  } else {
+    new_x = orig_x;
+  }
+
+  if (ychange) {
+    new_y = work_area.y + (to_bottom ?
+            (work_area.height + frame_height) - outer.height :
+            0);
+  } else {
+    new_y = orig_y;
+  }
+
+  meta_window_move_resize (window,
+          FALSE,
+          new_x,
+          new_y,
+          window->rect.width,
+          window->rect.height);
+}
+
+static void
+handle_move_to_corner_nw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, FALSE);
+    }
+}
+
+static void
+handle_move_to_corner_ne  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, FALSE);
+    }
+}
+
+static void
+handle_move_to_corner_sw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, TRUE);
+    }
+}
+
+static void
+handle_move_to_corner_se  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, TRUE);
+    }
+}
+
+static void
+handle_move_to_side_n     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, FALSE);
+    }
+}
+
+static void
+handle_move_to_side_s     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, TRUE);
+    }
+}
+
+static void
+handle_move_to_side_e     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, TRUE, FALSE);
+    }
+}
+
+static void
+handle_move_to_side_w     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window)
+    {
+      handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, FALSE, FALSE);
+    }
+}
+
 static gboolean
 process_workspace_switch_grab (MetaDisplay *display,
                               MetaScreen  *screen,
@@ -2988,7 +3194,9 @@ handle_panel_keybinding (MetaDisplay    *display,
  ev.data.l[1] = event->xkey.time;

  meta_topic (META_DEBUG_KEYBINDINGS,
-              "Sending panel message with timestamp %lu\n", event->xkey.time);
+              "Sending panel message with timestamp %lu, and turning mouse_mode "
+              "off due to keybinding press\n", event->xkey.time);
+  display->mouse_mode = FALSE;

  meta_error_trap_push (display);

@@ -3120,6 +3328,7 @@ do_choose_window (MetaDisplay    *display,
                                           tab_op_from_tab_type (type) :
                                           cycle_op_from_tab_type (type),
                                           FALSE,
+                                           FALSE,
                                           event->xkey.serial,
                                           0,
                                           binding->mask,
@@ -3341,6 +3550,7 @@ handle_begin_move         (MetaDisplay    *display,
    {
      meta_window_begin_grab_op (window,
                                 META_GRAB_OP_KEYBOARD_MOVING,
+                                 FALSE,
                                 event->xkey.time);
    }
 }
@@ -3356,6 +3566,7 @@ handle_begin_resize       (MetaDisplay    *display,
    {
      meta_window_begin_grab_op (window,
                                 META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+                                 FALSE,
                                 event->xkey.time);
    }
 }
@@ -3553,6 +3764,7 @@ handle_workspace_switch  (MetaDisplay    *display,
                                  NULL,
                                  META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
                                  FALSE,
+                                  FALSE,
                                  event->xkey.serial,
                                  0,
                                  grab_mask,
--- a/Show More
+++ b/Show More