Metacity 2.9.0 (unstable release)

2004-11-01 Elijah Newren  <newren@math.utah.edu>

	* NEWS, README: Metacity 2.9.0 (unstable release)

COMPLIANCE

@@ -0,0 +1,159 @@
+Metacity Standards Compliance
+=============================
+$Id$
+
+1) Introduction
+2) EWMH Compliance
+  a. Root Window Properties
+  b. Root Window Messages
+  c. Application Window Properties
+  d. Window Manager Protocols
+3) ICCCM Compliance
+
+1) Introduction
+---------------
+
+This document details metacity compliance with the relevent standards.
+The format of this document is as follows:
+
+[-/+?] Hint Name/Feature Name (Version number)
+       Errata/Comments
+
+The first character indicates the level of compliance as follows:
+    -   none
+    /   partial
+    +   complete
+    ?   unknown
+
+The title indicates a feature or a hint in the specification, and the
+version number indicates the minimum version of the specification
+supported by metacity.  Later versions may be supported if no
+incompatible changes have been made in the specification.
+
+2) EWMH Compliance
+------------------
+
+The EWMH, or Extended Window Manager Hints is a freedesktop.org-
+developed standard to support a number of conventions for
+communication between the window manager and clients.  It builds on
+and extends the ICCCM (See Section 3).  A copy of the current EWMH
+standard is available at http://freedesktop.org/Standards/wm-spec/
+
+  a. Root Window Properties
+  -------------------------
+
++ _NET_SUPPORTED (1.3)
+
++ _NET_CLIENT_LIST (1.3)
+
++ _NET_NUMBER_OF_DESKTOPS (1.3)
+
++ _NET_DESKTOP_GEOMETRY (1.3)
+  Metacity does not implement large desktops, so this is kept set to
+  the screen size.
+
++ _NET_DESKTOP_VIEWPORT (1.3)
+  Metacity does not implement viewports, so this is a constant (0,0).
+
++ _NET_CURRENT_DESKTOP (1.3)
+
++ _NET_DESKTOP_NAMES (1.3)
+
++ _NET_ACTIVE_WINDOW (1.3)
+
++ _NET_WORKAREA (1.3)
+
++ _NET_SUPPORTING_WM_CHECK (1.3)
+
++ _NET_VIRTUAL_ROOTS (1.3)
+  Metacity does not read or set this property, but it does not use
+  virtual roots to implement virtual desktops, so it complies with the
+  specification.
+
++ _NET_DESKTOP_LAYOUT (1.3)
+
++ _NET_SHOWING_DESKTOP (1.3)
+
+  b. Root Window Messages
+  -----------------------
+
++ _NET_CLOSE_WINDOW (1.3)
+
+- _NET_MOVERESIZE_WINDOW (1.3)
+  Metacity supports this message, but the specification is unclear on
+  the layout of the detail value, and as such it is #if 0'd in the code
+
++ _NET_WM_MOVERESIZE (1.3)
+
+- _NET_RESTACK_WINDOW (1.3)
+  Metacity will raise or lower windows in response to this message,
+  but the sibling restack modes are not supported, and it is currently
+  #if 0'd in the code.
+
++ _NET_REQUEST_FRAME_EXTENTS (1.3)  
+
+  c. Application Window Properties
+  --------------------------------
+
++ _NET_WM_NAME (1.3)
+
++ _NET_WM_VISIBLE_NAME (1.3)
+  Metacity does not set this property, but metacity will never display
+  a name different from _NET_WM_NAME
+
++ _NET_WM_ICON_NAME (1.3)
+
++ _NET_WM_VISIBLE_ICON_NAME (1.3)
+  Metacity does not set this property, but metacity will never display
+  a name different from _NET_WM_NAME
+
++ _NET_WM_DESKTOP (1.3)
+
++ _NET_WM_WINDOW_TYPE (1.3)
+
+/ _NET_WM_STATE (1.3)
+  This property is read and updated according to the specification,
+  but see caveat below.
+  Metacity does not recognize separate vertical and horizontal
+  maximization states.  Currently metacity will do a two-dimensional
+  maximization if either property is set.
+  See: http://bugzilla.gnome.org/show_bug.cgi?id=113601
+  Metacity doesn't implement viewports so _NET_WM_STATE_STICKY is
+  unimplemented.
+
++ _NET_WM_ALLOWED_ACTIONS (1.3)
+  Metacity keeps this hint up to date.  The code is somewhat crufty
+  and should be rewritten, though it is functional.
+  See: http://bugzilla.gnome.org/show_bug.cgi?id=90420
+
++ _NET_WM_STRUT (1.3)
+
++ _NET_WM_STRUT_PARTIAL (1.3)
+
++ _NET_WM_ICON_GEOMETRY (1.3)
+  Metacity uses this property to draw minimize/restore animations
+
++ _NET_WM_ICON (1.3)
+
++ _NET_WM_PID (1.3)
+
++ _NET_WM_HANDLED_ICONS (1.3)
+  Metacity does not read or set this property.  However, metacity
+  never manages iconified windows, and so has no need to do so.
+
++ _NET_WM_USER_TIME (1.3)
+  Metacity uses this property to prevent applications from stealing
+  focus if supported by the toolkit.
+
++ _NET_FRAME_EXTENTS (1.3)
+  If set in response to a _NET_REQUEST_FRAME_EXTENTS message received
+  prior to the window being mapped, this may be an estimate.  This is,
+  however, expressly allowed by the specification.
+
+  d. Window Manager Protocols
+  ---------------------------
++ _NET_WM_PING (1.3)
+
+3) ICCCM Compliance
+-------------------
+TODO

HACKING

@@ -1,3 +1,40 @@
+Making a release
+===
+
+To make a release of metacity, do the following:
+
+ - check out a fresh copy from CVS
+
+ - increment the version number in configure.in, 
+   see the comment above the version for the next fibonacci number
+
+ - update the file NEWS based on the ChangeLog
+
+ - add a ChangeLog entry containing the version number 
+   you're releasing ("Released 2.5.4" or something)
+   so people can see which changes were before and after
+   a given release.
+
+ - "make distcheck" (DO NOT just "make dist" - pass the check!)
+
+ - if make distcheck fails, fix it.
+
+ - once distcheck succeeds, "cvs commit"
+
+ - if someone else made changes and the commit fails, 
+   you have to "cvs up" and run "make distcheck" again
+
+ - once the commit succeeds, WITHOUT cvs updating, "cvs tag
+   METACITY_X_Y_Z" where
+   X_Y_Z map to version X.Y.Z
+
+ - scp the tarball to master.gnome.org
+
+ - run install-module on master.gnome.org to install the tarball 
+   on the ftp site
+
+Misc stuff
+===
 
 Don't commit substantive code in here without asking me,
 hp@redhat.com.  Adding translations, no-brainer typo fixes, etc.  is
@@ -64,4 +101,9 @@ be NULL.
 
 The code could use cleanup in a lot of places, feel free to do so.
 
-
+Metacity is ideally a fully ICCCM and EWMH-compliant window manager.
+Reading these specifications is a useful first step to understanding
+the role of a window manager on an X11 desktop and the standards and
+conventions on which X11 desktops are based.  Please refer to the
+COMPLIANCE file for additional information on these specifications and
+metacity's compliance therewith.

Makefile.am

@@ -1,5 +1,5 @@
 
 SUBDIRS=src po doc
 
-EXTRA_DIST=HACKING metacity.spec.in metacity.spec \
+EXTRA_DIST=HACKING rationales.txt \
 	intltool-extract.in intltool-merge.in intltool-update.in

NEWS

@@ -1,3 +1,378 @@
+2.9.0
+==
+
+This is an unstable release heading towards Gnome 2.10.
+
+Thanks to Rob Adams, Anders Carlsson, Elijah Newren, Soeren Sandmann,
+and Vincent Untz for fixes and features in this release.
+
+ - Add a keybinding to launch a terminal (Vincent) [#154232]
+ - Correct the requested number of keycodes (Rob) [#155247]
+ - Add tracker bugs to rationales.txt file
+ - Make the "showing desktop" mode be per-workspace instead of
+   per-screen. (Elijah) [#142198]
+ - Don't try to use an ARGB visual at all if the depth isn't
+   32-bit. This caused major slowdowns with Composite
+   enabled. (Anders)
+ - Fix the modifier key breakage introduced by an Xorg
+   change. (Soeren) [#151554]
+ - Update _NET_WM_STATE_HIDDEN so the pager on the panel will know
+   whether to display windows as visible or hidden (Elijah) [#105665]
+ - Fix the alt-tab order--if the most recently used window is not
+   focused, start alt tabbing with that window instead of the one
+   after it (Elijah) [#156251]
+ - Don't lower newly mapped windows when they're denied focus if they
+   are transients of the focused window.  Instead, defocus the
+   currently focused window (Elijah) [#151996]
+ - Re-enable focus stealing prevention (Elijah)
+
+Translations
+ es(Francisco Javier F. Serrador), sq(Laurent Dhima), sr(Danilo <20>egan), 
+ cs(Miloslav Trmac), en_CA(Adam Weinberger), en_GB(David Lodge)
+
+2.8.6
+==
+
+This is a stable release for Gnome 2.8.1.
+
+Thanks to the Ken Harris, Kjartan Maraas, and the tireless efforts of
+Elijah Newren for fixes in this release.
+
+Fixes
+  * Ensure the correct window is focused when minimizing (Elijah)
+  * Fix keynav with mouse focus (Elijah)
+  * Fix several race conditions in window focusing (Elijah)
+  * Focus the top window when lowering by frame click (Ken)
+  * Fix some compiler warnings (Kjartan)
+  * Fix some valgrind-reported errors (Elijah)
+  * Fix some potential issues with autoraising windows (Elijah)
+
+Translations
+  * en_CA(Adam Weinberger), it(Luca Ferretti)
+
+2.8.5
+==
+
+This is a stable release for Gnome 2.8.  Only translations and some
+new developer documentation were added since the last unstable release.
+This release boasts improved standards-compliance and a number of 
+bug fixes since the last stable release.
+
+Translations
+
+  * ar(Abdulaziz Al-Arfaj), cs(Miloslav Trmac), cy(Dafydd Harries),
+    en_GB(David Lodge), fr(Christophe Merlet (RedFox)), 
+    nn(<28>smund Skj<6B>veland), or(Gora Mohanty), 
+    pr_BR(Gustavo Noronha Silva), ro(Mugurel Tudor), 
+    th(Paisa Seeluangsawat), tr(Baris Cicek), zh_TW(Woodman Tuen)
+
+2.8.4
+==
+
+This release features a number of bug fixes, and also the disabling of
+the focus-stealing-prevention code (we're entering hard code freeze in
+Gnome so it's too late to fix the remaining issues, especially since
+it requires several patches to modules other than Metacity).
+
+Thanks to Havoc Pennington, Soeren Sandmann, Elijah Newren, and Rich
+Wareham for fixes in this release
+
+Fixes
+  * track the last_xor_rect, for wireframe painting (Havoc)
+  * Move wireframe code before grab is released to prevent endless
+    loops with fullscreen windows. (Soeren)
+  * Make dialogs that Metacity shows follow focus-stealing-prevention
+    conventions. (Elijah; part of #149028)
+  * add render extension check to the display, don't build the
+    compositing manager by default, use an ARGB visual when available
+    for the window frame (Rich Wareham; various tweaks added later by
+    Havoc)
+  * move the have_xrender variable initialization up in the file since
+    it can be set as part of composite check (Havoc)
+  * make argb stuff compile, add some code from xcompmgr (Havoc)
+  * fix an assertion failure that would occur after increasing the
+    number of workspaces; fix stacking order when a window is denied
+    focus (Elijah; #150615)
+  * disable some compositor code that wasn't working, don't grab the
+    server during repaint, various set_background fixes and
+    refactoring (Havoc)
+
+Translations
+  * az(Metin Amiroff), bs(Kemal Sanjta), ca(Jordi Mallach), 
+    el(Kostas Papadimas), es(Francisco Javier F. Serrador), 
+    eu(I<><49>aki Larra<72><61>aga Murgoitio), fi(Pauli Virtanen),
+    nb(Kjartan Maraas), sq(Laurent Dhima), uk(Maxim Dziumanenko)
+
+
+2.8.3
+==
+
+Some important bug fixes in this release, including somy a11y bugs,
+and a compile issue on Solaris.
+
+Thanks to Rob Adams, Bill Haneman, Peter O'Shea, Mike Castle, Soeren
+Sandman, Elijah Newren, and Havoc Pennington for fixes in this
+release.
+
+Fixes
+  * Adjust the MRU list when preventing focus stealing (Elijah)
+  * Ensure that we maintain a focus window when switching workspaces
+    in mouse focus mode (Elijah)
+  * Some improvements in the showing desktop mode, and window
+    activation (Elijah)
+  * Make sure cursors changes are handled correctly (Havoc, Soeren)
+  * Some fixes to the window menu (Rob)
+  * Fix a compile issue on Solaris (Peter, Mike)
+  * Allow struts to go past the middle of the screen, provided there's
+    a gap between them, fixing an issue with gnome magnifier (Bill)
+
+Translations
+  * fi (Pauli Virtanen), ja (Takeshi AIHANA), ko (Young-Ho, Cha), 
+    pl (Gnome PL Team), ru (Dmitry G. Mastrukov), sr (Danilo <20>Ł<EFBFBD>egan),
+    tk (Gurban M. Tewekgeli), zh_CN (Funda Wang)
+
+2.8.2
+===
+
+Many bugfixes and better support for the freedesktop.org EWMH spec.
+
+Thanks to Rob Adams, Anders Carlsson, Elijah Newren, Soeren Sandmann,
+Emil Soleyman-Zomalan, Michael Terry, and Jeff Waugh for fixes in this
+release.
+
+  - set titlebar_uses_system_font = false (it was ugly)
+  - make naming for "move a window"/"move the window"/"move window"
+    more consistent (fixes #142235)
+  - Add trailing quotes to keybinding explanation text.
+  - support for EWMH update counter spec & add compensation events
+    when events are ignored. (fixes #143333 and #109362)
+  - Fix focus bugs: remove race condition on window close/minimize
+    (#131582), make focus choice consistent for each focus mode
+    (#135810), choose correct focus window when "un-showing the
+    desktop (#144900), make sure correct window is focused when using
+    the workspace switcher (#120100).
+  - Use meta_topic instead of meta_warning when failing to connect to
+    a session manager; reduces metacity verbosity. (fixes #136218)
+  - Make meta_window_delete take a timestamp, and be sure to pass it
+    one.
+  - Add support for EWMH _NET_WM_USER_TIME spec.  This enables part of
+    preventing focus stealing.  (bug #118372) Also fix bug with
+    windows not being focused on unminimizing caused by original
+    patch.  (also bug #118372)
+  - Fix some support for EWMH hints, and fix USER_TIME support to
+    include the DEMANDS_ATTENTION hint.  Also includes some code for
+    implementing _NET_RESTACK_WINDOW and _NET_MOVERESIZE_WINDOW, but
+    this is disabled pending feature thaw.
+
+2.8.1
+===
+
+Thanks to Olivier Crete, Jarrod Johnson, Neil Muller, Elijah Newren,
+Mark McLoughlin, Rob Adams, and foser AT gentoo.org for fixes in this
+release.
+
+  - make the --enable-xinerama switch work properly
+  - prevent unwanted grab op from occurring
+  - don't down-size nitems from a gulong to an int
+  - add a value type check for the visual/audible bell gconf settings
+  - make the no sm support warning resizable
+  - more translations
+
+2.8.0
+===
+
+No code changes in this release, but some new translations.
+
+2.7.1
+===
+
+Thanks to Rob Adams for fixes in this release.
+
+ - bug #122016 - fix a focus race
+ - Change move_to_workspace_left/right/up/down keybindings to
+   <Control><Alt><Shift> arrow to avoid conflicting with new
+   keybindings in spacial nautilus.
+ - fix dialog stacking order issues so e.g. panel properties 
+   dialog is above the panel
+
+2.7.0
+===
+
+First unstable release tarball for GNOME 2.6.
+
+Thanks to Anders Carlsson, Elijah Newren, Rob Adams, James Cape,
+Thomas Fitzimmons, Calum Benson for fixes in this release.
+
+2.6.2
+===
+
+Thanks to Yukihiro Nakai, Rached Ben Mustapha, Gwenole Beauchesne,
+Padraig O'Briain, Laurent Vivier, Rob Adams for contributions to this
+release.
+
+ - fix to repaint after resize always, so on maximize 
+   and theme changes we get things drawn properly
+ - fix a compile issue on HPUX
+ - fix translations of metacity-message output
+ - fix to update window icons when they change
+ - put a limit on number of characters displayed in 
+   window titles during Alt+tab
+ - fix configure check for Xrandr
+ - fix 64-bit bug in property reading that broke 
+   things badly on 64-bit
+ - don't move focus when clicking close button on a window
+ - fix a crash in getting pixmap icons
+ - spawn dialogs and child processes on the proper 
+   screen in multihead situations
+ - if the focus gets set to None, set it back to 
+   something sane
+ - load accessibility modules and set accessibility roles
+ - fix hang after displaying warning dialogs
+ - fix a memory corruption when sticking/unsticking windows
+   that lead to a frequent crash and windows appearing 
+   in Alt+tab improperly
+ - fix some handling of partial-width panel struts
+ - more translations
+
+2.6.1
+===
+
+ - rebuild with fixed glib-gettext.m4
+
+2.6.0
+===
+
+ - some additional translations
+
+2.5.5
+===
+
+ Thanks to Rob Adams, Arvind Samptur, Andreas Volz, Ray Strode, John
+ Paul Wallington, Soeren Sandmann for contributions to this release. 
+ And as always thanks to the translators.
+
+ - fix aspect ratio handling
+ - fix "shake loose" functionality for maximized windows
+ - handle Xrandr size changes properly again
+ - fix fullscreen window detection
+ - fix workspace name handling
+ - don't steal button press events on root window
+ - nuke metacity.spec due to nonmaintenance
+ - allow too-large-for-screen windows to move their titlebar offscreen
+ - keep an MRU list of windows per-workspace and use it to focus 
+   the next window when the focused window disappears
+ - fix cursor when moving
+ - improve appearance of opaque resize
+ - make BELOW window state work
+ - fix a crash when gdk_pixmap_foreign_new() returned NULL
+
+2.5.3
+===
+
+ Thanks to Jordi Mallach, Padraig O'Briain, Rob Adams, Julio Merino,
+ Ben Jansens, Jurg Billeter, Ray Strode, marcus@freebsd.org, James
+ Laska, for contributions to this release. Thanks also to 
+ all the tireless translators.
+
+ - fixups to .desktop file
+ - activate window prior to grab end, avoiding
+   extra focus events
+ - add support for partial-width panels (fixes corner panel 
+   and xinerama window position constraints)
+ - added keybinding to toggle window as "always on top"
+ - support --disable-schemas-install option to configure
+ - destroy support for legacy GNOME 1.x hints; metacity 
+   no longer works with GNOME 1.x
+ - disable raise-on-click for mouse focus modes
+ - fix bug that broke many Javascript popup menus with mozilla
+ - allow "shaking loose" maximized windows, to move them 
+   between Xinerama heads or whatever
+ - honor desktop-wide double click timeout
+ - handle window placement properly for windows that 
+   start out maximized
+ - integrate Ximian patch to go ahead and log out after 4 minutes
+   even if a dialog is open
+ - fix a segfault
+ - fix bug where window groups weren't always kept up to date
+ - fix bug where focus got confused when switching workspaces
+   with mouse focus mode
+ - fix 64-bit crash on s390x
+ - chdir to user's homedir on startup
+ - keep window in fullscreen layer when its transients are focused
+ - fix keybindings bug when you had ScrollLock enabled
+ - many translation updates
+
+2.5.2
+===
+
+ Thanks to David Santiago, Julien Olivier, Anders Carlsson, Rob Adams
+ for fixes in this release.
+
+ - improved wording/UI for some dialogs
+ - while clicking a window button, if you move the mouse outside 
+   the button such that releasing the mouse button won't activate 
+   the window button, visually indicate by "popping out" the button.
+ - fix some valgrind errors
+ - change "show desktop mode" to convert to "everything is minimized
+   mode" if you open a new window while showing desktop, rather 
+   than previous behavior of simply leaving show desktop mode.
+ - fix a trivial memory leak
+ - change "move to workspace N" so it doesn't switch workspaces, 
+   just moves the window.
+ - translation updates
+
+2.5.1
+===
+
+ Thanks to Rob Adams, Peter O'Shea, Dafydd Harries, Masahiro Sakai, 
+ Soeren Sandmann for fixes in this release.
+
+ - fix bug where fullscreen windows were below top panels
+ - build fix for Solaris
+ - support diagonal window movement with numeric keypad
+ - multihead fix
+ - build fix for Cygwin 
+ - place on xinerama containing the pointer
+ - fix totally hosed window placement/movement for frameless
+   windows
+ - improvement to smoothness of window move/resize
+
+2.5.0
+===
+
+ Thanks to Rob Adams, Owen Taylor, Frederic Crozat, Arvind Samptur,
+ Bill Haneman, Akira Tagoh for help with fixes in this release.
+
+ - many new translations
+ - fix an infinite loop while holding a server grab triggered by 
+   some recent Qt versions doing weird stuff
+ - fix bug where Alt+rightclick repeatedly on titlebar resulted 
+   in zillions of menus
+ - fix Alt+Tab to *actually* put minimized windows at the end, 
+   though this was always intended
+ - rewrite size/positions constraint code (currently known 
+   to be quite buggy, e.g. xmms is hosed)
+ - enforce size of at least 1x1 on windows
+ - reduce latency of managing new windows still further 
+   by using async properties code in more places
+ - don't grab keybindings on docks, so gnome-panel 
+   can handle them
+ - suck in the panel's screenshot and run dialog global 
+   bindings
+ - lots of improvements to window placement
+ - sync max number of workspaces with pager applet
+ - fix to keep focus when inside window frame in 
+   strict mouse focus mode
+ - make it possible to start a reverse tab with 
+   shift+alt+tab (vs. alt+tab then shift)
+ - fix a multihead issue with constraints between two 
+   windows on different heads
+ - require GTK+ 2.2.0 and fontconfig
+ - default theme is now Simple
+ - add visual bell feature
+ - incorporate many fixes from 2.4.34
+ - other stuff
+
 2.4.13
 ===
 

README

@@ -6,15 +6,18 @@ on UNIX keyboards.
 The first release of Metacity was version 2.3. Metacity has no need for
 your petty hangups about version numbers.
 
+The stable releases so far are 2.4.x, 2.6.x, 2.8.0, 2.8.1, 2.8.1.x, 2.8.5-6
+
+Unstable branches are 2.3.x, 2.5.x, 2.8.2-4, 2.9.x)
+
 COMPILING METACITY
 ===
 
-You need GTK+ 2.0, ideally the latest in the 2.0.x series.  For
-multihead/Xinerama support to work, you need GTK+ 2.2.  For
-startup notification to work you need libstartup-notification at
+You need GTK+ 2.2.  For startup notification to work you need
+libstartup-notification at
 http://www.freedesktop.org/software/startup-notification/ or on the
-GNOME ftp site. You also need GConf 1.2 (unless building a funky 
-extra-small embedded metacity with --disable-gconf).
+GNOME ftp site. You also need GConf 1.2 (unless building a funky
+extra-small embedded metacity with --disable-gconf, see below).
 
 REPORTING BUGS AND SUBMITTING PATCHES
 ===
@@ -36,9 +39,9 @@ See the HACKING file for some notes on hacking Metacity.
 SHRINKING METACITY
 ===
 
-Not that metacity is huge (<400K binary last I checked), but about
-half of that is in the preferences handling, in static strings that
-aren't essential, and in the theme engine.
+Not that metacity is huge, but a substantial amount of code is in
+preferences handling, in static strings that aren't essential, and in
+the theme engine.
 
 You can strip about 70K from the metacity binary by compiling with 
 options such as:
@@ -78,7 +81,7 @@ METACITY FEATURES
  - Does not expose the concept of "window manager" to the user.  Some
    of the features in the GNOME control panel and other parts of the
    desktop happen to be implemented in metacity, such as changing your
-   window border theme, or changing your window navigation shorcuts,
+   window border theme, or changing your window navigation shortcuts,
    but the user doesn't need to know this.
 
  - Includes only the window manager; does not try to be a desktop
@@ -184,11 +187,10 @@ METACITY FEATURES
      be respawned. It theoretically restores sizes/positions/workspace
      for session-aware applications.
 
- - Metacity implements much of the new window manager spec from
-   freedesktop.org
-   (http://www.freedesktop.org/standards/wm-spec.html), and much of
-   the ICCCM. But then there are parts of each that it doesn't
-   implement, just because I haven't yet.
+ - Metacity implements much of the EWMH window manager specification
+   from freedesktop.org, as well as the older ICCCM.  Please refer to
+   the COMPLIANCE file for information on metacity compliance with
+   these standards.
 
  - Uses Pango to render text, so has cool i18n capabilities. 
    Supports UTF-8 window titles and such.
@@ -367,9 +369,11 @@ A: This one is also in rationales.txt. Because "ouija board" UI, where
      http://pobox.com/~hp/free-software-ui.html
      http://pobox.com/~hp/features.html   
 
-Q: Why no wireframe move/resize?
+Q: Why does wireframe move/resize suck?
 
-A: Also in rationales.txt. Because it has low usability, and is a pain
+A: You can turn it on with the reduced_resources setting.
+
+   But: it has low usability, and is a pain
    to implement, and there's no reason opaque move/resize should be a
    problem on any setup that can run a modern desktop worth a darn to
    begin with.
@@ -378,6 +382,9 @@ A: Also in rationales.txt. Because it has low usability, and is a pain
      http://pobox.com/~hp/free-software-ui.html
      http://pobox.com/~hp/features.html   
 
+   The reason we had to add wireframe anyway was broken 
+   proprietary apps that can't handle lots of resize events.
+
 Q: Why no XYZ?
 
 A: You are probably getting the idea by now - check rationales.txt,

configure.in

@@ -3,9 +3,7 @@ AC_INIT(src/display.c)
 
 AM_CONFIG_HEADER(config.h)
 
-# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 
-# releases on a branch add a 4th version like 2.4.21.1
-AM_INIT_AUTOMAKE(metacity, 2.4.13)
+AM_INIT_AUTOMAKE(metacity, 2.9.0)
 
 # Honor aclocal flags
 ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"
@@ -20,8 +18,24 @@ AC_PROG_INTLTOOL([0.21])
 AC_PROG_CC
 AC_ISC_POSIX
 AC_HEADER_STDC
+AC_LIBTOOL_WIN32_DLL
 AM_PROG_LIBTOOL
 
+#### Integer sizes 
+
+AC_CHECK_SIZEOF(char)
+AC_CHECK_SIZEOF(short)
+AC_CHECK_SIZEOF(long)
+AC_CHECK_SIZEOF(int)
+AC_CHECK_SIZEOF(void *)
+AC_CHECK_SIZEOF(long long)
+AC_CHECK_SIZEOF(__int64)
+
+## byte order
+AC_C_BIGENDIAN
+
+#### Warnings
+
 changequote(,)dnl
 if test "x$GCC" = "xyes"; then
   case " $CFLAGS " in
@@ -83,7 +97,7 @@ if test "x$GCC" = "xyes"; then
 fi
 changequote([,])dnl
 
-METACITY_PC_MODULES='gtk+-2.0 >= 2.0.0'
+METACITY_PC_MODULES='gtk+-2.0 >= 2.2.0 pango >= 1.2.0'
 
 AC_ARG_ENABLE(config-dialog,      [  --enable-config-dialog      enable the config dialog that you need with GNOME 2.0 (obsolete with GNOME 2.2)],,enable_config_dialog=no)
 
@@ -109,25 +123,35 @@ AC_ARG_ENABLE(sm,       [  --disable-sm             disable metacity's session m
 
 AC_ARG_ENABLE(startup-notification,   [  --disable-startup-notification             disable metacity's startup notification support, for embedded/size-sensitive custom non-GNOME builds],,enable_startup_notification=auto)
 
+AC_ARG_ENABLE(compositor,   [  --disable-compositor             disable metacity's compositing manager],,enable_compositor=auto)
+
 AC_ARG_ENABLE(xsync,       [  --disable-xsync             disable metacity's use of the XSync extension],,enable_xsync=auto)
 
+AC_ARG_ENABLE(render,       [  --disable-render             disable metacity's use of the RENDER extension],,enable_render=auto)
+
 AC_ARG_ENABLE(shape,       [  --disable-shape             disable metacity's use of the shaped window extension],,enable_shape=auto)
 
 ## try definining HAVE_BACKTRACE
 AC_CHECK_HEADERS(execinfo.h, [AC_CHECK_FUNCS(backtrace)])
 
-ALL_LINGUAS="am az bg ca cs da de el es fi fr gl he hu it ja ko lv mk ms no pl pt pt_BR ro ru sk sv tr uk vi zh_CN zh_TW"
+ALL_LINGUAS="am ar az be bg bn bs ca cs cy da de el en_CA en_GB es et eu fa fi fr ga gl gu he hi hr hu id is it ja ko lt lv mk ml mn ms nb nl nn no or pa pl pt pt_BR ro ru sl sk sq sr sr@Latn sv ta th tk tr uk vi wa zh_CN zh_TW"
 AM_GLIB_GNU_GETTEXT
 
 ## here we get the flags we'll actually use
-PKG_CHECK_MODULES(METACITY_MESSAGE, gtk+-2.0 >= 2.0.0)
-PKG_CHECK_MODULES(METACITY_WINDOW_DEMO, gtk+-2.0 >= 2.0.0)
+PKG_CHECK_MODULES(METACITY_MESSAGE, gtk+-2.0 >= 2.2.0)
+PKG_CHECK_MODULES(METACITY_WINDOW_DEMO, gtk+-2.0 >= 2.2.0)
 
 if test x$enable_config_dialog = xyes; then
-   PKG_CHECK_MODULES(METACITY_PROPS, gtk+-2.0 >= 2.0.0 gconf-2.0 >= 1.1.9 libglade-2.0)
+   PKG_CHECK_MODULES(METACITY_PROPS, gtk+-2.0 >= 2.2.0 gconf-2.0 >= 1.1.9 libglade-2.0)
 fi
 
-STARTUP_NOTIFICATION_VERSION=0.4
+if $PKG_CONFIG --atleast-version 1.2.0 pangoxft; then
+   echo "pangoxft found"
+else
+   AC_MSG_ERROR("Pango 1.2.0 or greater based on Xft2 is required")
+fi
+
+STARTUP_NOTIFICATION_VERSION=0.7
 AC_MSG_CHECKING([Startup notification library >= $STARTUP_NOTIFICATION_VERSION])
 if $PKG_CONFIG --atleast-version $STARTUP_NOTIFICATION_VERSION libstartup-notification-1.0; then
    have_startup_notification=yes
@@ -153,14 +177,71 @@ else
   echo "Building without libstartup-notification"
 fi
 
-PKG_CHECK_MODULES(METACITY, $METACITY_PC_MODULES)
+## init this, it gets set either in the compositor check below 
+## or the render-specific check later
+have_xrender=no
 
-if $PKG_CONFIG --atleast-version 2.2.0 gtk+-2.0; then
-   AC_DEFINE(HAVE_GTK_MULTIHEAD,,[gtk+ with multihead support found])
-   with_multihead=yes
+XCOMPOSITE_VERSION=1.0
+AC_MSG_CHECKING([Xcomposite >= $XCOMPOSITE_VERSION])
+if $PKG_CONFIG --atleast-version $XCOMPOSITE_VERSION xcomposite; then
+   have_xcomposite=yes
 else
-   with_multihead=no
+   have_xcomposite=no
 fi
+AC_MSG_RESULT($have_xcomposite)
+
+if test x$enable_compositor = xyes; then
+   have_xcomposite=yes
+   echo "CompositeExt support forced on"
+elif test x$enable_compositor = xauto; then
+   echo "Not building compositing manager by default now, must enable explicitly to get it. And it doesn't work, so don't bother unless you want to hack on it..."
+   have_xcomposite=no
+else
+   have_xcomposite=no
+fi
+
+if test x$have_xcomposite = xyes; then
+  echo "Building with CompositeExt"
+  METACITY_PC_MODULES="$METACITY_PC_MODULES xcomposite >= $XCOMPOSITE_VERSION xfixes xrender xdamage"
+  AC_DEFINE(HAVE_COMPOSITE_EXTENSIONS, , [Building with compositing manager support])
+
+  ## force on render also
+  have_xrender=yes
+else
+  echo "Building without compositing manager"
+fi
+
+## if no compositor, still possibly enable render
+if test x$have_xcomposite = xno; then
+  XRENDER_VERSION=0.0
+  AC_MSG_CHECKING([xrender >= $XRENDER_VERSION])
+  if $PKG_CONFIG --atleast-version $XRENDER_VERSION xrender; then
+     have_xrender=yes
+  else
+     have_xrender=no
+  fi
+  AC_MSG_RESULT($have_xrender)
+
+  if test x$enable_render = xyes; then
+     have_xrender=yes
+     echo "Render support forced on"
+  elif test x$enable_render = xauto; then
+     true
+  else
+     have_xrender=no
+  fi
+
+  if test x$have_xrender = xyes; then
+     echo "Building with Render"
+     METACITY_PC_MODULES="$METACITY_PC_MODULES xrender >= $XRENDER_VERSION"
+  fi
+fi ## have_composite
+
+if test x$have_xrender = xyes; then
+  AC_DEFINE(HAVE_RENDER, , [Building with Render extension support])
+fi
+
+PKG_CHECK_MODULES(METACITY, $METACITY_PC_MODULES)
 
 AC_PATH_XTRA
 
@@ -170,46 +251,51 @@ ALL_X_LIBS="$X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
 metacity_save_cppflags="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS $X_CFLAGS"
 
+AC_ARG_ENABLE(xinerama,[  --disable-xinerama          disable metacity's use of the Xinerama extension],
+              try_xinerama=$enable_xinerama,try_xinerama=yes)
+
 use_solaris_xinerama=no
 use_xfree_xinerama=no
-case "$host" in
-    *-*-solaris*)
-        # Check for solaris
-        use_solaris_xinerama=yes
-        AC_CHECK_LIB(Xext, XineramaGetInfo,
-        	     use_solaris_xinerama=yes, use_solaris_xinerama=no,
-                     $ALL_X_LIBS)
-        if test "x$use_solaris_xinerama" = "xyes"; then
-            AC_CHECK_HEADER(X11/extensions/xinerama.h,
-                      	    if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
-                                X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
-        	            fi
-                            AC_DEFINE(HAVE_SOLARIS_XINERAMA, , [Have Solaris-style Xinerama])
-          	            AC_DEFINE(HAVE_XINERAMA, , [Have some version of Xinerama]),
-                            use_solaris_xinerama=no,
-                            [#include <X11/Xlib.h>])
-        fi	
-        AC_MSG_CHECKING(for Xinerama support on Solaris)
-        AC_MSG_RESULT($use_solaris_xinerama);
-        ;;
-    *)
-        # Check for XFree
-        use_xfree_xinerama=yes
-        AC_CHECK_LIB(Xinerama, XineramaQueryExtension,
-            [AC_CHECK_HEADER(X11/extensions/Xinerama.h,
-       	                     X_EXTRA_LIBS="-lXinerama $X_EXTRA_LIBS"   
-      	                     if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
-             	                 X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
-      	                     fi
-        	             AC_DEFINE(HAVE_XFREE_XINERAMA, , [Have XFree86-style Xinerama])
-      	                     AC_DEFINE(HAVE_XINERAMA,, [Have some version of Xinerama]), 
-      	                     use_xfree_xinerama=no,
-                             [#include <X11/Xlib.h>])],
-            use_xfree_xinerama=no, -lXext $ALL_X_LIBS)
-        AC_MSG_CHECKING(for Xinerama support on XFree86)
-        AC_MSG_RESULT($use_xfree_xinerama);
-        ;;
-esac
+if test "${try_xinerama}" != no; then
+    case "$host" in
+        *-*-solaris*)
+            # Check for solaris
+            use_solaris_xinerama=yes
+            AC_CHECK_LIB(Xext, XineramaGetInfo,
+                         use_solaris_xinerama=yes, use_solaris_xinerama=no,
+                         $ALL_X_LIBS)
+            if test "x$use_solaris_xinerama" = "xyes"; then
+                AC_CHECK_HEADER(X11/extensions/xinerama.h,
+                                if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
+                                    X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
+                                fi
+                                AC_DEFINE(HAVE_SOLARIS_XINERAMA, , [Have Solaris-style Xinerama])
+                                AC_DEFINE(HAVE_XINERAMA, , [Have some version of Xinerama]),
+                                use_solaris_xinerama=no,
+                                [#include <X11/Xlib.h>])
+            fi	
+            AC_MSG_CHECKING(for Xinerama support on Solaris)
+            AC_MSG_RESULT($use_solaris_xinerama);
+            ;;
+        *)
+            # Check for XFree
+            use_xfree_xinerama=yes
+            AC_CHECK_LIB(Xinerama, XineramaQueryExtension,
+                [AC_CHECK_HEADER(X11/extensions/Xinerama.h,
+                                 X_EXTRA_LIBS="-lXinerama $X_EXTRA_LIBS"   
+                                 if test -z "`echo $ALL_X_LIBS | grep "\-lXext" 2> /dev/null`"; then
+                                     X_EXTRA_LIBS="-lXext $X_EXTRA_LIBS"
+                                 fi
+                                 AC_DEFINE(HAVE_XFREE_XINERAMA, , [Have XFree86-style Xinerama])
+                                 AC_DEFINE(HAVE_XINERAMA,, [Have some version of Xinerama]), 
+                                 use_xfree_xinerama=no,
+                                 [#include <X11/Xlib.h>])],
+                use_xfree_xinerama=no, -lXext $ALL_X_LIBS)
+            AC_MSG_CHECKING(for Xinerama support on XFree86)
+            AC_MSG_RESULT($use_xfree_xinerama);
+            ;;
+    esac
+fi
 
 CPPFLAGS="$metacity_save_cppflags"
 
@@ -235,13 +321,24 @@ if test "x$found_shape" = "xyes"; then
    AC_DEFINE(HAVE_SHAPE, , [Have the shape extension library])
 fi
 
+found_xkb=no
+AC_CHECK_LIB(X11, XkbQueryExtension,
+               [AC_CHECK_HEADER(X11/XKBlib.h,
+                                found_xkb=yes)],
+	, $ALL_X_LIBS)
+
+if test "x$found_xkb" = "xyes"; then
+   AC_DEFINE(HAVE_XKB, , [Have keyboard extension library])
+fi
+
+
 RANDR_LIBS=
 found_randr=no
 AC_CHECK_LIB(Xrandr, XRRUpdateConfiguration,
                [AC_CHECK_HEADER(X11/extensions/Xrandr.h,
                                 RANDR_LIBS=-lXrandr found_randr=yes,,
 				[#include <X11/Xlib.h>])],
-               , -lXrender $ALL_X_LIBS)
+               , -lXrender -lXext $ALL_X_LIBS)
 
 if test "x$found_randr" = "xyes"; then
    AC_DEFINE(HAVE_RANDR, , [Have the Xrandr extension library])
@@ -341,7 +438,6 @@ src/libmetacity-private.pc
 src/tools/Makefile
 src/themes/Makefile
 po/Makefile.in
-metacity.spec
 ])
 
 if test x$enable_gconf = xno; then
@@ -373,11 +469,14 @@ metacity-$VERSION:
 	GConf:                    ${enable_gconf}
 	XFree86 Xinerama:         ${use_xfree_xinerama}
 	Solaris Xinerama:         ${use_solaris_xinerama}
-	Multihead:                ${with_multihead}
 	Startup notification:     ${have_startup_notification}
+	Compositing manager:      ${have_xcomposite}
 	Session management:       ${found_sm}
 	Shape extension:          ${found_shape}
 	Resize-and-rotate:        ${found_randr}
 	Xsync:                    ${found_xsync}
+	Render:                   ${have_xrender}
         Deprecated config dialog: ${enable_config_dialog}
 "
+echo "This is the UNSTABLE branch of metacity"
+echo "Use 2.8.x (where x > 5) for stable (gnome-2-8 branch in CVS)"

doc/Makefile.am

@@ -1,2 +1,2 @@
 
-EXTRA_DIST=theme-format.txt metacity-theme.dtd
+EXTRA_DIST=theme-format.txt metacity-theme.dtd dialogs.txt

doc/dialogs.txt

@@ -0,0 +1,32 @@
+Dialogs which have no transient parent or root window being 
+their tranisent parent are the ones which will be visible in 
+the tasklist. 
+
+All such dialogs will be *always* on top of the window
+group i.e they would transients for the whole group.
+
+
+1) Modal dialogs 
+
+   
+   * If you wish to open another window from a modal dialog 
+
+     open *only* a modal dialog and set it's transient parent.
+     
+	 
+2) Normal dialog
+
+    
+   without transient parent
+
+   * If you wish to open another window from a normal dialog
+
+     open either a normal dialog or a modal dialog only.
+     Set the transient parent for the child dialog if you do not
+     want them to be transient for all the other windows in the group.
+     
+   with transient parent 
+ 
+   * If you wish to open another window from a normal dialog
+     
+     you could open any type of window.

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

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

metacity.spec.in

@@ -1,87 +0,0 @@
-%define ver @VERSION@
-%define RELEASE 1
-%define rel %{?CUSTOM_RELEASE} %{!?CUSTOM_RELEASE:%RELEASE}
-
-Summary: Metacity window manager
-Name: metacity
-Version: %ver
-Release: %rel
-URL: http://people.redhat.com/~hp/metacity/
-Source0: %{name}-%{version}.tar.gz
-License: GPL
-Group: User Interface/Desktops
-BuildRoot: %{_tmppath}/%{name}-root
-BuildRequires: gtk2-devel >= 2.0.0
-BuildRequires: GConf2-devel >= 1.1.9
-
-%description
-
-Metacity is a simple window manager that integrates nicely with 
-GNOME 2.
-
-%prep
-%setup -q
-
-%build
-%configure
-make %{?_smp_mflags}
-
-%install
-rm -rf $RPM_BUILD_ROOT
-
-export GCONF_DISABLE_MAKEFILE_SCHEMA_INSTALL=1
-%makeinstall
-unset GCONF_DISABLE_MAKEFILE_SCHEMA_INSTALL
-
-%clean
-rm -rf $RPM_BUILD_ROOT
-
-%post
-
-export GCONF_CONFIG_SOURCE=`gconftool-2 --get-default-source`
-SCHEMAS="metacity.schemas"
-for S in $SCHEMAS; do
-  gconftool-2 --makefile-install-rule %{_sysconfdir}/gconf/schemas/$S > /dev/null
-done
-
-%files
-%defattr(-,root,root)
-%doc README AUTHORS COPYING NEWS HACKING theme-format.txt
-%{_bindir}/*
-%{_libexecdir}/*
-%{_datadir}/gnome/wm-properties/*
-%{_sysconfdir}/gconf/schemas/*.schemas
-%{_datadir}/control-center-2.0/capplets/*
-%{_datadir}/metacity
-%{_datadir}/pixmaps/*
-%{_datadir}/themes/*
-
-%changelog
-* Tue Aug 20 2002 Steve Fox <drfickle@k-lug.org>
-- Autoconf-ize the spec file to magic updates
-- Include missing dirs
-
-* Thu May  2 2002 Havoc Pennington <hp@redhat.com>
-- 2.3.233
-
-* Thu Apr 25 2002 Havoc Pennington <hp@redhat.com>
-- rebuild in different environment
-- add gconf schemas boilerplate
-
-* Mon Apr 15 2002 Havoc Pennington <hp@pobox.com>
-- 2.3.89
-
-* Tue Oct 30 2001 Havoc Pennington <hp@redhat.com>
-- 2.3.34
-
-* Fri Oct 13 2001 Havoc Pennington <hp@redhat.com>
-- 2.3.21 
-
-* Mon Sep 17 2001 Havoc Pennington <hp@redhat.com>
-- 2.3.8
-- 2.3.13
-
-* Wed Sep  5 2001 Havoc Pennington <hp@redhat.com>
-- Initial build.
-
-

po/POTFILES.in

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

rationales.txt

@@ -1,8 +1,61 @@
 
-Focus windows on map: see http://bugzilla.gnome.org/show_bug.cgi?id=82921
-Keep panel always on top: http://bugzilla.gnome.org/show_bug.cgi?id=81551
-Edge flipping: http://bugzilla.gnome.org/show_bug.cgi?id=82917
-Opaque resize: http://bugzilla.gnome.org/show_bug.cgi?id=92618
-Super+click to resize: http://bugzilla.gnome.org/show_bug.cgi?id=79315
-minimized windows in Alt+tab: http://bugzilla.gnome.org/show_bug.cgi?id=89416
-raise windows on click: http://bugzilla.gnome.org/show_bug.cgi?id=86108
+History
+====
+
+Focus issues:
+  see doc/how-to-get-focus-right.txt
+
+Keep panel always on top:
+  http://bugzilla.gnome.org/show_bug.cgi?id=81551
+
+Edge flipping:
+  http://bugzilla.gnome.org/show_bug.cgi?id=82917
+
+Opaque resize:
+  http://bugzilla.gnome.org/show_bug.cgi?id=92618
+
+Alt+click to move/resize:
+  http://bugzilla.gnome.org/show_bug.cgi?id=101151
+  https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=80918
+
+minimized windows in Alt+tab:
+  http://bugzilla.gnome.org/show_bug.cgi?id=89416
+
+dialogs above entire app group:
+  http://bugzilla.gnome.org/show_bug.cgi?id=88926
+
+display window size/position: 
+  http://bugzilla.gnome.org/show_bug.cgi?id=85213
+  http://bugzilla.gnome.org/show_bug.cgi?id=106645
+  http://bugzilla.gnome.org/show_bug.cgi?id=130821
+
+configure click actions, alt+click:
+  http://bugzilla.gnome.org/show_bug.cgi?id=83210
+
+system modal dialogs:
+  http://bugzilla.gnome.org/show_bug.cgi?id=83357
+
+workspace wrapping:
+  http://bugzilla.gnome.org/show_bug.cgi?id=89315
+
+raise windows on click:
+  http://bugzilla.gnome.org/show_bug.cgi?id=86108
+  http://bugzilla.gnome.org/show_bug.cgi?id=115072
+  http://bugzilla.gnome.org/show_bug.cgi?id=115753
+
+
+Tracking bugs
+====
+
+          revise theme format: http://bugzilla.gnome.org/show_bug.cgi?id=102547
+           session management: http://bugzilla.gnome.org/show_bug.cgi?id=107063
+    focus-stealing-prevention: http://bugzilla.gnome.org/show_bug.cgi?id=149028
+             other focus bugs: http://bugzilla.gnome.org/show_bug.cgi?id=155450
+                drag-and-drop: http://bugzilla.gnome.org/show_bug.cgi?id=155451
+             raising/stacking: http://bugzilla.gnome.org/show_bug.cgi?id=155452
+  tasklist/workspace switcher: http://bugzilla.gnome.org/show_bug.cgi?id=155453
+   window/workspace selection: http://bugzilla.gnome.org/show_bug.cgi?id=155456
+    key/mouse-binding actions: http://bugzilla.gnome.org/show_bug.cgi?id=155457
+moving/resizing (constraints): http://bugzilla.gnome.org/show_bug.cgi?id=155458
+             window placement: http://bugzilla.gnome.org/show_bug.cgi?id=155460
+   logout/system-monitor keys: http://bugzilla.gnome.org/show_bug.cgi?id=155462

src/Makefile.am

@@ -2,7 +2,7 @@ lib_LTLIBRARIES = libmetacity-private.la
 
 SUBDIRS=wm-tester tools themes
 
-INCLUDES=@METACITY_CFLAGS@ -DMETACITY_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMETACITY_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMETACITY_PKGDATADIR=\"$(pkgdatadir)\" -DMETACITY_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"metacity\" -DSN_API_NOT_YET_FROZEN=1
+INCLUDES=@METACITY_CFLAGS@ -DMETACITY_LIBEXECDIR=\"$(libexecdir)\" -DMETACITY_LIBDIR=\"$(libdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMETACITY_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMETACITY_PKGDATADIR=\"$(pkgdatadir)\" -DMETACITY_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"metacity\" -DSN_API_NOT_YET_FROZEN=1
 
 EGGFILES=			\
 	eggaccelerators.c	\
@@ -11,7 +11,13 @@ EGGFILES=			\
 metacity_SOURCES= 				\
 	async-getprop.c				\
 	async-getprop.h				\
+	bell.h					\
+	bell.c					\
 	common.h				\
+	compositor.c				\
+	compositor.h				\
+	constraints.c				\
+	constraints.h				\
 	core.c					\
 	core.h					\
 	delete.c				\
@@ -97,6 +103,9 @@ libmetacity_private_la_SOURCES=	\
 	util.h			\
 	common.h
 
+libmetacity_private_la_LDFLAGS = -no-undefined
+libmetacity_private_la_LIBADD  = @METACITY_LIBS@
+
 libmetacityincludedir = $(includedir)/metacity-1/metacity-private
 
 libmetacityinclude_HEADERS =	\
@@ -141,8 +150,12 @@ schema_DATA = $(schema_in_files:.schemas.in=.schemas)
 
 @INTLTOOL_SCHEMAS_RULE@
 
+if GCONF_SCHEMAS_INSTALL
 install-data-local:
 	GCONF_CONFIG_SOURCE=$(GCONF_SCHEMA_CONFIG_SOURCE) $(GCONFTOOL) --makefile-install-rule $(srcdir)/$(schema_DATA)
+else
+install-data-local:
+endif
 
 IMAGES=default_icon.png stock_maximize.png stock_minimize.png stock_delete.png
 VARIABLES=default_icon_data $(srcdir)/default_icon.png \

src/async-getprop.c

@@ -347,8 +347,9 @@ async_get_property_handler (Display *dpy,
           break;
 
         case 32:
+          /* NOTE buffer is in longs to match XGetWindowProperty() */
           nbytes = reply->nItems * sizeof (long);
-          netbytes = reply->nItems << 2;
+          netbytes = reply->nItems << 2; /* wire size is always 32 bits though */
           if (nbytes + 1 > 0 &&
               (task->data = (unsigned char *) Xmalloc ((unsigned)nbytes + 1)))
             {
@@ -356,10 +357,41 @@ async_get_property_handler (Display *dpy,
               printf ("%s: already read %d bytes using %ld more, eating %ld more\n",
                       __FUNCTION__, bytes_read, nbytes, netbytes);
 #endif
-              /* _XRead32 (dpy, (long *) task->data, netbytes); */
-              _XGetAsyncData (dpy, task->data, buf, len,
-                              bytes_read, nbytes,
-                              netbytes);
+
+              /* We have to copy the XGetWindowProperty() crackrock
+               * and get format 32 as long even on 64-bit platforms.
+               */
+              if (sizeof (long) == 8)
+                {
+                  unsigned char *netdata;
+                  unsigned char *lptr;
+                  unsigned char *end_lptr;
+                  
+                  /* Store the 32-bit values in the end of the array */
+                  netdata = task->data + nbytes / 2;
+
+                  _XGetAsyncData (dpy, netdata, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+
+                  /* Now move the 32-bit values to the front */
+                  
+                  lptr = task->data;
+                  end_lptr = task->data + nbytes;
+                  while (lptr != end_lptr)
+                    {
+                      *(long*) lptr = *(CARD32*) netdata;
+                      lptr += sizeof (long);
+                      netdata += sizeof (CARD32);
+                    }
+                }
+              else
+                {
+                  /* Here the wire format matches our actual format */
+                  _XGetAsyncData (dpy, task->data, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+                }
             }
           break;
 

src/bell.c

@@ -34,7 +34,7 @@ meta_bell_flash_screen (MetaDisplay *display,
   
   if (screen->flash_window == None)
     {
-      Visual *visual = CopyFromParent;
+      Visual *visual = (Visual *)CopyFromParent;
       XSetWindowAttributes xswa;
       int depth = CopyFromParent;
       xswa.save_under = True;
@@ -136,7 +136,7 @@ meta_bell_flash_frame (MetaDisplay *display,
   
   g_assert (xkb_ev->xkb_type == XkbBellNotify);
   window = meta_display_lookup_x_window (display, xkb_bell_event->window);
-  if (!window && (display->focus_window->frame))
+  if (!window && (display->focus_window) && (display->focus_window->frame))
     {
       window = display->focus_window;
     }

src/bell.h

@@ -19,6 +19,7 @@
  * 02111-1307, USA.
  */
 
+#include <X11/Xlib.h>
 #ifdef HAVE_XKB
 #include <X11/XKBlib.h>
 #endif

src/common.h

@@ -42,7 +42,8 @@ typedef enum
   META_FRAME_MAXIMIZED                = 1 << 9,
   META_FRAME_ALLOWS_SHADE             = 1 << 10,
   META_FRAME_ALLOWS_MOVE              = 1 << 11,
-  META_FRAME_FULLSCREEN               = 1 << 12
+  META_FRAME_FULLSCREEN               = 1 << 12,
+  META_FRAME_IS_FLASHING              = 1 << 13
 } MetaFrameFlags;
 
 typedef enum
@@ -57,7 +58,13 @@ typedef enum
   META_MENU_OP_STICK       = 1 << 7,
   META_MENU_OP_WORKSPACES  = 1 << 8,
   META_MENU_OP_MOVE        = 1 << 9,
-  META_MENU_OP_RESIZE      = 1 << 10
+  META_MENU_OP_RESIZE      = 1 << 10,
+  META_MENU_OP_ABOVE       = 1 << 11,
+  META_MENU_OP_UNABOVE     = 1 << 12,
+  META_MENU_OP_MOVE_LEFT   = 1 << 13,
+  META_MENU_OP_MOVE_RIGHT  = 1 << 14,
+  META_MENU_OP_MOVE_UP     = 1 << 15,
+  META_MENU_OP_MOVE_DOWN   = 1 << 16
 } MetaMenuOp;
 
 typedef struct _MetaWindowMenu MetaWindowMenu;
@@ -65,6 +72,7 @@ typedef struct _MetaWindowMenu MetaWindowMenu;
 typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu,
                                      Display        *xdisplay,
                                      Window          client_xwindow,
+				     Time	     timestamp,
                                      MetaMenuOp      op,
                                      int             workspace,
                                      gpointer        data);

src/compositor.h

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

src/core.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -235,8 +236,9 @@ meta_core_user_raise (Display *xdisplay,
 }
 
 void
-meta_core_user_lower (Display *xdisplay,
-                      Window   frame_xwindow)
+meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                  Window   frame_xwindow,
+                                  Time     timestamp)
 {
   MetaDisplay *display;
   MetaWindow *window;
@@ -248,6 +250,38 @@ meta_core_user_lower (Display *xdisplay,
     meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
   
   meta_window_lower (window);
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+    {
+      /* Move window to the back of the focusing workspace's MRU list.
+       * Do extra sanity checks to avoid possible race conditions.
+       * (Borrowed from window.c.)
+       */
+      if (window->screen->active_workspace &&
+          meta_window_visible_on_workspace (window, 
+                                            window->screen->active_workspace))
+        {
+          GList* link;
+          link = g_list_find (window->screen->active_workspace->mru_list, 
+                              window);
+          g_assert (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_remove_link (window->screen->active_workspace->mru_list,
+                                link);
+          g_list_free (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_append (window->screen->active_workspace->mru_list, 
+                           window);
+        }
+    }
+
+  /* focus the default window, if needed */
+  if (window->has_focus)
+    meta_workspace_focus_default_window (window->screen->active_workspace,
+                                         NULL,
+                                         timestamp);
 }
 
 void
@@ -586,17 +620,17 @@ meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
       name = META_KEYBINDING_MAXIMIZE;
       break;
     case META_MENU_OP_UNSHADE:
-      name = META_KEYBINDING_TOGGLE_SHADE;
-      break;
     case META_MENU_OP_SHADE:
       name = META_KEYBINDING_TOGGLE_SHADE;
       break;
     case META_MENU_OP_UNSTICK:
-      name = META_KEYBINDING_TOGGLE_STICKY;
-      break;
     case META_MENU_OP_STICK:
       name = META_KEYBINDING_TOGGLE_STICKY;
       break;
+    case META_MENU_OP_ABOVE:
+    case META_MENU_OP_UNABOVE:
+      name = META_KEYBINDING_TOGGLE_ABOVE;
+      break;
     case META_MENU_OP_WORKSPACES:
       switch (workspace)
         {
@@ -644,6 +678,18 @@ meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
     case META_MENU_OP_RESIZE:
       name = META_KEYBINDING_BEGIN_RESIZE;
       break;
+    case META_MENU_OP_MOVE_LEFT:
+      name = META_KEYBINDING_MOVE_WORKSPACE_LEFT;
+      break;
+    case META_MENU_OP_MOVE_RIGHT:
+      name = META_KEYBINDING_MOVE_WORKSPACE_RIGHT;
+      break;
+    case META_MENU_OP_MOVE_UP:
+      name = META_KEYBINDING_MOVE_WORKSPACE_UP;
+      break;
+    case META_MENU_OP_MOVE_DOWN:
+      name = META_KEYBINDING_MOVE_WORKSPACE_DOWN;
+      break;
     }
 
   if (name)
@@ -678,6 +724,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
                          Window      frame_xwindow,
                          MetaGrabOp  op,
                          gboolean    pointer_already_grabbed,
+                         int         event_serial,
                          int         button,
                          gulong      modmask,
                          Time        timestamp,
@@ -699,6 +746,7 @@ meta_core_begin_grab_op (Display    *xdisplay,
 
   return meta_display_begin_grab_op (display, screen, window,
                                      op, pointer_already_grabbed,
+                                     event_serial,
                                      button, modmask,
                                      timestamp, root_x, root_y);
 }

src/core.h

@@ -60,8 +60,9 @@ void meta_core_user_resize  (Display *xdisplay,
 
 void meta_core_user_raise   (Display *xdisplay,
                              Window   frame_xwindow);
-void meta_core_user_lower   (Display *xdisplay,
-                             Window   frame_xwindow);
+void meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                       Window   frame_xwindow,
+                                       Time     timestamp);
 
 void meta_core_user_focus   (Display *xdisplay,
                              Window   frame_xwindow,
@@ -133,6 +134,7 @@ gboolean   meta_core_begin_grab_op (Display    *xdisplay,
                                     Window      frame_xwindow,
                                     MetaGrabOp  op,
                                     gboolean    pointer_already_grabbed,
+                                    int         event_serial,
                                     int         button,
                                     gulong      modmask,
                                     Time        timestamp,
@@ -163,6 +165,8 @@ void       meta_core_get_screen_size (Display *xdisplay,
  */
 void meta_core_increment_event_serial (Display *display);
 
+int meta_ui_get_last_event_serial (Display *xdisplay);
+
 #endif
 
 

src/delete.c

@@ -23,6 +23,7 @@
 #include "util.h"
 #include "window.h"
 #include "errors.h"
+#include "workspace.h"
 
 #include <sys/types.h>
 #include <signal.h>
@@ -30,12 +31,14 @@
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
+#include <stdio.h>
 
 static void meta_window_present_delete_dialog (MetaWindow *window);
 
 static void
 delete_ping_reply_func (MetaDisplay *display,
                         Window       xwindow,
+                        Time         timestamp,
                         void        *user_data)
 {
   meta_topic (META_DEBUG_PING,
@@ -288,13 +291,16 @@ io_from_ping_dialog (GIOChannel   *channel,
 static void
 delete_ping_timeout_func (MetaDisplay *display,
                           Window       xwindow,
+                          Time         timestamp,
                           void        *user_data)
 {
   MetaWindow *window = user_data;
   GError *err;
   int child_pid;
   int outpipe;
-  char *argv[5];
+  char *argv[9];
+  char numbuf[32];
+  char timestampbuf[32];
   char *window_id_str;
   GIOChannel *channel;
   
@@ -309,12 +315,19 @@ delete_ping_timeout_func (MetaDisplay *display,
     }
   
   window_id_str = g_strdup_printf ("0x%lx", window->xwindow);
+
+  sprintf (numbuf, "%d", window->screen->number);
+  sprintf (timestampbuf, "%lu", timestamp);
   
   argv[0] = METACITY_LIBEXECDIR"/metacity-dialog";
-  argv[1] = "--kill-window-question";
-  argv[2] = window->title;
-  argv[3] = window_id_str;
-  argv[4] = NULL;
+  argv[1] = "--screen";
+  argv[2] = numbuf;
+  argv[3] = "--timestamp";
+  argv[4] = timestampbuf;
+  argv[5] = "--kill-window-question";
+  argv[6] = window->title;
+  argv[7] = window_id_str;
+  argv[8] = NULL;
   
   err = NULL;
   if (!g_spawn_async_with_pipes ("/",
@@ -380,14 +393,24 @@ meta_window_delete (MetaWindow  *window,
   
   if (window->has_focus)
     {
+      /* FIXME Clean this up someday 
+       * http://bugzilla.gnome.org/show_bug.cgi?id=108706
+       */
+#if 0
       /* This is unfortunately going to result in weirdness
        * if the window doesn't respond to the delete event.
        * I don't know how to avoid that though.
        */
       meta_topic (META_DEBUG_FOCUS,
-                  "Focusing top window because focus window %s was deleted/killed\n",
+                  "Focusing default window because focus window %s was deleted/killed\n",
                   window->desc);
-      meta_screen_focus_top_window (window->screen, window);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window);
+#else
+      meta_topic (META_DEBUG_FOCUS,
+                  "Not unfocusing %s on delete/kill\n",
+                  window->desc);
+#endif
     }
   else
     {

src/display.h

@@ -3,6 +3,7 @@
 /* 
  * Copyright (C) 2001 Havoc Pennington
  * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -53,6 +54,7 @@ struct _MetaRectangle
   int height;
 };
 
+typedef struct MetaCompositor  MetaCompositor;
 typedef struct _MetaDisplay    MetaDisplay;
 typedef struct _MetaFrame      MetaFrame;
 typedef struct _MetaKeyBinding MetaKeyBinding;
@@ -67,6 +69,7 @@ typedef struct _MetaGroupPropHooks  MetaGroupPropHooks;
 
 typedef void (* MetaWindowPingFunc) (MetaDisplay *display,
 				     Window       xwindow,
+				     Time         timestamp,
 				     gpointer     user_data);
 
 
@@ -120,10 +123,6 @@ struct _MetaDisplay
   Atom atom_net_client_list_stacking;
   Atom atom_net_wm_state_skip_taskbar;
   Atom atom_net_wm_state_skip_pager;
-  Atom atom_win_workspace;
-  Atom atom_win_layer;
-  Atom atom_win_protocols;
-  Atom atom_win_supporting_wm_check;
   Atom atom_net_wm_icon_name;
   Atom atom_net_wm_icon;
   Atom atom_net_wm_icon_geometry;
@@ -134,7 +133,6 @@ struct _MetaDisplay
   Atom atom_net_active_window;
   Atom atom_metacity_restart_message;
   Atom atom_net_wm_strut;
-  Atom atom_win_hints;
   Atom atom_metacity_reload_theme_message;
   Atom atom_metacity_set_keybindings_message;
   Atom atom_net_wm_state_hidden;
@@ -157,6 +155,8 @@ struct _MetaDisplay
   Atom atom_net_wm_allowed_actions;
   Atom atom_net_wm_action_move;
   Atom atom_net_wm_action_resize;
+  Atom atom_net_wm_action_fullscreen;
+  Atom atom_net_wm_action_minimize;
   Atom atom_net_wm_action_shade;
   Atom atom_net_wm_action_stick;
   Atom atom_net_wm_action_maximize_horz;
@@ -167,23 +167,35 @@ struct _MetaDisplay
   Atom atom_net_wm_state_below;
   Atom atom_net_startup_id;
   Atom atom_metacity_toggle_verbose;
-  Atom atom_metacity_update_counter;
-  Atom atom_sync_counter;
-  
+  Atom atom_net_wm_sync_request;
+  Atom atom_net_wm_sync_request_counter;
+  Atom atom_gnome_panel_action;
+  Atom atom_gnome_panel_action_main_menu;
+  Atom atom_gnome_panel_action_run_dialog;
+  Atom atom_metacity_sentinel;
+  Atom atom_net_wm_strut_partial;
+  Atom atom_net_frame_extents;
+  Atom atom_net_request_frame_extents;
+  Atom atom_net_wm_user_time;
+  Atom atom_net_wm_state_demands_attention;
+  Atom atom_net_restack_window;
+  Atom atom_net_moveresize_window;
+  Atom atom_net_desktop_geometry;
+  Atom atom_net_desktop_viewport;
+
   /* This is the actual window from focus events,
    * not the one we last set
    */
   MetaWindow *focus_window;
 
+ /* Window that was the actual window from focus events before focus_window
+  */
+  MetaWindow *previously_focused_window;
+
   /* window we are expecting a FocusIn event for
    */
   MetaWindow *expected_focus_window;
 
-  /* Most recently focused list. Always contains all
-   * live windows.
-   */
-  GList *mru_list;  
-
   guint static_gravity_works : 1;
   
   /*< private-ish >*/
@@ -202,7 +214,6 @@ struct _MetaDisplay
   Window no_focus_window;
   
   /* for double click */
-  int double_click_time;
   Time last_button_time;
   Window last_button_xwindow;
   int last_button_num;
@@ -222,6 +233,7 @@ struct _MetaDisplay
 
   /* Pending autoraise */
   guint       autoraise_timeout_id;
+  MetaWindow* autoraise_window;
 
   /* Alt+click button grabs */
   unsigned int window_grab_modifiers;
@@ -231,32 +243,46 @@ struct _MetaDisplay
   MetaScreen *grab_screen;
   MetaWindow *grab_window;
   Window      grab_xwindow;
+  gulong      grab_start_serial;
   int         grab_button;
-  int         grab_initial_root_x;
-  int         grab_initial_root_y;
-  int         grab_current_root_x;
-  int         grab_current_root_y;
+  int         grab_anchor_root_x;
+  int         grab_anchor_root_y;
+  MetaRectangle grab_anchor_window_pos;
   int         grab_latest_motion_x;
   int         grab_latest_motion_y;
   gulong      grab_mask;
   guint       grab_have_pointer : 1;
   guint       grab_have_keyboard : 1;
+  guint       grab_wireframe_active : 1;
+  guint       grab_was_cancelled : 1;
+  MetaRectangle grab_wireframe_rect;
+  MetaRectangle grab_wireframe_last_xor_rect;
   MetaRectangle grab_initial_window_pos;
-  MetaRectangle grab_current_window_pos;
   MetaResizePopup *grab_resize_popup;
   GTimeVal    grab_last_moveresize_time;
-#ifdef HAVE_XSYNC
-  /* alarm monitoring client's _METACITY_UPDATE_COUNTER */
-  XSyncAlarm  grab_update_alarm;
+  Time        grab_motion_notify_time;
+  
+  /* we use property updates as sentinels for certain window focus events
+   * to avoid some race conditions on EnterNotify events
+   */
+  int         sentinel_counter;
+
+#ifdef HAVE_XKB
+  int         xkb_base_event_type;
 #endif
+#ifdef HAVE_XSYNC
+  /* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */
+  XSyncAlarm  grab_sync_request_alarm;
+#endif
+  int	      grab_resize_timeout_id;
 
   /* Keybindings stuff */
   MetaKeyBinding *screen_bindings;
   int             n_screen_bindings;
   MetaKeyBinding *window_bindings;
   int             n_window_bindings;
-  int min_keycode;
-  int max_keycode;
+  unsigned int min_keycode;
+  unsigned int max_keycode;
   KeySym *keymap;
   int keysyms_per_keycode;
   XModifierKeymap *modmap;
@@ -285,6 +311,9 @@ struct _MetaDisplay
 
   /* Managed by group-props.c */
   MetaGroupPropHooks *group_prop_hooks;
+
+  /* Managed by compositor.c */
+  MetaCompositor *compositor;
   
 #ifdef HAVE_STARTUP_NOTIFICATION
   SnDisplay *sn_display;
@@ -292,17 +321,33 @@ struct _MetaDisplay
 #ifdef HAVE_XSYNC
   int xsync_event_base;
   int xsync_error_base;
-#define META_DISPLAY_HAS_XSYNC(display) ((display)->xsync_event_base != 0)
-#else
-#define META_DISPLAY_HAS_XSYNC(display) FALSE
 #endif
 #ifdef HAVE_SHAPE
   int shape_event_base;
   int shape_error_base;
-#define META_DISPLAY_HAS_SHAPE(display) ((display)->shape_event_base != 0)
+#endif
+#ifdef HAVE_RENDER
+  int render_event_base;
+  int render_error_base;
+#endif
+#ifdef HAVE_XSYNC
+  unsigned int have_xsync : 1;
+#define META_DISPLAY_HAS_XSYNC(display) ((display)->have_xsync)
+#else
+#define META_DISPLAY_HAS_XSYNC(display) FALSE
+#endif
+#ifdef HAVE_SHAPE
+  unsigned int have_shape : 1;
+#define META_DISPLAY_HAS_SHAPE(display) ((display)->have_shape)
 #else
 #define META_DISPLAY_HAS_SHAPE(display) FALSE
 #endif
+#ifdef HAVE_RENDER
+  unsigned int have_render : 1;
+#define META_DISPLAY_HAS_RENDER(display) ((display)->have_render)
+#else
+#define META_DISPLAY_HAS_RENDER(display) FALSE
+#endif
 };
 
 gboolean      meta_display_open                (const char  *name);
@@ -354,6 +399,7 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display,
                                      MetaWindow  *window,
                                      MetaGrabOp   op,
                                      gboolean     pointer_already_grabbed,
+                                     int          event_serial,
                                      int          button,
                                      gulong       modmask,
                                      Time         timestamp,
@@ -368,16 +414,17 @@ void     meta_display_ungrab_window_buttons  (MetaDisplay *display,
                                               Window       xwindow);
 
 void meta_display_grab_focus_window_button   (MetaDisplay *display,
-                                              Window       xwindow);
+                                              MetaWindow  *window);
 void meta_display_ungrab_focus_window_button (MetaDisplay *display,
-                                              Window       xwindow);
+                                              MetaWindow  *window);
 
 /* make a request to ensure the event serial has changed */
 void     meta_display_increment_event_serial (MetaDisplay *display);
 
 void     meta_display_update_active_window_hint (MetaDisplay *display);
 
-guint32  meta_display_get_current_time (MetaDisplay *display);
+guint32  meta_display_get_current_time           (MetaDisplay *display);
+guint32  meta_display_get_current_time_roundtrip (MetaDisplay *display);
 
 /* utility goo */
 const char* meta_event_mode_to_string   (int m);
@@ -403,10 +450,10 @@ typedef enum
 
 } MetaTabList;
 
-GSList* meta_display_get_tab_list (MetaDisplay   *display,
-                                   MetaTabList    type,
-                                   MetaScreen    *screen,
-                                   MetaWorkspace *workspace);
+GList* meta_display_get_tab_list (MetaDisplay   *display,
+                                  MetaTabList    type,
+                                  MetaScreen    *screen,
+                                  MetaWorkspace *workspace);
 
 MetaWindow* meta_display_get_tab_next (MetaDisplay   *display,
                                        MetaTabList    type,
@@ -428,9 +475,21 @@ gboolean meta_grab_op_is_resizing (MetaGrabOp op);
 gboolean meta_rectangle_intersect (MetaRectangle *src1,
                                    MetaRectangle *src2,
                                    MetaRectangle *dest);
+gboolean meta_rectangle_equal (const MetaRectangle *src1,
+                               const MetaRectangle *src2);
 
 void meta_display_devirtualize_modifiers (MetaDisplay        *display,
                                           MetaVirtualModifier modifiers,
                                           unsigned int       *mask);
 
+void meta_display_increment_focus_sentinel (MetaDisplay *display);
+void meta_display_decrement_focus_sentinel (MetaDisplay *display);
+gboolean meta_display_focus_sentinel_clear (MetaDisplay *display);
+
+void meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                             Time         timestamp);
+void meta_display_queue_autoraise_callback  (MetaDisplay *display,
+                                             MetaWindow  *window);
+void meta_display_remove_autoraise_callback (MetaDisplay *display);
+
 #endif

src/effects.c

@@ -125,6 +125,22 @@ update_wireframe_window (MetaDisplay         *display,
 #endif
 }
 
+static void
+graphics_sync (BoxAnimationContext *context)
+{
+  XImage *image;
+  
+  /* A hack to force the X server to synchronize with the
+   * graphics hardware
+   */
+  image = XGetImage (context->screen->display->xdisplay,
+		     context->screen->xroot,
+		     0, 0, 1, 1,
+		     AllPlanes, ZPixmap);
+
+  XDestroyImage (image);
+}
+
 static gboolean
 effects_draw_box_animation_timeout (BoxAnimationContext *context)
 {
@@ -182,6 +198,8 @@ effects_draw_box_animation_timeout (BoxAnimationContext *context)
           XDestroyWindow (context->screen->display->xdisplay,
                           context->wireframe_xwindow);
         }
+
+      graphics_sync (context);
       
       g_free (context);
       return FALSE;
@@ -267,7 +285,7 @@ effects_draw_box_animation_timeout (BoxAnimationContext *context)
     }
 
   /* kick changes onto the server */
-  XFlush (context->screen->display->xdisplay);
+  graphics_sync (context);
   
   return TRUE;
 }
@@ -364,7 +382,7 @@ meta_effects_draw_box_animation (MetaScreen     *screen,
                                                   0,
                                                   CopyFromParent,
                                                   CopyFromParent,
-                                                  CopyFromParent,
+                                                  (Visual *)CopyFromParent,
                                                   CWOverrideRedirect | CWBackPixel,
                                                   &attrs);
 
@@ -409,5 +427,108 @@ meta_effects_draw_box_animation (MetaScreen     *screen,
   XFlush (context->screen->display->xdisplay);  
 }
 
+void
+meta_effects_begin_wireframe (MetaScreen          *screen,
+                              const MetaRectangle *rect)
+{
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (screen->display);
+  meta_ui_push_delay_exposes (screen->ui);  
 
+  meta_effects_update_wireframe (screen, NULL, rect);
+}
+
+static void
+draw_xor_rect (MetaScreen          *screen,
+               const MetaRectangle *rect)
+{
+  /* The lines in the center can't overlap the rectangle or each
+   * other, or the XOR gets reversed. So we have to draw things
+   * a bit oddly.
+   */
+  XSegment segments[8];
+  int i;
+  
+#define LINE_WIDTH META_WIREFRAME_XOR_LINE_WIDTH
+  
+  XDrawRectangle (screen->display->xdisplay,
+                  screen->xroot,
+                  screen->root_xor_gc,
+                  rect->x, rect->y,
+                  rect->width, rect->height);
+
+  /* Don't put lines inside small rectangles where they won't fit */
+  if (rect->width < (LINE_WIDTH * 4) ||
+      rect->height < (LINE_WIDTH * 4))
+    return;
+  
+  /* Two vertical lines at 1/3 and 2/3 */
+  segments[0].x1 = rect->x + rect->width / 3;
+  segments[0].y1 = rect->y + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[0].x2 = segments[0].x1;
+  segments[0].y2 = rect->y + rect->height - LINE_WIDTH / 2;  
+
+  segments[1] = segments[0];
+  segments[1].x1 = rect->x + (rect->width / 3) * 2;
+  segments[1].x2 = segments[1].x1;
+
+  /* Now make two horizontal lines at 1/3 and 2/3, but not
+   * overlapping the verticals
+   */
+
+  segments[2].x1 = rect->x + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[2].x2 = segments[0].x1 - LINE_WIDTH / 2;
+  segments[2].y1 = rect->y + rect->height / 3;
+  segments[2].y2 = segments[2].y1;
+
+  segments[3] = segments[2];
+  segments[3].x1 = segments[2].x2 + LINE_WIDTH;
+  segments[3].x2 = segments[1].x1 - LINE_WIDTH / 2;
+  
+  segments[4] = segments[3];
+  segments[4].x1 = segments[3].x2 + LINE_WIDTH;
+  segments[4].x2 = rect->x + rect->width - LINE_WIDTH / 2;
+
+  /* Second horizontal line is just like the first, but
+   * shifted down
+   */
+  i = 5;
+  while (i < 8)
+    {
+      segments[i] = segments[i - 3];
+      segments[i].y1 = rect->y + (rect->height / 3) * 2;
+      segments[i].y2 = segments[i].y1;
+      ++i;
+    }
+  
+  XDrawSegments (screen->display->xdisplay,
+                 screen->xroot,
+                 screen->root_xor_gc,
+                 segments,
+                 G_N_ELEMENTS (segments));
+}
+
+void
+meta_effects_update_wireframe (MetaScreen          *screen,
+                               const MetaRectangle *old_rect,
+                               const MetaRectangle *new_rect)
+{
+  if (old_rect)
+    draw_xor_rect (screen, old_rect);
+    
+  if (new_rect)
+    draw_xor_rect (screen, new_rect);
+    
+  XFlush (screen->display->xdisplay);
+}
+
+void
+meta_effects_end_wireframe (MetaScreen          *screen,
+                            const MetaRectangle *old_rect)
+{
+  meta_effects_update_wireframe (screen, old_rect, NULL);
+  
+  meta_display_ungrab (screen->display);
+  meta_ui_pop_delay_exposes (screen->ui);
+}
 

src/effects.h

@@ -25,7 +25,7 @@
 #include "util.h"
 #include "screen.h"
 
-#define META_MINIMIZE_ANIMATION_LENGTH 0.35
+#define META_MINIMIZE_ANIMATION_LENGTH 0.25
 #define META_SHADE_ANIMATION_LENGTH 0.2
 
 typedef enum
@@ -41,4 +41,12 @@ void meta_effects_draw_box_animation (MetaScreen     *screen,
                                       double          seconds_duration,
                                       MetaBoxAnimType anim_type);
 
+void meta_effects_begin_wireframe  (MetaScreen          *screen,
+                                    const MetaRectangle *rect);
+void meta_effects_update_wireframe (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    const MetaRectangle *new_rect);
+void meta_effects_end_wireframe    (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect);
+
 #endif /* META_EFFECTS_H */

src/fixedtip.c

@@ -48,7 +48,6 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number,
   if (tip == NULL)
     {      
       tip = gtk_window_new (GTK_WINDOW_POPUP);
-#ifdef HAVE_GTK_MULTIHEAD
       {
         GdkScreen *gdk_screen;
 
@@ -59,20 +58,14 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number,
         screen_width = gdk_screen_get_width (gdk_screen);
         screen_height = gdk_screen_get_height (gdk_screen);
       }
-#else
-      screen_width = gdk_screen_width ();
-      screen_height = gdk_screen_height ();      
-#endif
       
       gtk_widget_set_app_paintable (tip, TRUE);
       gtk_window_set_policy (GTK_WINDOW (tip), FALSE, FALSE, TRUE);
       gtk_widget_set_name (tip, "gtk-tooltips");
       gtk_container_set_border_width (GTK_CONTAINER (tip), 4);
 
-      gtk_signal_connect_object (GTK_OBJECT (tip), 
-				 "expose_event",
-				 GTK_SIGNAL_FUNC (expose_handler),
-                                 NULL);
+      g_signal_connect_swapped (tip, "expose_event",
+				 G_CALLBACK (expose_handler), NULL);
 
       label = gtk_label_new (NULL);
       gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
@@ -81,10 +74,8 @@ meta_fixed_tip_show (Display *xdisplay, int screen_number,
       
       gtk_container_add (GTK_CONTAINER (tip), label);
 
-      gtk_signal_connect (GTK_OBJECT (tip),
-			  "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &tip);
+      g_signal_connect (tip, "destroy",
+			G_CALLBACK (gtk_widget_destroyed), &tip);
     }
 
   gtk_label_set_markup (GTK_LABEL (label), markup_text);

src/frame.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -21,9 +22,14 @@
 
 #include <config.h>
 #include "frame.h"
+#include "bell.h"
 #include "errors.h"
 #include "keybindings.h"
 
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
 #define EVENT_MASK (SubstructureRedirectMask |                     \
                     StructureNotifyMask | SubstructureNotifyMask | \
                     ExposureMask |                                 \
@@ -38,10 +44,11 @@ meta_window_ensure_frame (MetaWindow *window)
 {
   MetaFrame *frame;
   XSetWindowAttributes attrs;
+  Visual *visual;
   
   if (window->frame)
     return;
-
+  
   /* See comment below for why this is required. */
   meta_display_grab (window->display);
   
@@ -59,9 +66,8 @@ meta_window_ensure_frame (MetaWindow *window)
 
   frame->mapped = FALSE;
   frame->need_reapply_frame_shape = TRUE;
+  frame->is_flashing = FALSE;
   
-  attrs.event_mask = EVENT_MASK;
-
   meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
                 window->desc,
                 XVisualIDFromVisual (window->xvisual) ==
@@ -75,26 +81,33 @@ meta_window_ensure_frame (MetaWindow *window)
   /* Default depth/visual handles clients with weird visuals; they can
    * always be children of the root depth/visual obviously, but
    * e.g. DRI games can't be children of a parent that has the same
-   * visual as the client.
+   * visual as the client. NULL means default visual.
+   *
+   * We look for an ARGB visual if we can find one, otherwise use
+   * the default of NULL.
    */
   
-  frame->xwindow = XCreateWindow (window->display->xdisplay,
-                                  window->screen->xroot,
-                                  frame->rect.x,
-                                  frame->rect.y,
-                                  frame->rect.width,
-                                  frame->rect.height,
-                                  0,
-                                  window->screen->default_depth,
-                                  CopyFromParent,
-                                  window->screen->default_xvisual,
-                                  CWEventMask,
-                                  &attrs);
-
-  /* So our UI can find the window ID */
-  XFlush (window->display->xdisplay);
+  /* Special case for depth 32 windows (assumed to be ARGB),
+   * we use the window's visual. Otherwise we just use the system visual.
+   */
+  if (window->depth == 32)
+    visual = window->xvisual;
+  else
+    visual = NULL;
   
+  frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
+                                                window->display->xdisplay,
+                                                visual,
+                                                frame->rect.x,
+                                                frame->rect.y,
+						frame->rect.width,
+						frame->rect.height,
+						frame->window->screen->number);
+
   meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
+  attrs.event_mask = EVENT_MASK;
+  XChangeWindowAttributes (window->display->xdisplay,
+			   frame->xwindow, CWEventMask, &attrs);
   
   meta_display_register_x_window (window->display, &frame->xwindow, window);
 
@@ -131,8 +144,6 @@ meta_window_ensure_frame (MetaWindow *window)
   /* stick frame to the window */
   window->frame = frame;
   
-  meta_ui_add_frame (window->screen->ui, frame->xwindow);
-
   if (window->title)
     meta_ui_set_frame_title (window->screen->ui,
                              window->frame->xwindow,
@@ -160,9 +171,11 @@ meta_window_destroy_frame (MetaWindow *window)
   if (window->frame == NULL)
     return;
 
+  meta_verbose ("Unframing window %s\n", window->desc);
+  
   frame = window->frame;
   
-  meta_ui_remove_frame (window->screen->ui, frame->xwindow);
+  meta_bell_notify_frame_destroy (frame);
   
   /* Unparent the client window; it may be destroyed,
    * thus the error trap.
@@ -186,6 +199,8 @@ meta_window_destroy_frame (MetaWindow *window)
                    window->frame->rect.y);
   meta_error_trap_pop (window->display, FALSE);
 
+  meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);
+
   meta_display_unregister_x_window (window->display,
                                     frame->xwindow);
   
@@ -194,9 +209,6 @@ meta_window_destroy_frame (MetaWindow *window)
   /* Move keybindings to window instead of frame */
   meta_window_grab_keys (window);
   
-  /* should we push an error trap? */
-  XDestroyWindow (window->display->xdisplay, frame->xwindow);
-  
   g_free (frame);
   
   /* Put our state back where it should be */
@@ -258,6 +270,9 @@ meta_frame_get_flags (MetaFrame *frame)
   if (frame->window->fullscreen)
     flags |= META_FRAME_FULLSCREEN;
 
+  if (frame->is_flashing)
+    flags |= META_FRAME_IS_FLASHING;
+
   return flags;
 }
 
@@ -333,23 +348,12 @@ meta_frame_sync_to_window (MetaFrame *frame,
    */
   update_shape (frame);
   
-  if (need_move && need_resize)
-    XMoveResizeWindow (frame->window->display->xdisplay,
-                       frame->xwindow,
-                       frame->rect.x,
-                       frame->rect.y,
-                       frame->rect.width,
-                       frame->rect.height);
-  else if (need_move)
-    XMoveWindow (frame->window->display->xdisplay,
-                 frame->xwindow,
-                 frame->rect.x,
-                 frame->rect.y);
-  else if (need_resize)
-    XResizeWindow (frame->window->display->xdisplay,
-                   frame->xwindow,
-                   frame->rect.width,
-                   frame->rect.height);  
+  meta_ui_move_resize_frame (frame->window->screen->ui,
+			     frame->xwindow,
+			     frame->rect.x,
+			     frame->rect.y,
+			     frame->rect.width,
+			     frame->rect.height);
 
   if (need_resize)
     {
@@ -373,8 +377,9 @@ meta_frame_queue_draw (MetaFrame *frame)
                             frame->xwindow);
 }
 
-void meta_frame_set_screen_cursor (MetaFrame	*frame,
-				   MetaCursor	cursor)
+void
+meta_frame_set_screen_cursor (MetaFrame	*frame,
+			      MetaCursor cursor)
 {
   Cursor xcursor;
   if (cursor == frame->current_cursor)
@@ -386,6 +391,7 @@ void meta_frame_set_screen_cursor (MetaFrame	*frame,
     { 
       xcursor = meta_display_create_x_cursor (frame->window->display, cursor);
       XDefineCursor (frame->window->display->xdisplay, frame->xwindow, xcursor);
+      XFlush (frame->window->display->xdisplay);
       XFreeCursor (frame->window->display->xdisplay, xcursor);
     }
 }

src/frame.h

@@ -58,6 +58,7 @@ struct _MetaFrame
 
   guint mapped : 1;
   guint need_reapply_frame_shape : 1;
+  guint is_flashing : 1; /* used by the visual bell flash */
 };
 
 void     meta_window_ensure_frame           (MetaWindow *window);

src/frames.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Red Hat, Inc.
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -63,6 +64,9 @@ static void meta_frames_paint_to_drawable (MetaFrames   *frames,
                                            GdkDrawable  *drawable,
                                            GdkRegion    *region);
 
+static void meta_frames_set_window_background (MetaFrames   *frames,
+                                               MetaUIFrame  *frame);
+
 static void meta_frames_calc_geometry (MetaFrames        *frames,
                                        MetaUIFrame         *frame,
                                        MetaFrameGeometry *fgeom);
@@ -155,7 +159,7 @@ unsigned_long_hash (gconstpointer v)
   gulong val = * (const gulong *) v;
 
   /* I'm not sure this works so well. */
-#if G_SIZEOF_LONG > 4
+#if GLIB_SIZEOF_LONG > 4
   return (guint) (val ^ (val >> 32));
 #else
   return val;
@@ -269,8 +273,8 @@ queue_recalc_func (gpointer key, gpointer value, gpointer data)
    * resize may not actually be needed so we always redraw
    * in case of color change.
    */
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-                            frame->window, GTK_STATE_NORMAL);
+  meta_frames_set_window_background (frames, frame);
+  
   gdk_window_invalidate_rect (frame->window, NULL, FALSE);
   meta_core_queue_frame_resize (gdk_display,
                                 frame->xwindow);
@@ -314,8 +318,8 @@ queue_draw_func (gpointer key, gpointer value, gpointer data)
    * resize may not actually be needed so we always redraw
    * in case of color change.
    */
-  gtk_style_set_background (GTK_WIDGET (frames)->style,
-                            frame->window, GTK_STATE_NORMAL);
+  meta_frames_set_window_background (frames, frame);
+
   gdk_window_invalidate_rect (frame->window, NULL, FALSE);
 }
 
@@ -452,7 +456,6 @@ meta_frames_calc_geometry (MetaFrames        *frames,
 MetaFrames*
 meta_frames_new (int screen_number)
 {
-#ifdef HAVE_GTK_MULTIHEAD
   GdkScreen *screen;
 
   screen = gdk_display_get_screen (gdk_display_get_default (),
@@ -460,33 +463,27 @@ meta_frames_new (int screen_number)
 
   return g_object_new (META_TYPE_FRAMES,
 		       "screen", screen,
-		       NULL);
-#else
-  return g_object_new (META_TYPE_FRAMES,
-		       NULL);
-#endif
-  
+		       NULL);  
 }
 
 void
 meta_frames_manage_window (MetaFrames *frames,
-                           Window      xwindow)
+                           Window      xwindow,
+			   GdkWindow  *window)
 {
   MetaUIFrame *frame;
 
+  g_assert (window);
+
   frame = g_new (MetaUIFrame, 1);
   
-  frame->window = gdk_window_foreign_new (xwindow);
+  frame->window = window;
 
-  if (frame->window == NULL)
-    {
-      g_free (frame);
-      meta_bug ("Frame 0x%lx doesn't exist\n", xwindow);
-      return;
-    }
-  
   gdk_window_set_user_data (frame->window, frames);
 
+  /* Set the window background to the current style */
+  meta_frames_set_window_background (frames, frame);
+
   /* Don't set event mask here, it's in frame.c */
   
   frame->xwindow = xwindow;
@@ -527,7 +524,7 @@ meta_frames_unmanage_window (MetaFrames *frames,
       
       g_hash_table_remove (frames->frames, &frame->xwindow);
 
-      g_object_unref (G_OBJECT (frame->window));
+      gdk_window_destroy (frame->window);
 
       if (frame->layout)
         g_object_unref (G_OBJECT (frame->layout));
@@ -619,8 +616,8 @@ meta_frames_reset_bg (MetaFrames *frames,
   widget = GTK_WIDGET (frames);
 
   frame = meta_frames_lookup_window (frames, xwindow);
-  
-  gtk_style_set_background (widget->style, frame->window, GTK_STATE_NORMAL);
+
+  meta_frames_set_window_background (frames, frame);
 }
 
 static void
@@ -835,21 +832,15 @@ meta_frames_apply_shapes (MetaFrames *frames,
       Window shape_window;
       Window client_window;
       Region client_xregion;
-#ifdef HAVE_GTK_MULTIHEAD
       GdkScreen *screen;
-#endif
       int screen_number;
       
       meta_topic (META_DEBUG_SHAPES,
                   "Frame 0x%lx needs to incorporate client shape\n",
                   frame->xwindow);
 
-#ifdef HAVE_GTK_MULTIHEAD
       screen = gtk_widget_get_screen (GTK_WIDGET (frames));
       screen_number = gdk_x11_screen_get_screen_number (screen);
-#else
-      screen_number = DefaultScreen (gdk_display);
-#endif
       
       attrs.override_redirect = True;
       
@@ -861,7 +852,7 @@ meta_frames_apply_shapes (MetaFrames *frames,
                                     0,
                                     CopyFromParent,
                                     CopyFromParent,
-                                    CopyFromParent,
+                                    (Visual *)CopyFromParent,
                                     CWOverrideRedirect,
                                     &attrs);
 
@@ -922,6 +913,25 @@ meta_frames_apply_shapes (MetaFrames *frames,
 #endif /* HAVE_SHAPE */
 }
 
+void
+meta_frames_move_resize_frame (MetaFrames *frames,
+			       Window      xwindow,
+			       int         x,
+			       int         y,
+			       int         width,
+			       int         height)
+{
+  MetaUIFrame *frame = meta_frames_lookup_window (frames, xwindow);
+  int old_width, old_height;
+  
+  gdk_drawable_get_size (frame->window, &old_width, &old_height);
+
+  gdk_window_move_resize (frame->window, x, y, width, height);
+
+  if (old_width != width || old_height != height)
+    gdk_window_invalidate_rect (frame->window, NULL, FALSE);
+}
+
 void
 meta_frames_queue_draw (MetaFrames *frames,
                         Window      xwindow)
@@ -1057,11 +1067,8 @@ show_tip_now (MetaFrames *frames)
       /* get conversion delta for root-to-frame coords */
       dx = root_x - x;
       dy = root_y - y;
-#ifdef HAVE_GTK_MULTIHEAD
       screen_number = gdk_screen_get_number (gtk_widget_get_screen (GTK_WIDGET (frames)));
-#else
-      screen_number = DefaultScreen (gdk_display);
-#endif
+      
       meta_fixed_tip_show (gdk_display,
 			   screen_number,
                            rect->x + dx,
@@ -1255,6 +1262,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                frame->xwindow,
                                op,
                                TRUE,
+                               meta_ui_get_last_event_serial (gdk_display),
                                event->button,
                                0,
                                event->time,
@@ -1334,6 +1342,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                frame->xwindow,
                                op,
                                TRUE,
+                               meta_ui_get_last_event_serial (gdk_display),
                                event->button,
                                0,
                                event->time,
@@ -1353,6 +1362,7 @@ meta_frames_button_press_event (GtkWidget      *widget,
                                    frame->xwindow,
                                    META_GRAB_OP_MOVING,
                                    TRUE,
+                                   meta_ui_get_last_event_serial (gdk_display),
                                    event->button,
                                    0,
                                    event->time,
@@ -1362,7 +1372,9 @@ meta_frames_button_press_event (GtkWidget      *widget,
     }
   else if (event->button == 2)
     {
-      meta_core_user_lower (gdk_display, frame->xwindow);
+      meta_core_user_lower_and_unfocus (gdk_display,
+                                        frame->xwindow,
+                                        event->time);
     }
   else if (event->button == 3)
     {
@@ -1592,6 +1604,7 @@ meta_frames_motion_notify_event     (GtkWidget           *widget,
 {
   MetaUIFrame *frame;
   MetaFrames *frames;
+  MetaGrabOp grab_op;
   
   frames = META_FRAMES (widget);
   
@@ -1602,16 +1615,43 @@ meta_frames_motion_notify_event     (GtkWidget           *widget,
   clear_tip (frames);
 
   frames->last_motion_frame = frame;
+
+  grab_op = meta_core_get_grab_op (gdk_display);
   
-  switch (meta_core_get_grab_op (gdk_display))
+  switch (grab_op)
     {
     case META_GRAB_OP_CLICKING_MENU:
     case META_GRAB_OP_CLICKING_DELETE:
     case META_GRAB_OP_CLICKING_MINIMIZE:
     case META_GRAB_OP_CLICKING_MAXIMIZE:
     case META_GRAB_OP_CLICKING_UNMAXIMIZE:
+      {
+        MetaFrameControl control;
+        int x, y;
+        
+        gdk_window_get_pointer (frame->window, &x, &y, NULL);
+
+        /* Control is set to none unless it matches
+         * the current grab
+         */
+        control = get_control (frames, frame, x, y);
+        if (! ((control == META_FRAME_CONTROL_MENU &&
+                grab_op == META_GRAB_OP_CLICKING_MENU) ||
+               (control == META_FRAME_CONTROL_DELETE &&
+                grab_op == META_GRAB_OP_CLICKING_DELETE) ||
+               (control == META_FRAME_CONTROL_MINIMIZE &&
+                grab_op == META_GRAB_OP_CLICKING_MINIMIZE) ||
+               (control == META_FRAME_CONTROL_MAXIMIZE &&
+                (grab_op == META_GRAB_OP_CLICKING_MAXIMIZE ||
+                 grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE))))
+          control = META_FRAME_CONTROL_NONE;
+        
+        /* Update prelit control and cursor */
+	meta_frames_update_prelit_control (frames, frame, control);
+
+        /* No tooltip while in the process of clicking */
+      }
       break;
-      
     case META_GRAB_OP_NONE:
       {
         MetaFrameControl control;
@@ -1659,7 +1699,7 @@ meta_frames_expose_event (GtkWidget           *widget,
   MetaFrames *frames;
 
   frames = META_FRAMES (widget);
-    
+
   frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
   if (frame == NULL)
     return FALSE;
@@ -1699,6 +1739,7 @@ meta_frames_paint_to_drawable (MetaFrames   *frames,
   int n_areas;
   int screen_width, screen_height;
   MetaButtonLayout button_layout;
+  MetaGrabOp grab_op;
   
   widget = GTK_WIDGET (frames);
 
@@ -1710,53 +1751,47 @@ meta_frames_paint_to_drawable (MetaFrames   *frames,
       ++i;
     }
 
+  grab_frame = meta_core_get_grab_frame (gdk_display);
+  grab_op = meta_core_get_grab_op (gdk_display);
+  if (grab_frame != frame->xwindow)
+    grab_op = META_GRAB_OP_NONE;
+  
   /* Set prelight state */
   switch (frame->prelit_control)
     {
     case META_FRAME_CONTROL_MENU:
-      button_states[META_BUTTON_TYPE_MENU] = META_BUTTON_STATE_PRELIGHT;
+      if (grab_op == META_GRAB_OP_CLICKING_MENU)
+        button_states[META_BUTTON_TYPE_MENU] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MENU] = META_BUTTON_STATE_PRELIGHT;
       break;
     case META_FRAME_CONTROL_MINIMIZE:
-      button_states[META_BUTTON_TYPE_MINIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      if (grab_op == META_GRAB_OP_CLICKING_MINIMIZE)
+        button_states[META_BUTTON_TYPE_MINIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MINIMIZE] = META_BUTTON_STATE_PRELIGHT;
       break;
     case META_FRAME_CONTROL_MAXIMIZE:
+      if (grab_op == META_GRAB_OP_CLICKING_MAXIMIZE)
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      break;
     case META_FRAME_CONTROL_UNMAXIMIZE:
-      button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      if (grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE)
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
       break;
     case META_FRAME_CONTROL_DELETE:
-      button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRELIGHT;
+      if (grab_op == META_GRAB_OP_CLICKING_DELETE)
+        button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRELIGHT;
       break;
     default:
       break;
     }
-  
-  grab_frame = meta_core_get_grab_frame (gdk_display);
-
-  if (frame->xwindow == grab_frame)
-    {
-      switch (meta_core_get_grab_op (gdk_display))
-        {
-        case META_GRAB_OP_CLICKING_MENU:
-          button_states[META_BUTTON_TYPE_MENU] =
-            META_BUTTON_STATE_PRESSED;
-          break;
-        case META_GRAB_OP_CLICKING_DELETE:
-          button_states[META_BUTTON_TYPE_CLOSE] =
-            META_BUTTON_STATE_PRESSED;
-          break;
-        case META_GRAB_OP_CLICKING_MAXIMIZE:
-        case META_GRAB_OP_CLICKING_UNMAXIMIZE:
-          button_states[META_BUTTON_TYPE_MAXIMIZE] =
-            META_BUTTON_STATE_PRESSED;
-          break;
-	case META_GRAB_OP_CLICKING_MINIMIZE:
-          button_states[META_BUTTON_TYPE_MINIMIZE] =
-            META_BUTTON_STATE_PRESSED;
-          break;
-        default:
-          break;
-        }
-    }
 
   /* Map button function states to button position states */
   button_states[META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND] =
@@ -1864,6 +1899,22 @@ meta_frames_paint_to_drawable (MetaFrames   *frames,
   g_free (areas);
 }
 
+static void
+meta_frames_set_window_background (MetaFrames   *frames,
+                                   MetaUIFrame  *frame)
+{
+  gtk_style_set_background (GTK_WIDGET (frames)->style,
+                            frame->window, GTK_STATE_NORMAL);
+
+#if 0
+  /* This is what we want for transparent background */
+  {
+    col.pixel = 0;
+    gdk_window_set_background (window, &col);
+  }
+#endif
+}
+
 static gboolean
 meta_frames_enter_notify_event      (GtkWidget           *widget,
                                      GdkEventCrossing    *event)
@@ -2085,6 +2136,13 @@ get_control (MetaFrames *frames,
 void
 meta_frames_push_delay_exposes (MetaFrames *frames)
 {
+  if (frames->expose_delay_count == 0)
+    {
+      /* Make sure we've repainted things */
+      gdk_window_process_all_updates ();
+      XFlush (gdk_display);
+    }
+  
   frames->expose_delay_count += 1;
 }
 

src/frames.h

@@ -103,7 +103,8 @@ GType        meta_frames_get_type               (void) G_GNUC_CONST;
 MetaFrames *meta_frames_new (int screen_number);
 
 void meta_frames_manage_window (MetaFrames *frames,
-                                Window      xwindow);
+                                Window      xwindow,
+				GdkWindow  *window);
 void meta_frames_unmanage_window (MetaFrames *frames,
                                   Window      xwindow);
 void meta_frames_set_title (MetaFrames *frames,
@@ -130,7 +131,12 @@ void meta_frames_apply_shapes (MetaFrames *frames,
                                int         new_window_width,
                                int         new_window_height,
                                gboolean    window_has_shape);
-
+void meta_frames_move_resize_frame (MetaFrames *frames,
+				    Window      xwindow,
+				    int         x,
+				    int         y,
+				    int         width,
+				    int         height);
 void meta_frames_queue_draw (MetaFrames *frames,
                              Window      xwindow);
 

src/group.c

@@ -2,6 +2,7 @@
 
 /* 
  * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -105,67 +106,71 @@ meta_window_get_group (MetaWindow *window)
 {
   if (window->unmanaging)
     return NULL;
-  
-  if (window->cached_group == NULL)
+
+  g_assert (window->group != NULL);
+
+  return window->group;
+}
+
+void
+meta_window_compute_group (MetaWindow* window)
+{
+  MetaGroup *group;
+
+  /* use window->xwindow if no window->xgroup_leader */
+      
+  group = NULL;
+      
+  if (window->display->groups_by_leader)
     {
-      MetaGroup *group;
-
-      /* use window->xwindow if no window->xgroup_leader */
-      
-      group = NULL;
-      
-      if (window->display->groups_by_leader)
-        {
-          if (window->xgroup_leader != None)
-            group = g_hash_table_lookup (window->display->groups_by_leader,
-                                         &window->xgroup_leader);
-          else
-            group = g_hash_table_lookup (window->display->groups_by_leader,
-                                         &window->xwindow);
-        }
-      
-      if (group != NULL)
-        {
-          window->cached_group = group;
-          group->refcount += 1;
-        }
+      if (window->xgroup_leader != None)
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xgroup_leader);
       else
-        {
-          if (window->xgroup_leader != None)
-            group = meta_group_new (window->display,
-                                    window->xgroup_leader);
-          else
-            group = meta_group_new (window->display,
-                                    window->xwindow);
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xwindow);
+    }
+      
+  if (group != NULL)
+    {
+      window->group = group;
+      group->refcount += 1;
+    }
+  else
+    {
+      if (window->xgroup_leader != None)
+        group = meta_group_new (window->display,
+                                window->xgroup_leader);
+      else
+        group = meta_group_new (window->display,
+                                window->xwindow);
           
-          window->cached_group = group;
-        }
-
-      window->cached_group->windows = g_slist_prepend (window->cached_group->windows,
-                                                       window);
-
-      meta_topic (META_DEBUG_GROUPS,
-                  "Adding %s to group with leader 0x%lx\n",
-                  window->desc, group->group_leader);
+      window->group = group;
     }
 
-  return window->cached_group;
+  window->group->windows = g_slist_prepend (window->group->windows,
+                                                   window);
+
+  meta_topic (META_DEBUG_GROUPS,
+              "Adding %s to group with leader 0x%lx\n",
+              window->desc, group->group_leader);
+
 }
 
 static void
 remove_window_from_group (MetaWindow *window)
 {
-  if (window->cached_group != NULL)
+  if (window->group != NULL)
     {
       meta_topic (META_DEBUG_GROUPS,
                   "Removing %s from group with leader 0x%lx\n",
-                  window->desc, window->cached_group->group_leader);
+                  window->desc, window->group->group_leader);
       
-      window->cached_group->windows =
-        g_slist_remove (window->cached_group->windows,
+      window->group->windows =
+        g_slist_remove (window->group->windows,
                         window);
-      meta_group_unref (window->cached_group);
-      window->cached_group = NULL;
+      meta_group_unref (window->group);
+      window->group = NULL;
     }
 }
 
@@ -173,7 +178,7 @@ void
 meta_window_group_leader_changed (MetaWindow *window)
 {
   remove_window_from_group (window);
-  meta_window_get_group (window);
+  meta_window_compute_group (window);
 }
 
 void
@@ -255,4 +260,5 @@ meta_group_property_notify (MetaGroup  *group,
                               event->xproperty.atom);
 
   return TRUE;
+
 }