2.23.3 release.

svn path=/trunk/; revision=3658

.cvsignore

@@ -29,3 +29,7 @@ COPYING
 intltool-*
 metacity.spec
 autom4te.cache
+compile
+depcomp
+omf.make
+xmldocs.make

HACKING

@@ -39,16 +39,20 @@ Minimal Building/Testing Environment
   You do not need to _install_ a development version of Metacity to
   build, run and test it; you can run it from some temporary
   directory.  Also, you do not need to build all of Gnome in order to
-  build a development version of Metacity -- odds are, you can build
-  metacity from CVS without building any other modules.
+  build a development version of Metacity -- odds are, you may be able
+  to build metacity from CVS without building any other modules.
 
-  As long as you have gtk+ >= 2.6 with your distro, you should be able
-  to install your distro's development packages (e.g. gtk2-devel,
-  GConf2-devel, and startup-notification-devel on Fedora) and be ready
-  to build and test Metacity.  Steps to do so:
+  As long as you have gtk+ >= 2.10 and GConf with your distro (gtk+ >=
+  2.6 if you manually revert the change from bug 348633), you should
+  be able to install your distro's development packages
+  (e.g. gtk2-devel, GConf2-devel, startup-notification-devel on
+  Fedora; also, remember to install the gnome-common package which is
+  needed for building cvs versions of Gnome modules like Metacity) as
+  well as the standard development tools (gcc, autoconf, automake,
+  pkg-config, intltool, and libtool) and be ready to build and test
+  Metacity.  Steps to do so:
 
-  $ cvs -q -z3 -d :pserver:anonymous@anoncvs.gnome.org:/cvs/gnome \
-                  checkout metacity
+  $ svn checkout http://svn.gnome.org/svn/metacity/trunk metacity
   $ cd metacity
   $ ./autogen.sh --prefix /usr
   $ make
@@ -178,7 +182,7 @@ Debugging information
 
   To run metacity under valgrind, use options typical for any Gnome
   program, such as
-    valgrind --logfile=metacity.log --tool=memcheck --num-callers=48 \
+    valgrind --log-file=metacity.log --tool=memcheck --num-callers=48 \
     --leak-check=yes --leak-resolution=high --show-reachable=yes     \
     ./src/metacity --replace
   where, again, the backslashes mean to join all the stuff on the following

MAINTAINERS

@@ -1,11 +1,43 @@
 Currently active maintainers
-----------------------------
-
-Havoc Pennington
-E-mail: hp@redhat.com
+--------------------------------
 
 Elijah Newren
-E-mail: newren@gmail.com
+Email: newren gmail com
+Userid: newren
 
-Søren Sandmann
-E-mail: sandmann@redhat.com
+  - Usually won't touch the theme bugs (isn't interested) or the
+    compositor (until open source nvidia drivers are up to snuff).
+    Tends to be most interested in libwnck/gtk interactions, focus
+    issues, constraints problems, and raising/stacking, but works on
+    just about anything other than themes and the compositor.
+
+Thomas Thurman
+Email: thomas thurman org uk
+Userid: tthurman
+
+  - Responsible for all theme bugs and the compositor (thank goodness
+    Thomas got involved, eh?).  I'm sure he'll replace this sentence
+    with his interests when he reads it.  ;-)
+
+
+Semi-active maintainers
+--------------------------------
+
+Havoc Pennington
+Email: hp  redhat com
+Userid: hp
+  - Original author.  Doesn't patch metacity anymore, but is active in
+    answering questions, responding to bugs, providing very helpful
+    suggestions and insight, and even assisting with debugging.
+
+
+Important historical figureheads
+--------------------------------
+
+Rob Adams (readams  readams net)
+  - Was the main maintainer of metacity for a while; particular areas
+    of focus included xinerama, placement, and an older version of the
+    constraints code.  Still responds to bugs every once in a while.
+
+Søren Sandmann (sandmann  redhat com)
+  - Wrote most of the current compositing manager code + libcm

Makefile.am

@@ -1,7 +1,7 @@
 
 SUBDIRS=src po doc
 
-EXTRA_DIST=HACKING rationales.txt \
+EXTRA_DIST = HACKING MAINTAINERS rationales.txt \
 	intltool-extract.in intltool-merge.in intltool-update.in
 
 DISTCLEANFILES = intltool-extract intltool-merge intltool-update po/stamp-it po/.intltool-merge-cache

NEWS

@@ -1,3 +1,702 @@
+2.23.3
+======
+
+Thanks to Marco Pesenti Gritti, Iain Holmes, Josh Lee, Thomas Thurman, and
+Matthew Wilson for improvements in this version.
+
+  - Workspaces whose name is the same as the standard name, plus some string,
+    are not cut off. (Thomas) (#453678)
+  - Improve compositor performance (Iain) (#522166)
+  - Draw wallpaper correctly when we start up with compositor
+    (Iain) (#522599)
+  - Several other smaller compositor fixes (Iain)
+  - Don't draw shadows on shaped windows unless they have frames
+    (Iain) (#505333)
+  - Newly-created keep-above windows get focus (Marco) (#519188)
+  - Allow moving workspace when dragging with modifier key (Matthew)
+    (#474195)
+
+Translations
+  Kenneth Nielsen (da), Gabor Kelemen (hu), Vasiliy Faronov (ru), Daniel
+  Nylander (sv), Maxim Dziumanenko (uk), Woodman Tuen (zh_HK)
+
+2.23.2
+======
+
+Removed some debug statements introduced in 2.23.1.  Brown paper bag release.
+
+
+2.23.1
+======
+
+Thanks to Cosimo Cecchi, Jens Granseuer, Jim Huang, Andrea Del Signore, and
+Thomas Thurman for improvements in this version.
+
+(Cosimo's patch was very similar to another received from Jason Ribero.)
+
+  - Allow horizontal and vertical maximisation using the mouse (Cosimo/Jason)
+    (#358674)
+  - Allow "spacer" as a value for buttons, for blank space (Andrea) (#509165)
+  - Remove unused code (Jim)
+  - refactor preferences handling (Thomas)
+  - make sure we're valid C89 (Jens) (#518917)
+  - some messing with tool scripts (Thomas)
+
+Translations
+  Jorge González (es), Claude Paroz (fr), Woodman Tuen (zh_HK), Woodman
+  Tuen (zh_TW)
+
+2.23.0
+======
+
+Thanks to Matthias Clasen, Mikkel Kamstrup Erlandsen, Jim Huang, Thomas Thurman,
+and Thomas Wood for improvements in this version.
+
+  - the preview widget can draw shaped windows properly! (Thomas W, #460018)
+  - refactored handling of boolean and enumerated gconf preferences;
+    refactoring of string and integer preferences will follow shortly (Thomas T)
+  - Applications asking to move and resize windows at the same time have
+    both their requests granted (Mikkel) (#448183)
+  - Windows marked "skip taskbar" don't appear in the ctrl-alt-tab list
+    (Matthias) (#106249)
+  - fix session management detection (Thomas T) (#328210)
+  - when resizing with the keyboard, the cursor stays on a window edge if
+    you escape, whichever direction you were going (Thomas T) (#436257)
+  - fix major breakage when gconf was turned off in configure (Jim) (#515019)
+  - fix major breakage when verbose was turned off in configure (Jim) (#515152)
+  - fix name of verbose option in help (Thomas T)
+  - various bits of messing around with release scripts (Thomas T)
+
+Translations
+  Ihar Hrachyshka (be@latin), Ilkka Tuohela (fi), Ignacio Casal Quinteiro (gl),
+  Shankar Prasad (kn), Changwoo Ryu (ko), Nabin Gautam (ne), Wouter Bolsterlee (nl)
+
+2.21.13
+=======
+
+Thanks to Michael Meeks and Thomas Thurman for improvements in this version.
+
+  - Only use compositor version if we have a compositor (Thomas) (#514453)
+  - Remove workaround for a problem in an ancient GTK version (Thomas) (#513737)
+  - Compositor efficiency fixes (Michael)
+  - Various tools added (Thomas)
+
+Translations
+  Amitakhya Phukan (as), Rhys Jones (cy), Andre Klapper (de), Takeshi AIHANA (ja),
+  Arangel Angov (mk), Tomasz Dominikowski (pl), Duarte Loreto (pt)
+
+2.21.8
+======
+
+Thanks to Paolo Borelli, Iain Holmes, Havoc Pennington, Christian Persch, Thomas
+Thurman, and Alex R.M. Turner for improvements in this version.
+
+  - Windows on other workspaces which need attention appear in the alt-tab
+    list too (Alex) (#333548)
+  - Remove deprecated function call (Christian) (#512561)
+  - New release script (Thomas)
+  - Made a start at improving the general number of comments (Thomas)
+  - Updated copyright year to 2008, and some other tiny fixes (Thomas)
+  - Don't do anything unusual when the compositor frees a window (Iain)
+  - Mapping windows doesn't mark them as damaged (Iain)
+  - Compositor uses the overlay window and not the root window (Iain)
+  - Fixed several list leaks (Paolo)
+  - Fixed warnings about printf formats (Havoc)
+  - Move source files into subdirectories of the src directory (Havoc)
+
+Translations
+  Khaled Hosny (ar), Ihar Hrachyshka (be@latin), Petr Kovar (cs), Andre
+  Klapper (de), Jorge González (es), Iñaki Larrañaga Murgoitio (eu), Seán de
+  Búrca (ga), Yuval Tanny (he), Luca Ferretti (it), Takeshi AIHANA (ja), Arangel
+  Angov (mk), sandeep shedmake (mr), Kjartan Maraas (nb), Yannig
+  Marchegay (Kokoyaya) (oc), Daniel Nylander (sv), Theppitak Karoonboonyanan (th),
+  Baris Cicek (tr), Clytie Siddall (vi)
+2.21.5
+======
+
+Thanks to Iain Holmes and Thomas Thurman for improvements in this version.
+This contains the new compositor; downstream maintainers should note that
+its GConf key is initially turned off in src/metacity.schemas.in and consider
+whether to turn it on by default in their packages.
+
+  - merge compositor branch! (Iain) (499081)
+  - print "Subversion" and not "CVS" when building (Thomas)
+
+Translations
+  Jorge González (es), Kjartan Maraas (nb), Daniel Nylander (sv)
+
+2.21.3
+======
+
+Thanks to Matthias Clasen, Martin Meyer, Kjartan Maraas, Thomas Thurman,
+and Lucas Rocha for improvements in this version.
+
+  - remove dead code (pointed out by Kjartan) (501365)
+  - rewrote long key binding description for the sake of
+    the translators (Thomas) (474889)
+  - check for null before adding menu (Matthias) (496054)
+  - let keys which end a grab also begin a grab (Thomas) (112560)
+  - check the right variable in theme sanity check (Martin) (501362)
+  - get session ID from environment if it's not passed in on the command
+    line (Lucas) (498033)
+
+Translations
+  Ihar Hrachyshka (be@latin), Petr Kovar (cs), Jorge González (es),
+  Ignacio Casal Quinteiro (gl), Rodrigo Flores (pt_BR), Pavol Šimo (sk),
+  Matej Urbančič (sl)
+
+2.21.2
+======
+
+Thanks to Benjamin Gramlich, Thomas Thurman, and Peter Bloomfield
+for improvements in this release.
+
+ - Theme parser is compliant to XDG Base Directory Specification
+   in searching for theme files. (Benjamin) (#480026)
+ - Some source files which didn't get used were removed (Thomas)
+   (#496947)
+ - Fullscreen and maximise windows don't try to save their position
+   (Peter) (#461927)
+
+Translations
+  Matej Urbančič (sl)
+
+2.21.1
+======
+
+Thanks to Elijah Newren, Alex R.M. Turner, Peter Bloomfield, Iain Holmes,
+Jans Granseuer, Federico Mena Quintero and Thomas Thurman for improvements
+in this release.
+
+ - Add --sync option, like all other GTK apps (Iain)
+ - Don't save window's position if it's maximised (Peter) (#461927)
+ - Memory leak fix in preview (Jans) (#469682)
+ - Truncate tab popup string correctly, and refactor function (Alex)
+ - Windows which pop up under always-on-top windows don't get the
+   focus, but do get the "needs attention" hint (Thomas) (#486445)
+ - Fix error in function call which caused focus problems (Federico)
+   (partial fix of #488468)
+
+Translations
+  Djihed Afifi (ar), Metin Amiroff (az), Alexander Shopov (bg),
+  Jordi Mallach (ca), David Lodge (en_GB), Jorge González (es),
+  Iñaki Larrañaga Murgoitio (eu), Vincent Untz (fr), Alastair McKinstry (ga),
+  Ankit Patel (gu), Rajesh Ranjan (hi), auto (hr), Changwoo Ryu (ko),
+  Raivis Dejus (lv), Wouter Bolsterlee (nl), Gora Mohanty (or),
+  ASB (pa), wadim dziedzic (pl), Duarte Loreto (pt),
+  Og Maciel (pt_BR), Peter Tuhársky (sk), Matej Urbančič (sl),
+  Daniel Nylander (sv), Maxim Dziumanenko (uk), Funda Wang (zh_CN)
+
+2.20.0
+======
+
+Thanks to Alexey Rusakov for the fix in this release.
+
+ - prevent a crash on logout with metacity subsequently not being
+   restored in future sessions (Alexey) [#433253]
+
+Translations
+  Khaled Hosny (ar), Ihar Hrachyshka (be@latin), Ask Hjorth Larsen (da),
+  Adam Weinberger (en_CA), Iñaki Larrañaga Murgoitio (eu), Ilkka
+  Tuohela (fi), Vincent Untz (fr), Ankit Patel (gu), Gabor Kelemen (hu),
+  Luca Ferretti (it), Takeshi AIHANA (ja), Žygimantas Beručka (lt), Jovan
+  Naumovski (mk), Ani Peter (ml), Og Maciel (pt_BR), Duarte Loreto (pt),
+  Mugurel Tudor (ro), Nickolay V. Shmyrev (ru), Peter Tuhársky (sk), Горан
+  Ракић (sr), Daniel Nylander (sv), Dr.T.Vasudevan (ta), Maxim
+  Dziumanenko (uk), Clytie Siddall (vi)
+
+2.19.55
+=======
+
+Thanks to Frederic Crozat, Matthias Clasen, and Thomas Thurman for improvements
+in this release.
+
+ - Noninteger auto-raise delay is not assumed to be zero (Thomas) (#377491)
+ - Fix mangled window title in "Force Quit" (Frederic) (#462734)
+ - "Close" can appear at any point in the window menu, and now appears
+   at the bottom (Thomas) (#104026)
+ - Windows which are always on top have "stick" insensitive (Thomas) (#460997)
+ - All bitfields in window structure are together for optimisation (Thomas)
+   (#450271)
+ - Use the correct directory when installing keybindings (Matthias) (#454055)
+
+Translations
+  Alexander Shopov (bg), Jorge González (es), Iñaki Larrañaga Murgoitio (eu),
+  Ilkka Tuohela (fi), Theppitak Karoonboonyanan (th)
+
+2.19.34
+=======
+
+Thanks to Rob Bradford, Cosimo Cecchi, Yair Hershkovitz and Thomas Thurman
+for improvements in this release.
+
+ - Fix a bug where the window can be focused without being raised
+   if the maximize is aborted. (Rob) [#459027]
+ - Unset fullscreen is an allowed action where relevant. (Cosimo) [#449427]
+ - Reverse window buttons and align them to the left for RTL locales.
+   (Yair) [#92212]
+ - Put all bitfields in window data together to help with optimisation.
+   (Thomas) [#450271]
+
+Translations
+  Jorge Gonzalez (es), Ilkka Tyohela (fi), Gabor Kelemen (hu),
+  Takeshi AIHANA (ja), Kjartan Maraas (nb), Vincent van Adrighem (nl),
+  Daniel Nylander (sv), Theppitak Karoonbooyana (th),
+  Nguyễn Thái Ngọc Duy (vi)
+
+2.19.21
+=======
+
+Thanks to Damien Carbery and Thomas Thurman for improvements in
+this release.
+
+ - Fixed build on Solaris (Damien) [#397296, #446535]
+ - Only activate windows which change their startup ID if the
+   new ID differs from the old. (This fixes the bug where KDE
+   apps gained the attention hint when switching workspaces.)
+   (Thomas) [#400167]
+ - Open new windows on the current xinerama. (Thomas) [#145503].
+
+Translations
+  Tshewang Norbu (dz),  Jorge González (es), Funda Wang (zh_CN)
+
+2.19.13
+=======
+
+Thanks to Elijah Newren and Thomas Thurman for improvements in
+this release.
+
+ - Updated the description of raise_on_click (Elijah) [#445447,
+   #389923]
+ - Refactor queueing code in window.c (Thomas) [#376760]
+ - Added switch_group to the keybindings file (Thomas) [#444879]
+ - New window information accessor function (Thomas) [#377495]
+
+2.19.8
+======
+
+Thanks to Linus Torvalds, Yair Hershkovitz and Thomas Thurman for
+improvements in this release.
+
+ - Lots of fixups for various alignments in RTL locales (Yair)
+   [#387893]
+ - Add code to configure what happens on right or middle click
+   of titlebar (Linus) [#408904]
+ - Fix layout for titlebars with mixed LTR/RTL scripts (Thomas)
+   [#433400]
+ - Fix window menu layout for RTL scripts (Thomas) [#433400]
+
+Translations
+  Khaled Hosny (ar), Ihar Hrachyshka (be@latin), Jovan Naumovski (mk),
+  Theppitak Karoonboonyanan (th)
+
+  [ Apologies to these translators who didn't get credited in the
+    version of 2.19.8 that shipped. ]
+
+2.19.5
+======
+
+ - Prevent metacity from "forgetting" which machine a window is on
+   (Elijah) [#418552]
+ - Prevent nasty flickering an placement problem introduced in
+   metacity 2.19.2 (Elijah) [fix side-effect of change in #426519]
+ - Fix some uninitialized memory usage errors (Elijah) [#427385]
+
+Translations
+  David Lodge (en_GB), Jorge González (es), Ignacio Casal Quinteiro (gl),
+  Daniel Nylander (sv)
+
+2.19.3
+======
+
+Thanks to Magnus Therning, Elijah Newren, Thomas Thurman, and Bruno
+Boaventura for improvements in this release.
+
+  - Add support for _NET_MOVERESIZE_WINDOW (Magnus, Elijah) [#344521]
+  - EWMH compliance: set _NET_WM_ALLOWED_ACTIONS so that pagers know
+    which actions we support (Elijah) [#115247]
+  - Fix crash with apps trying to open an insanely huge window
+    (Thomas) [#399529]
+  - Fix temporary hang/pause with libXt by making sure apps get a
+    ConfigureNotify on unmap (Elijah) [#399552]
+  - do not auto-maximize windows larger than the workarea in only a
+    single direction (Elijah) [#419810]
+  - Don't show the current workspace as a possible workspace to switch
+    to (Bruno) [#426791]
+  - Preserve stacking order across restarts (Elijah)
+
+Translations
+  Khaled Hosny (ar), Kjartan Maraas (nb)
+
+2.19.2
+======
+
+Thanks to Bastien Nocera, Thomas Thurman, and Elijah Newren for
+improvements in this release.
+
+  - Add new control-center key bindings definitions (Bastien) [#420145]
+  - Prevent metacity from crashing when trying to use invalid themes
+    (Thomas) [#423855]
+  - Fix invalid free causing crash on metacity close introduced in
+    2.19.1 (Elijah) [#427385]
+  - Add special keybinding just for debugging spew marks, unbound and
+    not even listed in schemas (Elijah)
+  - Fix move/resize events in relation to combinations of
+    ConfigureRequest and WM_NORMAL_HINTS change notifications (Elijah)
+    [#426519]
+  - Remove what we believe to be an ancient attempt at working around
+    sloppy/mouse focus bugs that we believe have since been correctly
+    fixed.  May fix some ugly race conditions.  May also cause nasty
+    bugs in sloppy/mouse focus modes.  Only one way to find
+    out... (Elijah) [#304430]
+
+Translations
+  Raivis Dejus (lv)
+
+2.19.1
+======
+
+Thanks to Jaap Haitsma, Linus Torvalds, Charlie Brej, Kjartan Maraas,
+Arthur Taylor, Elijah Newren, Josselin Mouette, Havoc Pennington,
+Benjamin Berg, and Carlo Wood for improvements in this release.
+
+  - new icon for the force-quit dialog (Jaap) [#396655]
+  - add configureable mouse click action abilities, and clean up lots of
+    related code (Linus) [#408899, #408902, others]
+  - add schemeas for middle and right click titlebar actions (Charlie)
+    [#408903]
+  - remove pango/pangox.h include since it's not needed and not
+    installed anymore (Kjartan)
+  - adjust rounded corners so that they fit nicely with the arcs
+    around them (Arthur) [#399373]
+  - fix session hang when metacity .sm file is missing (Josselin)
+    [#407981]
+  - add support for _NET_WM_USER_TIME_WINDOW in order to cut down on
+    context switches (Elijah, Havoc) [#354213]
+  - prevent nasty metacity/gdk interactions causing hangs with gtk
+    trunk (Elijah) [offshoots of #354213]
+  - fix button middle fallback and the prelight state (Benjamin) [#419043]
+  - Lots of code cleanup for the strut lists (Elijah)
+  - fix handling of unidirectional maximization and partial struts +
+    some miscellaneous cleanups (Carlo) [#358311]
+  - avoid some crashes when dragging windows partially offscreen
+    (Elijah) [#353513]
+  - avoid mousenav vs. keynav focus problems with the run application
+    dialog in mouse/sloppy focus modes (Elijah) [#374752]
+  - _NET_ACTIVE_WINDOW property on the root window should be a single
+    xwindow id, not two (Elijah)
+  - Fix unidirection unmaximization causing jumps (Elijah) [#355497]
+  - fix unfullscreening and unmaximizing with size increment/size
+    constraint windows (such as gnome-terminal) possibly not returning
+    to their "original position" (Elijah) [#329152]
+  - fix some issues with min/max and size increment constraints
+    (Elijah) [#418395]
+  - send synthetic configure notify events in response to appropriate
+    MapRequest events too (Elijah) [#322840]
+
+Translations
+  Ihar Hrachyshka (be@latin), Jordi Mallach (ca), Jakub Friedl (cs),
+  norbu (dz), David Lodge (en_GB), Ivar Smolin (et), Gabor Kelemen (hu),
+  Luca Ferretti (it), Takeshi AIHANA (ja), Erdal Ronahi (ku), Gintautas
+  Miliauskas (lt), Jovan Naumovski (mk), Kjartan Maraas (nb), Reinout van
+  Schouwen (nl), wadim dziedzic (pl), raulpereira (pt_BR), Nickolay V.
+  Shmyrev (ru), Горан Ракић (sr), Woodman Tuen (zh_HK), Woodman Tuen (zh_TW)
+
+2.17.5
+======
+
+Thanks to Bruno Boaventura, Mad Alex, and Thomas Thurman for
+improvements in this release.
+
+   - make window menu arrangement more sensible. (Bruno) [#382962]
+   - unmaximise button keeps pressed appearance when moved off and
+     back. (Alex) [#395560]
+   - fix a couple of compositor crashes (Thomas) [#387761]
+   - new environment variables checked if the compositor is enabled;
+     see the new file doc/compositor-control.txt for details. (Thomas)
+
+Translations
+  Djihed Afifi (ar), Ales Nyakhaychyk (be), Jordi Mallach (ca),
+  Jakub Friedl (cs), David Lodge (en_GB), Raivis Dejus (lv),
+  Kjartan Maraas (nb), Mugurel Tudor (ro), Daniel Nylander (sv),
+  Theppitak Karoonboonyanan (th)
+
+2.17.3
+======
+
+Thanks to Christof Krüger, Federico Mena Quintero, Bruno Boaventura,
+and Björn Lindqvist for improvements in this release.
+
+  - fix longstanding problem about windows flickering in and out of
+    maximised state when dragging between xineramas (Christof) [#358715]
+  - grab server when switching workspaces (Federico) [#381127] 
+  - replace changing text on window menu with pairs of radio buttons
+    and checkboxes (Bruno, Björn) [#343108]
+
+Translations
+  Kjartan Maraas (nb), Jakub Friedl (cs), Yuval Tanny (he), Ivar Smolin (et),
+  Duarte Loreto (pt), Francisco Javier F. Serrador (es)
+
+2.17.2
+======
+
+Thanks to Priit Laes, Bruno Boaventura, Kjartan Maraas, Justin Mason,
+Elijah Newren and Dan Mick for improvements in this release.
+
+  - implement handle_move_to_{side|corner}_* to allow the user to flip a
+    window to the side or corner of the screen. (Justin) [#317884]
+  - fix strict focus mode by picking up on res_class (Dan) [#361054]
+  - remove deprecated gtk stuff (Priit, Bruno)
+  - string fixes (Kjartan) [#363354, #363355]
+
+Translations
+  Jakub Friedl (cs), Francisco Javier F. Serrador (es), Ilkka Tuohela (fi),
+  Christophe Merlet (RedFox) (fr), Kjartan Maraas (nb)
+
+2.17.1
+======
+
+Thanks to Bruno Boaventura and Carlo Wood for improvements in this
+release.
+
+  - sync metacity workspace previous with libwnck (Bruno) [#341893]
+  - fix cases when titlebar is allowed offscreen and shouldn't be, and
+    vice-versa (Carlo) [#333995]
+
+Translations
+  Ilkka Tuohela (fi)
+
+2.17.0
+======
+
+Thanks to Elijah Newren, Jens Granseuer, Bruno Boaventura, Carlo Wood,
+and Thomas Thurman for changes in this release.
+
+  - version 2 of theme format: stick, shade and above buttons on titlebar,
+    variable rounding on corners, variable transparency on window
+    backgrounds, stock icons in themes, can remove all titlebar buttons
+    from certain classes of window, and more (Thomas) [#102547 and
+    dependencies]
+  - improve "Force Quit" dialog (Bruno) [#121936]
+  - ignore edge resistance when resizing with keyboard (Elijah) [#346782]
+  - maintain window size and placement across restarts (Carlo) [#358042]
+  - prevent crash when closing certain remote apps (Elijah) [#358514]
+  - longstanding mouse-focus bug fixed which affected firefox's
+    autocompletion (Elijah) [#357695]
+  - ignore maximum size constraints when maximising (Elijah) [#327543]
+  - warn translators to keep translations in sync with libwnck (Bruno)
+    [#355620]
+  - fixes for compilation warnings, etc (Elijah, Jens) [#348067, #356631]
+
+Translators
+  Ivar Smolin (et), Gabor Kelemen (hu), Luca Ferretti (it),
+  Runa Bhattacharjee (bn_IN)
+
+2.16.2
+======
+
+Thanks to Eljah Newren, Maik Beckmann, Christian Hamar, Thomas Andersen,
+and Bruno Boaventura de Oliveira for changes in this release.
+
+  - partial audit to fix timestamp usage (Elijah) [part of #355180]
+  - remove compilation warnings (Maik) [#355876]; (Bruno) [#355490,
+    #355489]
+  - automatic detection of stable/unstable in configure script
+    (Christian/Elijah) [#356122]
+  - make windows be stacked correctly before showing them (Thomas)
+    [#332385]
+  - use guint32 for timestamps (Elijah) [#348305]
+
+Translators
+  Wouter Bolsterlee (nl), Matic Žgur (sl), Francisco Javier F. Serrador (es),
+  Vladimir Petkov (bg), Jordi Mallach (ca), Ilkka Tuohela (fi),
+  Rajesh Ranjan (hi), Woodman Tuen (zh_HK, zh_TW), Ani Peter (ml),
+  Felix (ta), Ankit Patel (gu), Mohammad DAMT (id)
+ 
+2.16.1
+======
+
+Thanks to Elijah Newren, Colin Watson, and Bruno Boaventura de Oliveira
+Lacerda for changes in this release.
+
+  - fix stuck grab, letting focus be transferred between windows (Elijah)
+    [#354422 partial]
+  - windows returning from fullscreen are constrained to be onscreen
+    (Elijah) [#353699]
+  - Clear the transient_for flag of a window after emitting a warning
+    (Colin)
+  - Replace copy_of_gdk_x11_window_set_user_time() with the real thing
+    (Bruno) [#352293]
+
+Translators
+  David Lodge (en_GB), Ivar Smolin (et), Matic Žgur (sl),
+  Vasiliy Faronov (ru)
+
+2.16.0
+==
+
+Thanks to Jens Granseuer for changes in this release.
+
+ - Fix the build with c89/gcc 2.95.
+
+Translators
+  Rahul Bhalerao (mr), Runa Bhattacharjee (bn_IN), Woodman Tuen
+  (zh_HK, zh_TW), Kostas Papadimas (el), Ani Peter (ml),
+  Jonathan Ernst (fr), Горан Ракић (sr, Gabor Kelemen (hu),
+  Maxim Dziumanenko (uk), Duarte Loreto (pt), Jordi Mallach (ca),
+  Gintautas Miliauskas (lt)
+
+2.15.34
+==
+
+Thanks to Stéphane Rosi, Vytautus Liuolia, Will Walker, Baptiste
+Mille-Mathias, Elijah Newren, Ed Catmur, and Thomas Andersen for fixes
+in this release.
+
+ - allow moving maximized windows between xineramas again (Stéphane)
+   [#338660]
+ - fix an uninitialized-usage bug with net_wm_user_time that breaks
+   focus with new windows (Vytautus)
+ - re-fix accessibility events for the alt-tab popup (Will) [#350624]
+ - update the close pixmap to fit better with the other pixmaps of the
+   menu (Baptiste) [#345498]
+ - fix several fullscreen handling bugs I introduced, causing
+   fullscreen windows to not actually be shown fullscreen (Elijah)
+   [#343115]
+ - fix keybindings with hex-values, coming from special extended
+   keyboard keys (Ed) [#140448]
+ - fix metacity-dialog handling of arguments (Thomas) [#340690]
+
+Translators
+  Vladimir Petkov (bg), Jordi Mallach (ca), Gabor Kelemen (hu),
+  Mohammad DAMT (id), Wouter Bolsterlee (nl), Daniel Nylander (sv),
+  Funda Wang (zh_CN)
+
+2.15.21
+==
+
+Thanks to Vincent Untz, Jens Granseuer, Björn Lindqvist, Dmitry
+Timoshkov, Thomas Thurman, Vytautas Liuolia, Thomas Andersen, Chris
+Ball, and Elijah Newren for fixes in this release.
+
+ - kill usage of libegg (Vincent) [#348633]
+ - fix another C89 vs. C99 issue (Jens) [#347621]
+ - make it so maximized windows do not have rounded corners (Björn)
+   [#336850]
+ - fix the heuristic for determining if windows can be made
+   fullscreen, needed for WINE and possible also some legacy
+   applications (Dmitry) [#346927]
+ - make sure window features get recalculated when the screen is
+   resized via XRandR (Dmitry) [#346927]
+ - fitts' law fixes for titlebar buttons on maximized windows (Thomas
+   Thurman) [#97703]
+ - react to _NET_STARTUP_ID changes, as proposed for the new
+   startup-notification/EWMH spec (Vytautas) [#347515]
+ - return the window to maximized state if the window was "shaken
+   loose" from maximized state during a resize but the resize is later
+   aborted (Thomas Andersen) [#346719]
+ - fix button lighting with dragged clicks (Björn) [#321474]
+ - don't minimize in response to double clicks on the titlebar when
+   minimiziation should not be allowed (Chris) [#347377]
+ - fix some titlebar-not-on-screen constraint issues (Elijah)
+   [#333328, #345522]
+
+Translators
+ Mahay Alam Khan (bn_IN), Jakub Friedl (cs), Iñaki Larrañaga 
+ Murgoitio (eu), Yuval Tanny (he), Rajesh Ranjan (hi), Jovan
+ Naumovski (mk) Kjartan Maraas (nb), Leonid Kanter (ru)
+
+2.15.13
+==
+
+Thanks to Björn Lindqvist and Thomas Thurman for improvements in this
+release.
+
+ - grab alt+shift+button1 when trying to snap-move windows (Björn)
+ - avoid a case where memory is written after it's freed (Thomas)
+
+Translators
+ Hendrik Richter (de), Kostas Papadimas (el), Jonathan Ernst (fr),
+ Satoru SATOH (ja)
+
+2.15.8
+==
+
+Known as the "Elijah sucks for not reviewing a couple dozen patches"
+release.  And for not getting on IRC soon enough to catch Marnanel and
+show him how to do the release.  So, just translations this time.
+
+Translations
+
+  Mahay Alam Khan (bn_IN), Rhys Jones (cy), Francisco Javier
+  F. Serrador (es), Ilkka Tuohela (fi), Rajesh Ranjan (hi), Changwoo
+  Ryu (ko), Fano Rajaonarisoa (mg), Sanlig Badral (mn), Слободан Д. 
+  Средојевић (sr), Funda Wang (zh_CN)
+
+2.15.5
+==
+
+Thanks to Björn Lindqvist, Søren Sandmann, Adam Jackson, Elijah
+Newren, and Aidan Delaney for improvements in this release.
+	
+ - code cleanup in resizepopup.c (Björn) [#341648]
+ - fix a logic bug so that the whole titlebar becomes sensitive to
+   mouse clicks (Björn) [#336320]
+ - make mouse cursor when moving windows become a hand (Björn) [#337376]
+ - lots and lots of compositor improvements -- beginning of a new
+   layer to abstract transition effects, shrinking and minimizing and
+   exploding effects, fading in and out, unminimize animation that
+   reverses minimize one, translucent menus, bounce on window focus,
+   and all kinds of stuff I don't understand and can't summarize well
+   (Søren, Adam)
+ - Fix a crash on exit/logout from assuming a compositor would always
+   exist (Elijah) [#342166]
+ - code cleanup in tabpopup.c (Aidan Delaney) [#166890]
+
+Translations
+  Pema Geyleg (dz), Iñaki Larrañaga Murgoitio (eu), Theppitak
+  Karoonboonyanan (th), Clytie Siddall (vi)
+
+2.15.3
+==
+
+Thanks to Søren Sandmann, Elijah Newren, Paolo Borelli, Björn
+Lindqvist, jylefort at FreeBSD org, 
+
+ - various code cleanups (Søren)
+ - prevent long titles from "sticking" in the tasklist (Elijah) [#330671]
+ - handle sync counter notifications in the compositor (Søren)
+ - notes/documentation updates (Elijah)
+ - plug a small leak (Paolo)
+ - remove a lot of dead code obsoleted by the new edge-resistance
+   stuff (Björn) [#341561]
+ - prevent a crash when changing resolution (jylefort) [#340847]
+ - revert an accessibility module loading workaround from Gnome 2.6
+   that has long since been fixed for us in gtk+ (Elijah) [#123372]
+
+Translations
+  Francisco Javier F. Serrador (es), Ignacio Casal Quinteiro (gl),
+  Raivis Dejus (lv), Kjartan Maraas (nb), Funda Wang (zh_CN), Woodman
+  Tuen (zh_HK), Woodman Tuen (zh_TW)
+
+2.15.2
+==
+
+Here's hoping that "third time's a charm."  ;-) This release just
+fixes the translations-not-included issue.  See
+http://mail.gnome.org/archives/desktop-devel-list/2006-April/msg00483.html
+for more details.
+
+ - Use gnome-autogen.sh like most other modules (Rodney)
+
+2.15.1
+==
+
+This release just fixes the control-center build (which depends upon
+libmetacity-private).  Thanks to Vincent for catching the problem.
+
+ - Include boxes.h in the includes dir (Elijah) [#339708]
+
 2.15.0
 ==
 

README

@@ -6,10 +6,11 @@ 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.[01], 2.8.1.x, 2.8.5-, 2.10.x,
-2.12.x, 2.14.x.
+The stable releases so far are 2.4.x, 2.6.x, 2.8.[01], 2.8.1.x, 2.8.5-,
+2.10.x, 2.12.x, 2.14.x, 2.16.x.
 
-Unstable branches are 2.3.x, 2.5.x, 2.8.2-4, 2.9.x, 2.11.x, 2.13.x, 2.15.x
+Unstable branches are 2.3.x, 2.5.x, 2.8.2-4, 2.9.x, 2.11.x, 2.13.x,
+2.15.x, 2.17.x.
 
 COMPILING METACITY
 ===

autogen.sh

@@ -4,140 +4,18 @@
 srcdir=`dirname $0`
 test -z "$srcdir" && srcdir=.
 
-ORIGDIR=`pwd`
-cd $srcdir
-PROJECT=metacity
-TEST_TYPE=-f
-FILE=src/display.c
+PKG_NAME="metacity"
+REQUIRED_AUTOMAKE_VERSION=1.10
 
-DIE=0
-
-(autoconf --version) < /dev/null > /dev/null 2>&1 || {
-	echo
-	echo "You must have autoconf installed to compile $PROJECT."
-	echo "Download the appropriate package for your distribution,"
-	echo "or get the source tarball at http://ftp.gnu.org/gnu/autoconf/"
-	DIE=1
+(test -f $srcdir/configure.in \
+  && test -d $srcdir/src) || {
+    echo -n "**Error**: Directory "\`$srcdir\'" does not look like the"
+    echo " top-level metacity directory"
+    exit 1
 }
 
-if automake-1.9 --version < /dev/null > /dev/null 2>&1; then
-  AUTOMAKE=automake-1.9
-  ACLOCAL=aclocal-1.9
-elif automake-1.8 --version < /dev/null > /dev/null 2>&1; then
-  AUTOMAKE=automake-1.8
-  ACLOCAL=aclocal-1.8
-elif automake-1.7 --version < /dev/null > /dev/null 2>&1; then
-  AUTOMAKE=automake-1.7
-  ACLOCAL=aclocal-1.7
-else
-        echo
-        echo "You must have automake >= 1.7 installed to compile $PROJECT."
-        echo "Get http://ftp.gnu.org/gnu/automake/automake-1.9.3.tar.bz2"
-        echo "(or a newer version if it is available)"
-        DIE=1
-fi
-
-(grep "^AM_PROG_LIBTOOL" configure.in >/dev/null) && {
-  (libtool --version) < /dev/null > /dev/null 2>&1 || {
-    echo
-    echo "**Error**: You must have \`libtool' installed to compile $PROJECT."
-    echo "Get http://ftp.gnu.org/gnu/libtool/libtool-1.5.10.tar.gz"
-    echo "(or a newer version if it is available)"
-    DIE=1
-  }
+which gnome-autogen.sh || {
+    echo "You need to install gnome-common from the GNOME CVS"
+    exit 1
 }
-
-CONFIGURE=configure.in
-if grep "^AM_[A-Z0-9_]\{1,\}_GETTEXT" "$CONFIGURE" >/dev/null; then
-  if grep "sed.*POTFILES" "$CONFIGURE" >/dev/null; then
-    GETTEXTIZE=""
-  else
-    if grep "^AM_GLIB_GNU_GETTEXT" "$CONFIGURE" >/dev/null; then
-      GETTEXTIZE="glib-gettextize"
-      GETTEXTIZE_URL="ftp://ftp.gtk.org/pub/gtk/v2.0/glib-2.0.0.tar.gz"
-    else
-      GETTEXTIZE="gettextize"
-      GETTEXTIZE_URL="ftp://alpha.gnu.org/gnu/gettext-0.10.35.tar.gz"
-    fi
-
-    $GETTEXTIZE --version < /dev/null > /dev/null 2>&1
-    if test $? -ne 0; then
-      echo
-      echo "**Error**: You must have \`$GETTEXTIZE' installed to compile $PKG_NAME."
-      echo "Get $GETTEXTIZE_URL"
-      echo "(or a newer version if it is available)"
-      DIE=1
-    fi
-  fi
-fi
-
-if test "$DIE" -eq 1; then
-	exit 1
-fi
-
-test $TEST_TYPE $FILE || {
-	echo "You must run this script in the top-level $PROJECT directory"
-	exit 1
-}
-
-if test -z "$*"; then
-	echo "I am going to run ./configure with no arguments - if you wish "
-        echo "to pass any to it, please specify them on the $0 command line."
-fi
-
-topdir=`pwd`
-for coin in .
-do 
-  dr=`dirname $coin`
-  if test -f $dr/NO-AUTO-GEN; then
-    echo skipping $dr -- flagged as no auto-gen
-  else
-    echo processing $dr
-    cd $dr
-    if grep "^AM_GLIB_GNU_GETTEXT" configure.in >/dev/null; then
-      if grep "sed.*POTFILES" configure.in >/dev/null; then
-	: do nothing -- we still have an old unmodified configure.in
-      else
-	echo "Creating $dr/aclocal.m4 ..."
-	test -r $dr/aclocal.m4 || touch $dr/aclocal.m4
-	echo "Running glib-gettextize...  Ignore non-fatal messages."
-	echo "no" | glib-gettextize --force --copy || exit $?
-	echo "Making $dr/aclocal.m4 writable ..."
-	test -r $dr/aclocal.m4 && chmod u+w $dr/aclocal.m4
-      fi
-    fi
-    if grep "^AC_PROG_INTLTOOL" configure.in >/dev/null; then
-      echo "Running intltoolize..."
-      intltoolize --force --copy --automake || exit $?
-    fi
-    if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
-      echo "Running libtoolize..."
-      libtoolize --force --copy || exit $?
-    fi
-
-    echo "Running $ACLOCAL $ACLOCAL_FLAGS ..."
-    $ACLOCAL $ACLOCAL_FLAGS || exit $?
-    echo "Running autoconf ..."
-    autoconf || exit $?
-    if grep "^AC_CONFIG_HEADERS" configure.in >/dev/null; then
-      echo "Running autoheader..."
-      autoheader || exit $?
-    fi
-    echo "Running $AUTOMAKE..."
-    $AUTOMAKE --add-missing --force --gnu || exit $?
-
-    cd $topdir
-  fi
-done
-
-conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
-
-cd "$ORIGDIR"
-
-if test x$NOCONFIGURE = x; then
-  echo Running $srcdir/configure $conf_flags "$@" ...
-  $srcdir/configure $conf_flags "$@" \
-  && echo Now type \`make\' to compile $PROJECT  || exit $?
-else
-  echo Skipping configure process.
-fi
+USE_GNOME2_MACROS=1 USE_COMMON_DOC_BUILD=yes . gnome-autogen.sh

configure.in

@@ -1,11 +1,17 @@
 AC_PREREQ(2.50)
 
+m4_define([metacity_major_version], [2])
+m4_define([metacity_minor_version], [23])
 # Fibonacci sequence for micro version numbering:
 # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987
-AC_INIT([metacity], [2.15.0],
+m4_define([metacity_micro_version], [3])
+
+m4_define([metacity_version],
+          [metacity_major_version.metacity_minor_version.metacity_micro_version])
+AC_INIT([metacity], [metacity_version],
         [http://bugzilla.gnome.org/enter_bug.cgi?product=metacity])
 
-AC_CONFIG_SRCDIR(src/display.c)
+AC_CONFIG_SRCDIR(src/core/display.c)
 AC_CONFIG_HEADERS(config.h)
 
 AM_INIT_AUTOMAKE
@@ -101,7 +107,7 @@ if test "x$GCC" = "xyes"; then
 fi
 changequote([,])dnl
 
-METACITY_PC_MODULES='gtk+-2.0 >= 2.2.0 pango >= 1.2.0'
+METACITY_PC_MODULES='gtk+-2.0 >= 2.10.0 pango >= 1.2.0'
 
 AC_ARG_ENABLE(gconf,
   AC_HELP_STRING([--disable-gconf],
@@ -114,7 +120,7 @@ if test x$enable_gconf = xyes; then
 fi
 
 AC_ARG_ENABLE(verbose-mode,
-  AC_HELP_STRING([--disable-verbose],
+  AC_HELP_STRING([--disable-verbose-mode],
                  [disable metacity's ability to do verbose logging, for embedded/size-sensitive custom builds]),,
   enable_verbose_mode=yes)
 
@@ -170,6 +176,10 @@ else
    AC_MSG_ERROR("Pango 1.2.0 or greater based on Xft2 is required")
 fi
 
+# Unconditionally use this dir to avoid a circular dep with gnomecc
+GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
+AC_SUBST(GNOME_KEYBINDINGS_KEYSDIR)
+
 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
@@ -213,15 +223,15 @@ 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
+   echo "Building compositing manager by default now."
+   have_xcomposite=yes
 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 cm"
+  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
@@ -416,7 +426,7 @@ case "$METACITY_LIBS" in
  *)
   AC_CHECK_LIB(SM, SmcSaveYourselfDone, 
                [AC_CHECK_HEADERS(X11/SM/SMlib.h,
-                                METACITY_LIBS="-lSM -lICE $METACITY_LIBS" found_sm=no)],
+                                METACITY_LIBS="-lSM -lICE $METACITY_LIBS" found_sm=yes)],
                , $METACITY_LIBS)
     ;;
 esac
@@ -449,12 +459,6 @@ fi
 
 AC_SUBST(GDK_PIXBUF_CSOURCE)
 
-## hack to work with old GTK versions for now 
-save_LDFLAGS=$LDFLAGS
-LDFLAGS="$METACITY_LIBS $LDFLAGS"
-AC_CHECK_FUNCS(gdk_pixbuf_new_from_stream)
-LDFLAGS=$save_LDFLAGS
-
 if test x$enable_gconf = xyes; then 
    AC_PATH_PROG(GCONFTOOL, gconftool-2, no)
    if test x"$GCONFTOOL" = xno; then
@@ -467,6 +471,12 @@ else
   GCONF_SCHEMAS_INSTALL_FALSE=
 fi
 
+AC_ARG_ENABLE(debug,
+	[  --enable-debug		enable debugging],,
+	enable_debug=no)
+if test "x$enable_debug" = "xyes"; then
+	CFLAGS="$CFLAGS -g -O -Wall"
+fi
 AC_CONFIG_FILES([
 Makefile
 doc/Makefile
@@ -483,11 +493,8 @@ AC_OUTPUT
 
 if test x$enable_gconf = xno; then
         echo "*** WARNING WARNING WARNING WARNING WARNING"
-        echo "*** Building without GConf"
-        echo "*** This means there's no way to change prefs except"
-        echo "*** hacking source code, at least for now."
-        echo "*** Also, some prefs may have broken defaults."
-        echo "*** Patches needed for a simple no-gconf config file."
+        echo "*** Building without GConf.  This means there's no"
+        echo "*** way to change prefs except hacking source code."
         echo "*** This is intended for embedded systems etc., not for normal use."
 fi
 
@@ -519,5 +526,13 @@ metacity-$VERSION:
 	Render:                   ${have_xrender}
 	Xcursor:                  ${have_xcursor}
 "
-echo "This is the UNSTABLE branch of metacity"
-echo "Use 2.14.x for stable (gnome-2-14 branch in CVS)"
+
+METACITY_MINOR_VERSION=metacity_minor_version
+if test $(( $(echo $METACITY_MINOR_VERSION) %2)) == "1"; then
+   stable_version=$(( ($METACITY_MINOR_VERSION / 2) * 2))
+   echo "This is the UNSTABLE branch of metacity"
+   echo -n "Use 2.$stable_version.x for stable "
+   echo    "(gnome-2-$stable_version branch in Subversion)"
+else
+   echo "This is the stable branch of metacity"
+fi

doc/compositor-control.txt

@@ -0,0 +1,46 @@
+The compositor is the box of tricks inside the window manager which performs
+special effects on the windows on your screen. Metacity's compositor is
+under development. Your help is requested in finding and fixing bugs. This
+document tells you how to configure Metacity so that you can use compositing.
+
+To turn the compositor on initially, you need to pass --enable-compositor to
+the configure script. This will introduce a dependence on libcm, which you
+can get from <URL:http://ftp.gnome.org/pub/GNOME/sources/libcm/>.
+
+When Metacity is compiled, you will need to turn the compositor on in gconf
+for it to have any effect. You will find the boolean switch at
+
+   /apps/metacity/general/compositing_manager
+
+When that's done, you can set some environment variables before you launch
+Metacity to influence how the compositor works. These will eventually become
+configuration options or gconf options when they grow up. Define them to any
+value to turn them on; leave them undefined to turn them off. Currently the
+options you can set are:
+
+   LIBCM_DIRECT
+
+      If this is set, the compositor will bypass the X server and do all its
+      work directly with the hardware. I know of no reason you would want to
+      do so, but perhaps you do.
+
+   LIBCM_TFP
+
+      If this is set ("tfp mode"), the compositor will feel free to use the
+      texture_from_pixmap extension; if this is not set ("non-tfp mode"), the
+      compositor will use a workaround. Many drivers require non-tfp mode in
+      order to work, and will paint all windows clear blue or clear white
+      without it. Thanks to Travis Watkins for suggesting this switch; he
+      cautions that some games or video players may require tfp mode.
+
+   METACITY_BLING
+
+      This turns on several pretty but non-essential animations (dialogues
+      fracturing and exploding, minimisations doing a shrinkydink effect,
+      and so on). If it is not set, the standard non-GL animations are
+      retained. This affects only window event animations; it doesn't change
+      menus zooming, dialogues being semi-transparent, and so on. Try it
+      and see whether you like it.
+
+If you have any problems, ask on metacity-devel-list@gnome.org, or
+#gnome-hackers on gimpnet, or come and find me (tthurman at gnome) and ask.

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

@@ -9,7 +9,8 @@ basics are easy:
 Focus method  Behavior
     click     When a user clicks on a window, focus it
    sloppy     When an EnterNotify is received, focus the window
-    mouse     Same as sloppy, but also defocus on LeaveNotify
+    mouse     Same as sloppy, but also defocus when mouse enters DESKTOP
+              window
 
 Note that these choices (along with the choice that clicking on a
 window raises it for the click focus method) introduces the following
@@ -20,8 +21,8 @@ Focus method  Invariant
    sloppy     If the mouse is in a window, then it is focused; if the
               mouse is not in a window, then the most recently used
               window is focused.
-    mouse     If the mouse is in a window, then it is focused; otherwise,
-              the designated "no_focus_window" is focused
+    mouse     If the mouse is in a non-DESKTOP window, then it is focused;
+              otherwise, the designated "no_focus_window" is focused
 
 However, there are a number of cases where the current focus window
 becomes invalid and another should be chosen.  Some examples are when
@@ -34,8 +35,9 @@ Focus method  Behavior
               on top)
    sloppy     Focus the window containing the pointer if there is such
               a window, otherwise focus the most recently used window.
-    mouse     Focus the window containing the pointer if there is one,
-              otherwise focus the designated "no_focus_window".
+    mouse     Focus the non-DESKTOP window containing the pointer if
+              there is one, otherwise focus the designated
+              "no_focus_window".
 
 Note that "most recently used window", as used here, has a slightly
 different connotation than "most recent to have keyboard focus".  This
@@ -62,9 +64,9 @@ cases in which a new window shouldn't be focused:
 
 To handle these cases, Metacity compares timestamps of the event that
 caused the launch and the timestamp of the last interaction with the
-focused window.  (Case 2 is handled by providing a special timestamp
-of 0 for the launch time, which ensures that the window that appears
-doesn't get focus)
+focused window.  (Case 2 is handled by the application providing a
+special timestamp of 0 for the launch time, which ensures that the
+window that appears doesn't get focus)
 
 If the newly launched window isn't focused, some things should be done
 to alert the user that there is a window to work with:
@@ -84,10 +86,10 @@ attempt to handle the INHERENTLY CONFLICTING CONSTRAINTS.  Metacity does
 this by having a mouse_mode boolean used to determine which of the two
 sets of invariants holds.  This mode is set according to which method was
 most recently used to choose a focus window:
-  1) When receiving EnterNotify/LeaveNotify events from mouse movement, set
+  1) When receiving EnterNotify events from mouse movement, set
      mouse_mode to TRUE.
   2) When using keynav to choose a focus window (e.g. alt-tab, alt-esc,
-     move-window-to-workspace keybindings), set mouse_mode to FALSE.
+     alt-f2, move-window-to-workspace keybindings), set mouse_mode to FALSE.
   3) When handling events that don't choose a focus window but rather need
      a focus_window chosen for them (e.g. switch-to-workspace keybindings),
      don't change the mouse_mode and just use the current value.
@@ -123,6 +125,7 @@ To read more about the bugs that inspired these choices:
   - Mousenav vs. Keynav in mouse and sloppy focus modes
     http://bugzilla.gnome.org/show_bug.cgi?id=167545
     http://bugzilla.gnome.org/show_bug.cgi?id=101190
+    http://bugzilla.gnome.org/show_bug.cgi?id=357695
   - Not focusing panels
     http://bugzilla.gnome.org/show_bug.cgi?id=160470
     http://bugzilla.gnome.org/show_bug.cgi?id=120100

doc/theme-format.txt

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

po/.cvsignore

@@ -9,3 +9,4 @@ cat-id-tbl.c
 messages
 missing
 stamp-cat-id
+stamp-it

po/LINGUAS

@@ -2,16 +2,20 @@
 #
 am
 ar
+as
 az
 be
+be@latin
 bg
 bn
+bn_IN
 bs
 ca
 cs
 cy
 da
 de
+dz
 el
 en_CA
 en_GB
@@ -33,18 +37,23 @@ id
 is
 it
 ja
+ka
+kn
 ko
 ku
 lt
 lv
+mg
 mk
 ml
 mn
+mr
 ms
 nb
 ne
 nl
 nn
+oc
 or
 pa
 pl
@@ -53,8 +62,9 @@ pt_BR
 ro
 ru
 rw
-sl
+si
 sk
+sl
 sq
 sr
 sr@Latn
@@ -68,4 +78,5 @@ vi
 wa
 xh
 zh_CN
+zh_HK
 zh_TW

po/POTFILES.in

@@ -1,26 +1,29 @@
 # List of source files containing translatable strings.
 # Please keep this file sorted alphabetically.
-src/tools/metacity-message.c
-src/delete.c
-src/display.c
-src/errors.c
-src/frames.c
-src/keybindings.c
-src/main.c
-src/menu.c
-src/metaaccellabel.c
-src/metacity-dialog.c
+src/50-metacity-desktop-key.xml.in
+src/50-metacity-key.xml.in
+src/core/core.c
+src/core/delete.c
+src/core/display.c
+src/core/errors.c
+src/core/keybindings.c
+src/core/main.c
+src/core/prefs.c
+src/core/screen.c
+src/core/session.c
+src/core/util.c
+src/core/window-props.c
+src/core/window.c
+src/core/xprops.c
 src/metacity.desktop.in
 src/metacity.schemas.in
-src/prefs.c
-src/resizepopup.c
-src/screen.c
-src/session.c
-src/theme-parser.c
-src/theme-viewer.c
-src/theme.c
-src/util.c
-src/window-props.c
-src/window.c
-src/workspace.c
-src/xprops.c
+src/ui/frames.c
+src/ui/menu.c
+src/ui/metaaccellabel.c
+src/ui/metacity-dialog.c
+src/ui/resizepopup.c
+src/ui/theme-parser.c
+src/ui/theme-viewer.c
+src/ui/theme.c
+src/tools/metacity-message.c
+

rationales.txt

@@ -50,6 +50,12 @@ Pointer warping:
   (Think about tasklist & window selector too; this would be a very bad idea)
 
 
+Bugs for easy dupe-finding that seem to be hard to find otherwise:
+===
+Applications opening in wrong workspace:
+  http://bugzilla.gnome.org/show_bug.cgi?id=160687
+
+
 Tracking bugs
 ====
 
@@ -68,3 +74,6 @@ moving/resizing (constraints): http://bugzilla.gnome.org/show_bug.cgi?id=155458
                 modal dialogs: http://bugzilla.gnome.org/show_bug.cgi?id=164841
      multi-head sans xinerama: http://bugzilla.gnome.org/show_bug.cgi?id=324772
                      xinerama: http://bugzilla.gnome.org/show_bug.cgi?id=324773
+          output-only windows: http://bugzilla.gnome.org/show_bug.cgi?id=340584
+  allowed actions/window-type: http://bugzilla.gnome.org/show_bug.cgi?id=340682
+        EWMH/ICCCM compliance: http://bugzilla.gnome.org/show_bug.cgi?id=340691

src/50-metacity-desktop-key.xml.in

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<KeyListEntries _name="Desktop" wm_name="Metacity" package="metacity">
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/panel_run_dialog" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/panel_main_menu" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/run_command_screenshot" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/run_command_window_screenshot" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/run_command_terminal" />
+
+</KeyListEntries>
+

src/50-metacity-key.xml.in

@@ -0,0 +1,269 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<KeyListEntries _name="Window Management" wm_name="Metacity" package="metacity">
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/activate_window_menu" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/toggle_fullscreen" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/toggle_maximized" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/maximize" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/unmaximize" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/toggle_shaded" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/close" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/minimize" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/begin_move" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/begin_resize" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/toggle_on_all_workspaces"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/raise_or_lower" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/raise" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/lower" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/maximize_vertically" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/maximize_horizontally" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_1"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_2"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_3"
+	value="2"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_4"
+	value="3"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_5"
+	value="4"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_6"
+	value="5"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_7"
+	value="6"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_8"
+	value="7"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_9"
+	value="8"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_10"
+	value="9"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_11"
+	value="10"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_12"
+	value="11"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_left"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_right"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_up"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/window_keybindings/move_to_workspace_down"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_windows" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_group" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_panels" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/cycle_windows" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/cycle_group" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/cycle_panels" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/show_desktop" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_1"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_2"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_3"
+	value="2"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_4"
+	value="3"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_5"
+	value="4"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_6"
+	value="5"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_7"
+	value="6"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_8"
+	value="7"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_9"
+	value="8"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_10"
+	value="9"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_11"
+	value="10"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_12"
+	value="11"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_left"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_right"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_up"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/metacity/global_keybindings/switch_to_workspace_down"
+	value="1"
+	key="/apps/metacity/general/num_workspaces"
+	comparison="gt" />
+
+</KeyListEntries>
+

src/Makefile.am

@@ -2,138 +2,130 @@ lib_LTLIBRARIES = libmetacity-private.la
 
 SUBDIRS=wm-tester tools themes
 
-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	\
-	eggaccelerators.h
+INCLUDES=@METACITY_CFLAGS@ -I $(srcdir)/include -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
 
 metacity_SOURCES= 				\
-	async-getprop.c				\
-	async-getprop.h				\
-	bell.h					\
-	bell.c					\
-	boxes.h					\
-	boxes.c					\
-	common.h				\
-	c-screen.c				\
-	c-screen.h				\
-	compositor.c				\
-	compositor.h				\
-	constraints.c				\
-	constraints.h				\
-	core.c					\
-	core.h					\
-	delete.c				\
-	display.c				\
-	display.h				\
-	draw-workspace.c			\
-	draw-workspace.h			\
-	edge-resistance.c			\
-	edge-resistance.h			\
-	effects.c				\
-	effects.h				\
-	errors.c				\
-	errors.h				\
-	eventqueue.c				\
-	eventqueue.h				\
-	fixedtip.c				\
-	fixedtip.h				\
-	frame.c					\
-	frame.h					\
-	frames.c				\
-	frames.h				\
-	gradient.c				\
-	gradient.h				\
-	group.c					\
-	group.h					\
-	group-private.h				\
-	group-props.c				\
-	group-props.h				\
-	iconcache.c				\
-	iconcache.h				\
+	core/async-getprop.c			\
+	core/async-getprop.h			\
+	core/bell.c				\
+	core/bell.h				\
+	core/boxes.c				\
+	include/boxes.h				\
+	core/compositor.c			\
+	core/compositor.h			\
+	core/constraints.c			\
+	core/constraints.h			\
+	core/core.c				\
+	core/delete.c				\
+	core/display.c				\
+	core/display.h				\
+	ui/draw-workspace.c			\
+	ui/draw-workspace.h			\
+	core/edge-resistance.c			\
+	core/edge-resistance.h			\
+	core/effects.c				\
+	core/effects.h				\
+	core/errors.c				\
+	core/errors.h				\
+	core/eventqueue.c			\
+	core/eventqueue.h			\
+	core/frame.c				\
+	core/frame.h				\
+	ui/gradient.c				\
+	ui/gradient.h				\
+	core/group-private.h			\
+	core/group-props.c			\
+	core/group-props.h			\
+	core/group.c				\
+	core/group.h				\
+	core/iconcache.c			\
+	core/iconcache.h			\
+	core/keybindings.c			\
+	core/keybindings.h			\
+	core/main.c				\
+	include/main.h				\
+	core/metacity-Xatomtype.h		\
+	core/place.c				\
+	core/place.h				\
+	core/prefs.c				\
+	include/prefs.h				\
+	core/screen.c				\
+	core/screen.h				\
+	core/session.c				\
+	core/session.h				\
+	core/stack.c				\
+	core/stack.h				\
+	core/util.c				\
+	include/util.h				\
+	core/window-props.c			\
+	core/window-props.h			\
+	core/window.c				\
+	core/window.h				\
+	core/workspace.c			\
+	core/workspace.h			\
+	core/xprops.c				\
+	core/xprops.h				\
+	include/common.h			\
+	include/core.h				\
+	include/ui.h				\
 	inlinepixbufs.h				\
-	keybindings.c				\
-	keybindings.h				\
-	main.c					\
-	main.h					\
-	menu.c					\
-	menu.h					\
-	metaaccellabel.c			\
-	metaaccellabel.h			\
-	metacity-Xatomtype.h			\
-	place.c					\
-	place.h					\
-	prefs.c					\
-	prefs.h					\
-	resizepopup.c				\
-	resizepopup.h				\
-	screen.c				\
-	screen.h				\
-	session.c				\
-	session.h				\
-	spring-model.c				\
-	spring-model.h				\
-	stack.c					\
-	stack.h					\
-	tabpopup.c				\
-	tabpopup.h				\
-	theme.c					\
-	theme.h					\
-	theme-parser.c				\
-	theme-parser.h				\
-	themewidget.c				\
-	themewidget.h				\
-	ui.c					\
-	ui.h					\
-	util.c					\
-	util.h					\
-	window.c				\
-	window.h				\
-	window-props.c				\
-	window-props.h				\
-	workspace.c				\
-	workspace.h				\
-	xprops.c				\
-	xprops.h				\
-	$(EGGFILES)
+	ui/fixedtip.c				\
+	ui/fixedtip.h				\
+	ui/frames.c				\
+	ui/frames.h				\
+	ui/menu.c				\
+	ui/menu.h				\
+	ui/metaaccellabel.c			\
+	ui/metaaccellabel.h			\
+	ui/resizepopup.c			\
+	include/resizepopup.h			\
+	ui/tabpopup.c				\
+	include/tabpopup.h				\
+	ui/theme-parser.c			\
+	ui/theme-parser.h			\
+	ui/theme.c				\
+	ui/theme.h				\
+	ui/themewidget.c			\
+	ui/themewidget.h			\
+	ui/ui.c
 
 # by setting libmetacity_private_la_CFLAGS, the files shared with
 # metacity proper will be compiled with different names.
 libmetacity_private_la_CFLAGS =
-libmetacity_private_la_SOURCES=	\
-	boxes.c			\
-	boxes.h			\
-	gradient.c		\
-	gradient.h		\
-	preview-widget.c	\
-	preview-widget.h	\
-	theme.c			\
-	theme.h			\
-	theme-parser.c		\
-	theme-parser.h		\
-	util.c			\
-	util.h			\
-	common.h
+libmetacity_private_la_SOURCES=			\
+	core/boxes.c				\
+	include/boxes.h				\
+	ui/gradient.c				\
+	ui/gradient.h				\
+	core/util.c				\
+	include/util.h				\
+	include/common.h			\
+	ui/preview-widget.c			\
+	ui/preview-widget.h			\
+	ui/theme-parser.c			\
+	ui/theme-parser.h			\
+	ui/theme.c				\
+	ui/theme.h
 
 libmetacity_private_la_LDFLAGS = -no-undefined
 libmetacity_private_la_LIBADD  = @METACITY_LIBS@
 
 libmetacityincludedir = $(includedir)/metacity-1/metacity-private
 
-libmetacityinclude_HEADERS =	\
-	common.h		\
-	gradient.h		\
-	preview-widget.h	\
-	theme.h			\
-	theme-parser.h		\
-	util.h
+libmetacityinclude_HEADERS =			\
+	include/boxes.h				\
+	ui/gradient.h				\
+	include/util.h				\
+	include/common.h			\
+	ui/preview-widget.h			\
+	ui/theme-parser.h			\
+	ui/theme.h
 
 metacity_theme_viewer_SOURCES=  \
-	theme-viewer.c
+	ui/theme-viewer.c
 
 metacity_dialog_SOURCES= 	\
-	metacity-dialog.c
+	ui/metacity-dialog.c
 
 bin_PROGRAMS=metacity metacity-theme-viewer
 libexec_PROGRAMS=metacity-dialog
@@ -143,9 +135,9 @@ metacity_LDADD=@METACITY_LIBS@ $(EFENCE)
 metacity_theme_viewer_LDADD= @METACITY_LIBS@ libmetacity-private.la
 metacity_dialog_LDADD=@METACITY_LIBS@
 
-testboxes_SOURCES=util.h util.c boxes.h boxes.c testboxes.c
-testgradient_SOURCES=gradient.h gradient.c testgradient.c
-testasyncgetprop_SOURCES=async-getprop.h async-getprop.c testasyncgetprop.c
+testboxes_SOURCES=include/util.h core/util.c include/boxes.h core/boxes.c core/testboxes.c
+testgradient_SOURCES=ui/gradient.h ui/gradient.c ui/testgradient.c
+testasyncgetprop_SOURCES=core/async-getprop.h core/async-getprop.c core/testasyncgetprop.c
 
 noinst_PROGRAMS=testboxes testgradient testasyncgetprop
 
@@ -163,6 +155,12 @@ schemadir   = @GCONF_SCHEMA_FILE_DIR@
 schema_in_files = metacity.schemas.in
 schema_DATA = $(schema_in_files:.schemas.in=.schemas)
 
+@INTLTOOL_XML_NOMERGE_RULE@
+
+xmldir       = @GNOME_KEYBINDINGS_KEYSDIR@
+xml_in_files = 50-metacity-desktop-key.xml.in 50-metacity-key.xml.in
+xml_DATA     = $(xml_in_files:.xml.in=.xml)
+
 @INTLTOOL_SCHEMAS_RULE@
 
 if GCONF_SCHEMAS_INSTALL
@@ -179,10 +177,10 @@ VARIABLES=default_icon_data $(srcdir)/default_icon.png \
           stock_delete_data $(srcdir)/stock_delete.png
 
 BUILT_SOURCES = inlinepixbufs.h
-CLEANFILES = inlinepixbufs.h metacity.desktop metacity.schemas
+CLEANFILES = inlinepixbufs.h metacity.desktop metacity.schemas 50-metacity-desktop-key.xml 50-metacity-key.xml
 
 inlinepixbufs.h: $(IMAGES)
-	   $(GDK_PIXBUF_CSOURCE) --raw --build-list $(VARIABLES) >$(srcdir)/inlinepixbufs.h
+	$(GDK_PIXBUF_CSOURCE) --raw --build-list $(VARIABLES) >$(srcdir)/inlinepixbufs.h
 
 pkgconfigdir = $(libdir)/pkgconfig
 
@@ -190,13 +188,8 @@ pkgconfig_DATA = libmetacity-private.pc
 
 EXTRA_DIST=$(desktopfiles_files) 	\
 	$(IMAGES) $(schema_DATA) 	\
-	update-from-egg.sh		\
 	$(desktopfiles_in_files)	\
 	$(schema_in_files)		\
+	$(xml_in_files)			\
 	libmetacity-private.pc.in
 
-
-EGGDIR=$(srcdir)/../../libegg/libegg
-
-regenerate-built-sources:
-	EGGFILES="$(EGGFILES)" EGGDIR="$(EGGDIR)" $(srcdir)/update-from-egg.sh

src/api.c

@@ -1,53 +0,0 @@
-/* Metacity misc. public entry points */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * 
- * 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.
- */
-
-#include "api.h"
-#include "display.h"
-#include "colors.h"
-
-PangoContext*
-meta_get_pango_context (Screen                     *xscreen,
-                        const PangoFontDescription *desc)
-{
-  MetaScreen *screen;
-
-  screen = meta_screen_for_x_screen (xscreen);
-
-  g_return_val_if_fail (screen != NULL, NULL);
-
-  return meta_screen_get_pango_context (screen,
-                                        desc,
-                                        /* FIXME, from the frame window */
-                                        PANGO_DIRECTION_LTR);
-}
-
-gulong
-meta_get_x_pixel (Screen *xscreen, const PangoColor *color)
-{
-  MetaScreen *screen;
-
-  screen = meta_screen_for_x_screen (xscreen);
-
-  g_return_val_if_fail (screen != NULL, 0);
-  
-  return meta_screen_get_x_pixel (screen, color);
-}
-

src/api.h

@@ -1,62 +0,0 @@
-/* Metacity misc. public entry points */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * 
- * 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_API_H
-#define META_API_H
-
-/* don't add any internal headers here; api.h is an installed/public
- * header. Only theme.h is also installed.
- */
-#include <X11/Xlib.h>
-#include <pango/pangox.h>
-
-/* Colors/state stuff matches GTK since we get the info from
- * the GTK UI slave
- */
-typedef struct _MetaUIColors MetaUIColors;
-
-typedef enum
-{
-  META_STATE_NORMAL,
-  META_STATE_ACTIVE,
-  META_STATE_PRELIGHT,
-  META_STATE_SELECTED,
-  META_STATE_INSENSITIVE
-} MetaUIState;
-
-struct _MetaUIColors
-{
-  PangoColor fg[5];
-  PangoColor bg[5];
-  PangoColor light[5];
-  PangoColor dark[5];
-  PangoColor mid[5];
-  PangoColor text[5];
-  PangoColor base[5];
-  PangoColor text_aa[5];
-};
-
-PangoContext*       meta_get_pango_context (Screen                     *xscreen,
-                                            const PangoFontDescription *desc);
-gulong              meta_get_x_pixel       (Screen                     *xscreen,
-                                            const PangoColor           *color);
-
-#endif

src/c-screen.c

@@ -1,810 +0,0 @@
-/* 
- * Copyright (C) 2006 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.
- */
-
-#include <config.h>
-
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-#include <cm/ws.h>
-#include <cm/stacker.h>
-#include <cm/wsint.h>
-#include <cm/drawable-node.h>
-#include <cm/state.h>
-#include <cm/magnifier.h>
-#include <cm/square.h>
-
-#include "screen.h"
-#include "c-screen.h"
-
-typedef struct WindowInfo WindowInfo;
-
-struct WindowInfo
-{
-    Window	xwindow;
-    CmNode     *node;
-    gboolean	updates;
-
-    WsRectangle size;
-};
-
-struct MetaScreenInfo
-{
-    WsDisplay *display;
-    CmStacker *stacker;
-    CmMagnifier *magnifier;
-    
-    WsWindow *gl_window;
-    WsWindow *root_window;
-    
-    WsScreen *screen;
-    MetaScreen *meta_screen;
-    
-    GHashTable *window_infos_by_xid;
-    
-    int repaint_id;
-    int idle_id;
-
-    WsWindow *selection_window;
-};
-
-#if 0
-static void
-update_frame_counter (void)
-{
-#define BUFSIZE 128
-    static GTimer *timer;
-    static double buffer [BUFSIZE];
-    static int next = 0;
-    
-    if (!timer)
-	timer = g_timer_new ();
-    
-    buffer[next++] = g_timer_elapsed (timer, NULL);
-    
-    if (next == BUFSIZE)
-    {
-	int i;
-	double total;
-	
-	next = 0;
-	
-	total = 0.0;
-	for (i = 1; i < BUFSIZE; ++i)
-	    total += buffer[i] - buffer[i - 1];
-	
-	g_print ("frames per second: %f\n", 1 / (total / (BUFSIZE - 1)));
-    }
-}
-#endif
-
-static void
-dump_stacking_order (GList *nodes)
-{
-    GList *list;
-    
-    for (list = nodes; list != NULL; list = list->next)
-    {
-	CmDrawableNode *node = list->data;
-	
-	if (node)
-	    g_print ("%lx, ", WS_RESOURCE_XID (node->drawable));
-    }
-    g_print ("\n");
-}
-
-static gboolean
-repaint (gpointer data)
-{
-    MetaScreenInfo *info = data;
-    CmState *state;
-#if 0
-    g_print ("repaint\n");
-#endif
-    glViewport (0, 0,
-		info->meta_screen->rect.width,
-		info->meta_screen->rect.height);
-
-    glLoadIdentity();
-    
-#if 0
-    glClearColor (0, 0, 0, 1.0);
-    glClear (GL_COLOR_BUFFER_BIT);
-#endif
-
-    ws_window_raise (info->gl_window);
-
-#if 0
-    glDisable (GL_TEXTURE_2D);
-    glDisable (GL_TEXTURE_RECTANGLE_ARB);
-    glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
-    glColor4f (0.0, 1.0, 0.0, 1.0);
-    glRectf (-1.0, -1.0, 1.0, 1.0);
-    glFinish();
-#endif
-    
-    state = cm_state_new ();
-    
-    cm_state_disable_depth_buffer_update (state);
-    
-    cm_node_render (CM_NODE (info->magnifier), state);
-    
-    cm_state_enable_depth_buffer_update (state);
-    
-    g_object_unref (state);
-    
-    ws_window_gl_swap_buffers (info->gl_window);
-    glFinish();
-    
-#if 0
-    dump_stacking_order (info->stacker->children);
-#endif
-    
-    info->idle_id = 0;
-    return FALSE;
-}
-
-static WindowInfo *
-find_win_info (MetaScreenInfo *info,
-	       Window	       xwindow)
-{
-    WindowInfo *win_info =
-	g_hash_table_lookup (info->window_infos_by_xid, (gpointer)xwindow);
-    
-    return win_info;
-}
-
-static CmNode *
-find_node (MetaScreenInfo *info,
-	   Window	   xwindow)
-{
-    WindowInfo *win_info = find_win_info (info, xwindow);
-    
-    if (win_info)
-	return win_info->node;
-    
-    return NULL;
-}
-
-static GList *all_screen_infos;
-
-MetaScreenInfo *
-meta_screen_info_get_by_xwindow (Window xwindow)
-{
-    GList *list;
-    
-    for (list = all_screen_infos; list != NULL; list = list->next)
-    {
-	MetaScreenInfo *info = list->data;
-	
-	if (find_node (info, xwindow))
-	    return info;
-    }
-    
-    return NULL;
-}
-
-MetaScreenInfo *
-meta_screen_info_new (WsDisplay *display,
-		      MetaScreen *screen)
-{
-    MetaScreenInfo *scr_info = g_new0 (MetaScreenInfo, 1);
-    
-    scr_info->screen = ws_display_get_screen_from_number (
-	display, screen->number);
-    scr_info->root_window = ws_screen_get_root_window (scr_info->screen);
-    scr_info->display = display;
-    scr_info->window_infos_by_xid =
-	g_hash_table_new_full (g_direct_hash, g_direct_equal,
-			       NULL, g_free);
-    scr_info->meta_screen = screen;
-    
-    all_screen_infos = g_list_prepend (all_screen_infos, scr_info);
-    
-    return scr_info;
-}
-
-static char *
-make_selection_name (MetaScreenInfo *info)
-{
-    char *buffer;
-    
-    buffer = g_strdup_printf ("_NET_WM_CM_S%d", info->meta_screen->number);
-
-    return buffer;
-}
-
-static void
-on_selection_clear (WsWindow *window,
-		    WsSelectionClearEvent *event,
-		    gpointer data)
-{
-    MetaScreenInfo *info = data;
-    char *buffer = make_selection_name (info);
-
-    if (strcmp (event->selection, buffer))
-    {
-	/* We lost the selection */
-	meta_screen_info_unredirect (info);
-    }
-}
-
-static WsWindow *
-claim_selection (MetaScreenInfo *info)
-{
-    WsWindow *window = ws_window_new (info->root_window);
-    char *buffer = make_selection_name (info);
-
-#if 0
-    g_print ("selection window: %lx\n", WS_RESOURCE_XID (window));
-#endif
-    
-    ws_window_own_selection (window, buffer, WS_CURRENT_TIME);
-
-    g_signal_connect (window, "selection_clear_event", G_CALLBACK (on_selection_clear), info);
-
-    g_free (buffer);
-    
-    return window;
-}
-
-static void
-queue_paint (CmNode *node,
-	     MetaScreenInfo *info)
-{
-#if 0
-    g_print ("queueing %s\n", G_OBJECT_TYPE_NAME (node));
-#endif
-    meta_screen_info_queue_paint (info);
-}
-
-void
-meta_screen_info_redirect (MetaScreenInfo *info)
-{
-    WsWindow *root = ws_screen_get_root_window (info->screen);
-    WsRectangle source;
-    WsRectangle target;
-    WsServerRegion *region;
-    int screen_w;
-    int screen_h;
-    CmSquare *square;
-    
-#if 0
-    g_print ("redirecting %lx\n", WS_RESOURCE_XID (root));
-#endif
-    
-    ws_window_redirect_subwindows (root);
-    info->gl_window = ws_screen_get_gl_window (info->screen);
-    /* FIXME: This should probably happen in libcm */
-    ws_window_set_override_redirect (info->gl_window, TRUE);
-    region = ws_server_region_new (info->display);
-    ws_window_set_input_shape (info->gl_window, region);
-    g_object_unref (G_OBJECT (region));
-
-    ws_display_begin_error_trap (info->display);
-    
-    ws_window_unredirect (info->gl_window);
-
-    ws_display_end_error_trap (info->display);
-    
-    info->selection_window = claim_selection (info);
-    
-    ws_window_map (info->gl_window);
-    
-    info->stacker = cm_stacker_new ();
-
-    square = cm_square_new (0.3, 0.3, 0.8, 1.0);
-    
-    cm_stacker_add_child (info->stacker, CM_NODE (square));
-
-    g_object_unref (square);
-
-    screen_w = ws_screen_get_width (info->screen);
-    screen_h = ws_screen_get_height (info->screen);
-
-#if 0
-    g_print ("width: %d height %d\n", screen_w, screen_h);
-#endif
-    
-    source.x = (screen_w - (screen_w / 4)) / 2;
-    source.y = screen_h / 16;
-    source.width = screen_w / 4;
-    source.height = screen_h / 16;
-    
-    target.x = 0;
-    target.y = screen_h - screen_h / 4;
-    target.width = screen_w;
-    target.height = screen_h / 4;
-    
-    info->magnifier = cm_magnifier_new (CM_NODE (info->stacker), &source, &target);
-
-    g_object_unref (info->stacker);
-    
-    if (g_getenv ("USE_MAGNIFIER"))
-	cm_magnifier_set_active (info->magnifier, TRUE);
-    else
-	cm_magnifier_set_active (info->magnifier, FALSE);
-    
-    info->repaint_id =
-	g_signal_connect (info->magnifier, "need_repaint",
-			  G_CALLBACK (queue_paint), info);
-    
-    ws_display_sync (info->display);
-}
-
-void
-meta_screen_info_unredirect (MetaScreenInfo *info)
-{
-    WsScreen *ws_screen = info->screen;
-    WsWindow *root = ws_screen_get_root_window (ws_screen);
-    
-#if 0
-    g_print ("unredirecting %lx\n", WS_RESOURCE_XID (root));
-#endif
-    
-    g_signal_handler_disconnect (info->magnifier, info->repaint_id);
-    g_object_unref (info->magnifier);
-    
-    ws_window_unredirect_subwindows (root);
-#if 0
-    ws_window_unmap (info->gl_window);
-#endif
-    ws_screen_release_gl_window (ws_screen);
-    
-    ws_display_sync (info->display);
-
-    /* FIXME: libcm needs a way to guarantee that a window is destroyed,
-     * without relying on ref counting having it as a side effect
-     */
-    g_object_unref (info->selection_window);
-}
-
-void
-meta_screen_info_queue_paint (MetaScreenInfo *info)
-{
-#if 0
-    g_print ("queuing\n");
-#endif
-    if (!info->idle_id)
-	info->idle_id = g_idle_add (repaint, info);
-}
-
-void
-meta_screen_info_restack (MetaScreenInfo *info,
-			  Window	  window,
-			  Window	  above_this)
-{
-    CmNode *window_node = find_node (info, window);
-    CmNode *above_node  = find_node (info, above_this);
-    
-#if 0
-    g_print ("restack %lx over %lx \n", window, above_this);
-#endif
-    
-#if 0
-    dump_stacking_order (info->stacker->children);
-#endif
-    
-    if (window_node == above_node)
-	return;
-    
-    if (window_node && above_this == WS_RESOURCE_XID (info->gl_window))
-    {
-	cm_stacker_raise_child (info->stacker, window_node);
-    }
-    else if (window_node && above_this == None)
-    {
-	cm_stacker_lower_child (info->stacker, window_node);
-    }
-    else if (window_node && above_node)
-    {
-	cm_stacker_restack_child (info->stacker, window_node, above_node);
-    }
-#if 0
-    else
-	g_print ("nothing happened\n");
-#endif
-    
-#if 0
-    g_print ("done restacking; new order:\n");
-#endif
-#if 0
-    dump_stacking_order (info->stacker->children);
-#endif
-    
-}
-
-void
-meta_screen_info_raise_window (MetaScreenInfo  *info,
-			       Window           window)
-{
-    CmNode *node = find_node (info, window);
-    
-    if (node)
-	cm_stacker_raise_child (info->stacker, node);
-}
-
-void
-meta_screen_info_set_size (MetaScreenInfo *info,
-			   Window	   window,
-			   gint		   x,
-			   gint		   y,
-			   gint		   width,
-			   gint		   height)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, window));
-    WindowInfo *winfo = find_win_info (info, window);
-    WsRectangle rect;
-    
-    rect.x = x;
-    rect.y = y;
-    rect.width = width;
-    rect.height = height;
-    
-    if (node)
-    {
-	WsRegion *shape;
-	
-	if (winfo && winfo->updates)
-	{
-	    WsWindow *window = WS_WINDOW (node->drawable);
-	    WsDisplay *display = WS_RESOURCE (window)->display;
-
-	    ws_display_begin_error_trap (display);
-
-#if 0
-	    g_print ("meta screen info set: %d %d %d %d\n",
-		     x, y, width, height);
-#endif
-	    
-	    cm_drawable_node_set_geometry (CM_DRAWABLE_NODE (node), &rect);
-	    shape = ws_window_get_output_shape (window);
-	    cm_drawable_node_set_shape (node, shape);
-	    ws_region_destroy (shape);
-
-	    if (rect.width != winfo->size.width ||
-		rect.height != winfo->size.height)
-	    {
-		cm_drawable_node_update_pixmap (node);
-	    }
-
-	    winfo->size = rect;
-
-	    ws_display_end_error_trap (display);
-	}
-    }
-}
-
-static void
-print_child_titles (WsWindow *window)
-{
-    GList *children = ws_window_query_subwindows (window);
-    GList *list;
-    int i;
-    
-    g_print ("window: %lx %s\n", WS_RESOURCE_XID (window), ws_window_query_title (window));
-    
-    i = 0;
-    for (list = children; list != NULL; list = list->next)
-    {
-	WsWindow *child = list->data;
-	
-	g_print ("  %d adding: %lx %s\n", i++, WS_RESOURCE_XID (child), ws_window_query_title (child));
-    }
-}
-
-static WindowInfo *
-window_info_new (Window xwindow,
-		 CmNode *node)
-{
-    WindowInfo *win_info = g_new0 (WindowInfo, 1);
-    win_info->xwindow = xwindow;
-    win_info->node = node;
-    win_info->updates = TRUE;
-    return win_info;
-}
-
-static gboolean
-has_type (WsWindow *window, const char *check_type)
-{
-    gchar **types = ws_window_get_property_atom_list (window, "_NET_WM_WINDOW_TYPE");
-    int i;
-    gboolean result;
-
-    if (!types)
-	return FALSE;
-
-    result = FALSE;
-    
-    for (i = 0; types[i] != NULL; ++i)
-    {
-	gchar *type = types[i];
-
-	g_print ("type: %s\n", type);
-	
-	if (strcmp (type, check_type) == 0)
-	{
-	    result = TRUE;
-	    break;
-	}
-    }
-
-    g_strfreev (types);
-    return result;
-}
-
-void
-meta_screen_info_add_window (MetaScreenInfo *info,
-			     Window	     xwindow)
-{
-    CmNode *node;
-    WsDrawable *drawable;
-    WsRectangle geometry;
-    double alpha = 1.0;
-    
-    ws_display_begin_error_trap (info->display);
-    
-    node = find_node (info, xwindow);
-#if 0
-    g_print ("lookup %lx\n", xwindow);
-#endif
-    drawable = WS_DRAWABLE (ws_window_lookup (info->display, xwindow));
-
-    if (node)
-	goto out;
-    
-    if (ws_window_query_input_only (WS_WINDOW (drawable)))
-	goto out;
-
-    if (WS_WINDOW (drawable) == info->gl_window ||
-	WS_WINDOW (drawable) == info->screen->overlay_window)
-    {
-#if 0
-	g_print ("gl window\n");
-#endif
-	goto out;
-    }
-    
-    ws_drawable_query_geometry (drawable, &geometry);
-    
-    node = CM_NODE (cm_drawable_node_new (drawable, &geometry));
-
-#if 0
-    g_print ("alpha: %f\n", alpha);
-#endif
-    cm_drawable_node_set_alpha (node, alpha);
-    
-#if 0
-    print_child_titles (WS_WINDOW (drawable));
-#endif
-    
-    cm_stacker_add_child (info->stacker, node);
-
-    g_hash_table_insert (info->window_infos_by_xid,
-			 (gpointer)xwindow,
-			 window_info_new (xwindow, node));
-    
-    g_object_unref (node);    
-out:
-    if (node)
-    {
-#if 0
-	g_print ("drawable %lx is now ", WS_RESOURCE_XID (drawable));
-#endif
-	if (ws_window_query_mapped (WS_WINDOW (drawable)))
-	{
-#if 0
-	    g_print ("mapped\n");
-#endif
-	    cm_drawable_node_unset_patch (node);
-#if 0
-	    g_print ("set alpha %f\n", alpha);
-#endif
-	    
-	    if (has_type (drawable, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"))
-	    {
-#if 0
-		g_print ("is menu\n");
-#endif
-		alpha = 0.9;
-	    }
-	    else if (has_type (drawable, "_NET_WM_WINDOW_TYPE_POPUP_MENU"))
-	    {
-		alpha = 0.9;
-	    }
-	    else
-	    {
-#if 0
-		g_print ("is not menu\n");
-#endif
-		alpha = 1.0;
-	    }
-	    cm_drawable_node_set_alpha (node, alpha);
-	    cm_drawable_node_set_viewable (node, TRUE);
-	    cm_drawable_node_update_pixmap (node);
-	}
-	else
-	{
-#if 0
-	    g_print ("unmapped\n");
-#endif
-	    cm_drawable_node_set_viewable (node, FALSE);
-	}
-    }
-    
-    ws_display_end_error_trap (info->display);
-    
-#if 0
-    g_print ("done checking\n");
-#endif
-    
-    return;
-}
-
-
-void
-meta_screen_info_remove_window (MetaScreenInfo *info,
-				Window	        xwindow)
-{
-    CmNode *node = find_node (info, xwindow);
-    
-#if 0
-    g_print ("removing %lx\n", xwindow);
-#endif
-
-    if (node)
-    {
-	g_hash_table_remove (info->window_infos_by_xid, (gpointer)xwindow);
-	
-	cm_stacker_remove_child (info->stacker, node);
-    }
-}
-
-void
-meta_screen_info_set_updates (MetaScreenInfo *info,
-			      Window	      xwindow,
-			      gboolean	      updates)
-{
-    WindowInfo *win_info = find_win_info (info, xwindow);
-    CmDrawableNode *node = CM_DRAWABLE_NODE (win_info->node);
-
-#if 0
-    g_print ("setting updates to %s\n", updates? "on" : "off");
-#endif
-    
-    win_info->updates = updates;
-    
-    if (node)
-	cm_drawable_node_set_updates (node, updates);
-    
-    if (updates)
-    {
-	WsRectangle rect;
-	WsRegion *shape;
-	WsDisplay *display = WS_RESOURCE (node->drawable)->display;
-	
-	ws_display_begin_error_trap (display);
-	ws_drawable_query_geometry (node->drawable, &rect);
-	cm_drawable_node_update_pixmap (node);
-	cm_drawable_node_set_geometry (node, &rect);
-	shape = ws_window_get_output_shape (WS_WINDOW (node->drawable));
-	cm_drawable_node_set_shape (node, shape);
-	ws_region_destroy (shape);
-	ws_display_end_error_trap (display);
-    }
-}
-
-
-void
-meta_screen_info_set_patch (MetaScreenInfo *info,
-			    Window	    xwindow,
-			    CmPoint         points[4][4])
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-    
-    if (node)
-	cm_drawable_node_set_patch (node, points);
-}
-
-void
-meta_screen_info_unset_patch (MetaScreenInfo *info,
-			      Window	      xwindow)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-    
-    if (node)
-	cm_drawable_node_unset_patch (node);
-}
-
-void
-meta_screen_info_set_alpha (MetaScreenInfo *info,
-			    Window	xwindow,
-			    gdouble alpha)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-#if 0
-    g_print ("alpha: %f\n", alpha);
-#endif
-    cm_drawable_node_set_alpha (node, alpha);
-}
-
-void
-meta_screen_info_get_real_size (MetaScreenInfo *info,
-				Window xwindow,
-				WsRectangle *size)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-    
-    if (!size)
-	return;
-    
-    cm_drawable_node_get_clipbox (node, size);
-}
-
-void
-meta_screen_info_unmap (MetaScreenInfo *info,
-			Window		xwindow)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-    
-#if 0
-    g_print ("unmapping: %lx\n", xwindow);
-#endif
-    
-    if (node)
-	cm_drawable_node_set_viewable (node, FALSE);
-}
-
-void
-meta_screen_info_set_target_rect (MetaScreenInfo *info,
-				  Window xwindow,
-				  WsRectangle *rect)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-
-    if (node)
-	cm_drawable_node_set_scale_rect (node, rect);
-}
-
-void
-meta_screen_info_set_explode (MetaScreenInfo *info,
-			      Window xwindow,
-			      gdouble level)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-
-    if (node)
-    {
-#if 0
-	g_print ("level: %f\n", level);
-#endif
-    
-	cm_drawable_node_set_explosion_level (node, level);
-    }
-}
-
-void
-meta_screen_info_hide_window (MetaScreenInfo *info,
-			      Window          xwindow)
-{
-    CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, xwindow));
-
-    cm_drawable_node_set_viewable (node, FALSE);
-}
-
-#endif
-

src/c-screen.h

@@ -1,49 +0,0 @@
-#include "screen.h"
-
-typedef struct MetaScreenInfo MetaScreenInfo;
-
-MetaScreenInfo *meta_screen_info_new     (WsDisplay	 *display,
-					  MetaScreen     *screen);
-MetaScreenInfo *meta_screen_info_get_by_xwindow (Window xwindow);
-void            meta_screen_info_destroy (MetaScreenInfo *scr_info);
-void		meta_screen_info_redirect (MetaScreenInfo *info);
-void		meta_screen_info_unredirect (MetaScreenInfo *info);
-void		meta_screen_info_add_window (MetaScreenInfo *scr_info,
-					     Window          xwindow);
-void		meta_screen_info_remove_window (MetaScreenInfo *scr_info,
-						Window	     xwindow);
-void		meta_screen_info_restack	(MetaScreenInfo *scr_info,
-						 Window		 window,
-						 Window		 above_this);
-void	        meta_screen_info_set_size       (MetaScreenInfo *info,
-						 Window	         window,
-						 gint		 x,
-						 gint		 y,
-						 gint		 width,
-						 gint		 height);
-void            meta_screen_info_raise_window (MetaScreenInfo  *scr_info,
-					       Window           window);
-void		meta_screen_info_queue_paint (MetaScreenInfo *info);
-void		meta_screen_info_set_updates (MetaScreenInfo *info,
-					      Window	      xwindow,
-					      gboolean        updates);
-void		meta_screen_info_set_patch (MetaScreenInfo *info,
-					    Window	    xwindow,
-					    CmPoint         points[4][4]);
-void		meta_screen_info_unset_patch (MetaScreenInfo *info,
-					      Window	      xwindow);
-void            meta_screen_info_set_alpha (MetaScreenInfo *info,
-				       Window	xwindow,
-				       gdouble alpha);
-void		meta_screen_info_get_real_size (MetaScreenInfo *info,
-						Window xwindow,
-						WsRectangle *size);
-void		meta_screen_info_set_target_rect (MetaScreenInfo *info,
-						  Window xwindow,
-						  WsRectangle *rect);
-
-void		meta_screen_info_set_explode (MetaScreenInfo *info,
-					      Window xwindow,
-					      gdouble level);
-void		meta_screen_info_hide_window (MetaScreenInfo *info,
-					      Window          xwindow);

src/core/async-getprop.c

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

src/core/async-getprop.h

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

src/core/bell.c

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity visual bell */
 
 /* 
@@ -20,11 +22,57 @@
  * 02111-1307, USA.
  */
 
+/**
+ * \file core/bell.c Ring the bell or flash the screen
+ *
+ * Sometimes, X programs "ring the bell", whatever that means. Metacity lets
+ * the user configure the bell to be audible or visible (aka visual), and
+ * if it's visual it can be configured to be frame-flash or fullscreen-flash.
+ * We never get told about audible bells; X handles them just fine by itself.
+ *
+ * Visual bells come in at meta_bell_notify(), which checks we are actually
+ * in visual mode and calls through to meta_bell_visual_notify(). That
+ * function then checks what kind of visual flash you like, and calls either
+ * meta_bell_flash_fullscreen()-- which calls meta_bell_flash_screen() to do
+ * its work-- or meta_bell_flash_frame(), which flashes the focussed window
+ * using meta_bell_flash_window_frame(), unless there is no such window, in
+ * which case it flashes the screen instead. meta_bell_flash_window_frame()
+ * flashes the frame and calls meta_bell_unflash_frame() as a timeout to
+ * remove the flash.
+ *
+ * The visual bell was the result of a discussion in Bugzilla here:
+ * <http://bugzilla.gnome.org/show_bug.cgi?id=99886>.
+ *
+ * Several of the functions in this file are ifdeffed out entirely if we are
+ * found not to have the XKB extension, which is required to do these clever
+ * things with bells; some others are entirely no-ops in that case.
+ *
+ * \bug Static functions should not be called meta_*.
+ */
+
 #include <config.h>
 #include "bell.h"
 #include "screen.h"
 #include "prefs.h"
 
+/**
+ * Flashes one entire screen.  This is done by making a window the size of the
+ * whole screen (or reusing the old one, if it's still around), mapping it,
+ * painting it white and then black, and then unmapping it. We set saveunder so
+ * that all the windows behind it come back immediately.
+ *
+ * Unlike frame flashes, we don't do fullscreen flashes with a timeout; rather,
+ * we do them in one go, because we don't have to rely on the theme code
+ * redrawing the frame for us in order to do the flash.
+ *
+ * \param display  The display which owns the screen (rather redundant)
+ * \param screen   The screen to flash
+ *
+ * \bug The way I read it, this appears not to do the flash
+ * the first time we flash a particular display. Am I wrong?
+ *
+ * \bug This appears to destroy our current XSync status.
+ */
 static void
 meta_bell_flash_screen (MetaDisplay *display, 
 			MetaScreen  *screen)
@@ -87,6 +135,16 @@ meta_bell_flash_screen (MetaDisplay *display,
   XFlush (display->xdisplay);
 }
 
+/**
+ * Flashes one screen, or all screens, in response to a bell event.
+ * If the event is on a particular window, flash the screen that
+ * window is on. Otherwise, flash every screen on this display.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the event came in on
+ * \param xkb_ev   The bell event
+ */
 #ifdef HAVE_XKB
 static void
 meta_bell_flash_fullscreen (MetaDisplay *display, 
@@ -114,6 +172,20 @@ meta_bell_flash_fullscreen (MetaDisplay *display,
     }
 }
 
+/**
+ * Makes a frame be not flashed; this is the timeout half of
+ * meta_bell_flash_window_frame(). This is done simply by clearing the
+ * flash flag and queuing a redraw of the frame.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param data  The frame to unflash, cast to a gpointer so it can go into
+ *              a callback function.
+ * \return Always FALSE, so we don't get called again.
+ *
+ * \bug This is the parallel to meta_bell_flash_window_frame(), so it should
+ * really be called meta_bell_unflash_window_frame().
+ */
 static gboolean 
 meta_bell_unflash_frame (gpointer data)
 {
@@ -123,6 +195,17 @@ meta_bell_unflash_frame (gpointer data)
   return FALSE;
 }
 
+/**
+ * Makes a frame flash and then return to normal shortly afterwards.
+ * This is done by setting a flag so that the theme
+ * code will temporarily draw the frame as focussed if it's unfocussed and
+ * vice versa, and then queueing a redraw. Lastly, we create a timeout so
+ * that the flag can be unset and the frame re-redrawn.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param window  The window to flash
+ */
 static void
 meta_bell_flash_window_frame (MetaWindow *window)
 {
@@ -133,6 +216,13 @@ meta_bell_flash_window_frame (MetaWindow *window)
       meta_bell_unflash_frame, window->frame, NULL);
 }
 
+/**
+ * Flashes the frame of the focussed window. If there is no focussed window,
+ * flashes the screen.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
 static void
 meta_bell_flash_frame (MetaDisplay *display, 
 		       XkbAnyEvent *xkb_ev)
@@ -156,6 +246,17 @@ meta_bell_flash_frame (MetaDisplay *display,
     }
 }
 
+/**
+ * Gives the user some kind of visual bell substitute, in response to a
+ * bell event. What this is depends on the "visual bell type" pref.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ *
+ * \bug This should be merged with meta_bell_notify().
+ */
 static void
 meta_bell_visual_notify (MetaDisplay *display, 
 			 XkbAnyEvent *xkb_ev)
@@ -174,6 +275,16 @@ meta_bell_visual_notify (MetaDisplay *display,
     }
 }
 
+/**
+ * Gives the user some kind of visual bell; in fact, this is our response
+ * to any kind of bell request, but we set it up so that we only get
+ * notified about visual bells, and X deals with audible ones.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
 void
 meta_bell_notify (MetaDisplay *display, 
 		  XkbAnyEvent *xkb_ev)
@@ -182,8 +293,17 @@ meta_bell_notify (MetaDisplay *display,
   if (meta_prefs_get_visual_bell ()) 
     meta_bell_visual_notify (display, xkb_ev);
 }
-#endif
+#endif /* HAVE_XKB */
 
+/**
+ * Turns the bell to audible or visual. This tells X what to do, but
+ * not Metacity; you will need to set the "visual bell" pref for that.
+ *
+ * If the configure script found we had no XKB, this is a no-op.
+ *
+ * \param display  The display we're configuring
+ * \param audible  True for an audible bell, false for a visual bell
+ */
 void
 meta_bell_set_audible (MetaDisplay *display, gboolean audible)
 {
@@ -195,6 +315,27 @@ meta_bell_set_audible (MetaDisplay *display, gboolean audible)
 #endif  
 }
 
+/**
+ * Initialises the bell subsystem. This involves intialising
+ * XKB (which, despite being a keyboard extension, is the
+ * place to look for bell notifications), then asking it
+ * to send us bell notifications, and then also switching
+ * off the audible bell if we're using a visual one ourselves.
+ *
+ * Unlike most X extensions we use, we only initialise XKB here
+ * (rather than in main()). It's possible that XKB is not
+ * installed at all, but if that was known at build time
+ * we will have HAVE_XKB undefined, which will cause this
+ * function to be a no-op.
+ *
+ * \param display  The display which is opening
+ *
+ * \bug There is a line of code that's never run that tells
+ * XKB to reset the bell status after we quit. Bill H said
+ * (<http://bugzilla.gnome.org/show_bug.cgi?id=99886#c12>)
+ * that XFree86's implementation is broken so we shouldn't
+ * call it, but that was in 2002. Is it working now?
+ */
 gboolean
 meta_bell_init (MetaDisplay *display)
 {
@@ -236,6 +377,15 @@ meta_bell_init (MetaDisplay *display)
   return FALSE;
 }
 
+/**
+ * Shuts down the bell subsystem.
+ *
+ * \param display  The display which is closing
+ *
+ * \bug This is never called! If we had XkbSetAutoResetControls
+ * enabled in meta_bell_init(), this wouldn't be a problem, but
+ * we don't.
+ */
 void
 meta_bell_shutdown (MetaDisplay *display)
 {
@@ -248,6 +398,14 @@ meta_bell_shutdown (MetaDisplay *display)
 #endif
 }
 
+/**
+ * Deals with a frame being destroyed. This is important because if we're
+ * using a visual bell, we might be flashing the edges of the frame, and
+ * so we'd have a timeout function waiting ready to un-flash them. If the
+ * frame's going away, we can tell the timeout not to bother.
+ *
+ * \param frame  The frame which is being destroyed
+ */
 void
 meta_bell_notify_frame_destroy (MetaFrame *frame)
 {

src/core/bell.h

@@ -1,5 +1,6 @@
 /* Metacity visual bell */
 
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /* 
  * Copyright (C) 2002 Sun Microsystems Inc.
  * 

src/core/boxes.c

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Simple box operations */
 
 /* 
@@ -27,7 +29,6 @@
 #include "boxes.h"
 #include "util.h"
 #include <X11/Xutil.h>  /* Just for the definition of the various gravities */
-#include <stdio.h>      /* For snprintf */
 
 char*
 meta_rectangle_to_string (const MetaRectangle *rect,
@@ -59,7 +60,7 @@ meta_rectangle_region_to_string (GList      *region,
   char *cur = output;
 
   if (region == NULL)
-    snprintf (output, 10, "(EMPTY)");
+    g_snprintf (output, 10, "(EMPTY)");
 
   while (tmp)
     {
@@ -112,7 +113,7 @@ meta_rectangle_edge_list_to_string (GList      *edge_list,
   GList *tmp = edge_list;
 
   if (edge_list == NULL)
-    snprintf (output, 10, "(EMPTY)");
+    g_snprintf (output, 10, "(EMPTY)");
 
   while (tmp)
     {
@@ -545,10 +546,10 @@ meta_rectangle_get_minimal_spanning_set_for_region (
   ret = g_list_prepend (NULL, temp_rect);
 
   strut_iter = all_struts;
-  while (strut_iter)
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
     {
       GList *rect_iter; 
-      MetaRectangle *strut = (MetaRectangle*) strut_iter->data;
+      MetaRectangle *strut_rect = &((MetaStrut*)strut_iter->data)->rect;
 
       tmp_list = ret;
       ret = NULL;
@@ -556,45 +557,45 @@ meta_rectangle_get_minimal_spanning_set_for_region (
       while (rect_iter)
         {
           MetaRectangle *rect = (MetaRectangle*) rect_iter->data;
-          if (!meta_rectangle_overlap (rect, strut))
+          if (!meta_rectangle_overlap (rect, strut_rect))
             ret = g_list_prepend (ret, rect);
           else
             {
               /* If there is area in rect left of strut */
-              if (rect->x < strut->x)
+              if (BOX_LEFT (*rect) < BOX_LEFT (*strut_rect))
                 {
                   temp_rect = g_new (MetaRectangle, 1);
                   *temp_rect = *rect;
-                  temp_rect->width = strut->x - rect->x;
+                  temp_rect->width = BOX_LEFT (*strut_rect) - BOX_LEFT (*rect);
                   ret = g_list_prepend (ret, temp_rect);
                 }
               /* If there is area in rect right of strut */
-              if (rect->x + rect->width > strut->x + strut->width)
+              if (BOX_RIGHT (*rect) > BOX_RIGHT (*strut_rect))
                 {
                   int new_x;
                   temp_rect = g_new (MetaRectangle, 1);
                   *temp_rect = *rect;
-                  new_x = strut->x + strut->width;
-                  temp_rect->width = rect->x + rect->width - new_x;
+                  new_x = BOX_RIGHT (*strut_rect);
+                  temp_rect->width = BOX_RIGHT(*rect) - new_x;
                   temp_rect->x = new_x;
                   ret = g_list_prepend (ret, temp_rect);
                 }
               /* If there is area in rect above strut */
-              if (rect->y < strut->y)
+              if (BOX_TOP (*rect) < BOX_TOP (*strut_rect))
                 {
                   temp_rect = g_new (MetaRectangle, 1);
                   *temp_rect = *rect;
-                  temp_rect->height = strut->y - rect->y;
+                  temp_rect->height = BOX_TOP (*strut_rect) - BOX_TOP (*rect);
                   ret = g_list_prepend (ret, temp_rect);
                 }
               /* If there is area in rect below strut */
-              if (rect->y + rect->height > strut->y + strut->height)
+              if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*strut_rect))
                 {
                   int new_y;
                   temp_rect = g_new (MetaRectangle, 1);
                   *temp_rect = *rect;
-                  new_y = strut->y + strut->height;
-                  temp_rect->height = rect->y + rect->height - new_y;
+                  new_y = BOX_BOTTOM (*strut_rect);
+                  temp_rect->height = BOX_BOTTOM (*rect) - new_y;
                   temp_rect->y = new_y;
                   ret = g_list_prepend (ret, temp_rect);
                 }
@@ -603,7 +604,6 @@ meta_rectangle_get_minimal_spanning_set_for_region (
           rect_iter = rect_iter->next;
         }
       g_list_free (tmp_list);
-      strut_iter = strut_iter->next;
     }
 
   /* Sort by maximal area, just because I feel like it... */
@@ -660,6 +660,76 @@ meta_rectangle_expand_region_conditionally (GList     *region,
   return region;
 }
 
+void
+meta_rectangle_expand_to_avoiding_struts (MetaRectangle       *rect,
+                                          const MetaRectangle *expand_to,
+                                          const MetaDirection  direction,
+                                          const GSList        *all_struts)
+{
+  const GSList *strut_iter;
+
+  /* If someone wants this function to handle more fine-grained
+   * direction expanding in the future (e.g. only left, or fully
+   * horizontal plus upward), feel free.  But I'm hard-coding for both
+   * horizontal directions (exclusive-)or both vertical directions.
+   */
+  g_assert ((direction == META_DIRECTION_HORIZONTAL) ^
+            (direction == META_DIRECTION_VERTICAL  ));
+ 
+  if (direction == META_DIRECTION_HORIZONTAL)
+    {
+      rect->x      = expand_to->x;
+      rect->width  = expand_to->width;
+    }
+  else
+    {
+      rect->y      = expand_to->y;
+      rect->height = expand_to->height;
+    }
+
+ 
+  /* Run over all struts */
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      MetaStrut *strut = (MetaStrut*) strut_iter->data;
+ 
+      /* Skip struts that don't overlap */
+      if (!meta_rectangle_overlap (&strut->rect, rect))
+        continue;
+
+      if (direction == META_DIRECTION_HORIZONTAL)
+        {
+          if (strut->side == META_SIDE_LEFT)
+            {
+              int offset = BOX_RIGHT(strut->rect) - BOX_LEFT(*rect);
+              rect->x     += offset;
+              rect->width -= offset;
+            }
+          else if (strut->side == META_SIDE_RIGHT)
+            {
+              int offset = BOX_RIGHT (*rect) - BOX_LEFT(strut->rect);
+              rect->width -= offset;
+            }
+          /* else ignore the strut */
+        }
+      else /* direction == META_DIRECTION_VERTICAL */
+        {
+          if (strut->side == META_SIDE_TOP)
+            {
+              int offset = BOX_BOTTOM(strut->rect) - BOX_TOP(*rect);
+              rect->y      += offset;
+              rect->height -= offset;
+            }
+          else if (strut->side == META_SIDE_BOTTOM)
+            {
+              int offset = BOX_BOTTOM(*rect) - BOX_TOP(strut->rect);
+              rect->height -= offset;
+            }
+          /* else ignore the strut */
+        }
+    } /* end loop over struts */
+} /* end meta_rectangle_expand_to_avoiding_struts */
+
 void
 meta_rectangle_free_list_and_elements (GList *filled_list)
 {
@@ -705,6 +775,25 @@ meta_rectangle_contained_in_region (const GList         *spanning_rects,
   return contained;
 }
 
+gboolean
+meta_rectangle_overlaps_with_region (const GList         *spanning_rects,
+                                     const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     overlaps;
+
+  temp = spanning_rects;
+  overlaps = FALSE;
+  while (!overlaps && temp != NULL)
+    {
+      overlaps = overlaps || meta_rectangle_overlap (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return overlaps;
+}
+
+
 void
 meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
                                          FixedDirections      fixed_directions,
@@ -718,39 +807,36 @@ meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
   /* First, find best rectangle from spanning_rects to which we can clamp
    * rect to fit into.
    */
-  temp = spanning_rects;
-  while (temp)
+  for (temp = spanning_rects; temp; temp = temp->next)
     {
-      int factor = 1;
       MetaRectangle *compare_rect = temp->data;
       int            maximal_overlap_amount_for_compare;
       
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_X) &&
           (compare_rect->x > rect->x || 
            compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
         
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_Y) &&
           (compare_rect->y > rect->y || 
            compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;
 
-      /* If compare can't hold the min_size window, set factor to 0 */
+      /* If compare can't hold the min_size window, skip this rectangle. */
       if (compare_rect->width  < min_size->width ||
           compare_rect->height < min_size->height)
-        factor = 0;
+        continue;
 
       /* Determine maximal overlap amount */
       maximal_overlap_amount_for_compare =
         MIN (rect->width,  compare_rect->width) *
         MIN (rect->height, compare_rect->height);
-      maximal_overlap_amount_for_compare *= factor;
 
       /* See if this is the best rect so far */
       if (maximal_overlap_amount_for_compare > best_overlap)
@@ -758,8 +844,6 @@ meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
           best_rect    = compare_rect;
           best_overlap = maximal_overlap_amount_for_compare;
         }
-
-      temp = temp->next;
     }
 
   /* Clamp rect appropriately */
@@ -792,34 +876,31 @@ meta_rectangle_clip_to_region (const GList         *spanning_rects,
   /* First, find best rectangle from spanning_rects to which we will clip
    * rect into.
    */
-  temp = spanning_rects;
-  while (temp)
+  for (temp = spanning_rects; temp; temp = temp->next)
     {
-      int factor = 1;
       MetaRectangle *compare_rect = temp->data;
       MetaRectangle  overlap;
       int            maximal_overlap_amount_for_compare;
-      
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+     
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip the rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_X) &&
           (compare_rect->x > rect->x || 
            compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
         
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip the rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_Y) &&
           (compare_rect->y > rect->y || 
            compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;
 
       /* Determine maximal overlap amount */
       meta_rectangle_intersect (rect, compare_rect, &overlap);
       maximal_overlap_amount_for_compare = meta_rectangle_area (&overlap);
-      maximal_overlap_amount_for_compare *= factor;
 
       /* See if this is the best rect so far */
       if (maximal_overlap_amount_for_compare > best_overlap)
@@ -827,8 +908,6 @@ meta_rectangle_clip_to_region (const GList         *spanning_rects,
           best_rect    = compare_rect;
           best_overlap = maximal_overlap_amount_for_compare;
         }
-
-      temp = temp->next;
     }
 
   /* Clip rect appropriately */
@@ -875,36 +954,35 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
   /* First, find best rectangle from spanning_rects to which we will shove
    * rect into.
    */
-  temp = spanning_rects;
-  while (temp)
+  
+  for (temp = spanning_rects; temp; temp = temp->next)
     {
-      int factor = 1;
       MetaRectangle *compare_rect = temp->data;
       int            maximal_overlap_amount_for_compare;
       int            dist_to_compare;
       
-      /* If x is fixed and the entire width of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_X) &&
           (compare_rect->x > rect->x || 
            compare_rect->x + compare_rect->width < rect->x + rect->width))
-        factor = 0;
+        continue;
         
-      /* If y is fixed and the entire height of rect doesn't fit in compare, set
-       * factor to 0.
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
        */
       if ((fixed_directions & FIXED_DIRECTION_Y) &&
           (compare_rect->y > rect->y || 
            compare_rect->y + compare_rect->height < rect->y + rect->height))
-        factor = 0;
+        continue;
 
       /* Determine maximal overlap amount between rect & compare_rect */
       maximal_overlap_amount_for_compare =
         MIN (rect->width,  compare_rect->width) *
         MIN (rect->height, compare_rect->height);
 
-      /* Determine distance necessary to put rect into comapre_rect */
+      /* Determine distance necessary to put rect into compare_rect */
       dist_to_compare = 0;
       if (compare_rect->x > rect->x)
         dist_to_compare += compare_rect->x - rect->x;
@@ -917,13 +995,6 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
         dist_to_compare += (rect->y + rect->height) -
                            (compare_rect->y + compare_rect->height);
 
-      /* If we'd have to move in the wrong direction, disqualify compare_rect */
-      if (factor == 0)
-        {
-          maximal_overlap_amount_for_compare = 0;
-          dist_to_compare = G_MAXINT;
-        }
-
       /* See if this is the best rect so far */
       if ((maximal_overlap_amount_for_compare > best_overlap) ||
           (maximal_overlap_amount_for_compare == best_overlap &&
@@ -933,8 +1004,6 @@ meta_rectangle_shove_into_region (const GList         *spanning_rects,
           best_overlap      = maximal_overlap_amount_for_compare;
           shortest_distance = dist_to_compare;
         }
-
-      temp = temp->next;
     }
 
   /* Shove rect appropriately */
@@ -1054,9 +1123,9 @@ meta_rectangle_edge_aligns (const MetaRectangle *rect, const MetaEdge *edge)
     case META_DIRECTION_BOTTOM:
       return BOX_LEFT (*rect)      <= BOX_RIGHT (edge->rect) &&
              BOX_LEFT (edge->rect) <= BOX_RIGHT (*rect);
+    default:
+      g_assert_not_reached ();
     }
-
-  g_assert_not_reached ();
 }
 
 static GList*
@@ -1140,27 +1209,27 @@ replace_rect_with_list (GList *old_element,
 }
 
 /* Make a copy of the strut list, make sure that copy only contains parts
- * of the old_struts that intersect with the rection rect, and then do some
+ * of the old_struts that intersect with the region rect, and then do some
  * magic to make all the new struts disjoint (okay, we we break up struts
  * that aren't disjoint in a way that the overlapping part is only included
  * once, so it's not really magic...).
  */
 static GList*
-get_disjoint_strut_list_in_region (const GSList        *old_struts,
-                                   const MetaRectangle *region)
+get_disjoint_strut_rect_list_in_region (const GSList        *old_struts,
+                                        const MetaRectangle *region)
 {
-  GList *struts;
+  GList *strut_rects;
   GList *tmp;
 
   /* First, copy the list */
-  struts = NULL;
+  strut_rects = NULL;
   while (old_struts)
     {
-      MetaRectangle *cur = old_struts->data;
+      MetaRectangle *cur = &((MetaStrut*)old_struts->data)->rect;
       MetaRectangle *copy = g_new (MetaRectangle, 1);
       *copy = *cur;
       if (meta_rectangle_intersect (copy, region, copy))
-        struts = g_list_prepend (struts, copy);
+        strut_rects = g_list_prepend (strut_rects, copy);
       else
         g_free (copy);
 
@@ -1170,7 +1239,7 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
   /* Now, loop over the list and check for intersections, fixing things up
    * where they do intersect.
    */
-  tmp = struts;
+  tmp = strut_rects;
   while (tmp)
     {
       GList *compare;
@@ -1197,10 +1266,10 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
               cur_leftover = g_list_prepend (cur_leftover, overlap_allocated);
 
               /* Fix up tmp, compare, and cur -- maybe struts too */
-              if (struts == tmp)
+              if (strut_rects == tmp)
                 {
-                  struts = replace_rect_with_list (tmp, cur_leftover);
-                  tmp = struts;
+                  strut_rects = replace_rect_with_list (tmp, cur_leftover);
+                  tmp = strut_rects;
                 }
               else
                 tmp   = replace_rect_with_list (tmp,     cur_leftover);
@@ -1218,7 +1287,7 @@ get_disjoint_strut_list_in_region (const GSList        *old_struts,
       tmp = tmp->next;
     }
 
-  return struts;
+  return strut_rects;
 }
 
 gint
@@ -1326,7 +1395,7 @@ rectangle_and_edge_intersection (const MetaRectangle *rect,
   /* Find out if the intersection is empty; have to do it this way since
    * edges have a thickness of 0
    */
-  if ((result->width < 0 || result->height < 0) ||
+  if ((result->width <  0 || result->height <  0) ||
       (result->width == 0 && result->height == 0))
     {
       result->width = 0;
@@ -1376,6 +1445,8 @@ rectangle_and_edge_intersection (const MetaRectangle *rect,
           else
             *handle_type = 0;
           break;
+        default:
+          g_assert_not_reached ();
         }
     }
   return intersect;
@@ -1482,23 +1553,25 @@ split_edge (GList *cur_list,
           cur_list = g_list_prepend (cur_list, temp_edge);
         }
       break;
+    default:
+      g_assert_not_reached ();
     }
 
   return cur_list;
 }
 
 /* Split up edge and remove preliminary edges from strut_edges depending on
- * if and how strut and edge intersect.
+ * if and how rect and edge intersect.
  */
 static void
-fix_up_edges (MetaRectangle *strut,        MetaEdge *edge, 
+fix_up_edges (MetaRectangle *rect,         MetaEdge *edge, 
               GList         **strut_edges, GList    **edge_splits,
               gboolean      *edge_needs_removal)
 {
   MetaEdge overlap;
   int      handle_type;
 
-  if (!rectangle_and_edge_intersection (strut, edge, &overlap, &handle_type))
+  if (!rectangle_and_edge_intersection (rect, edge, &overlap, &handle_type))
     return;
 
   if (handle_type == 0 || handle_type == 1)
@@ -1607,9 +1680,9 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
                                     const GSList        *all_struts)
 {
   GList        *ret;
-  GList        *fixed_struts;
+  GList        *fixed_strut_rects;
   GList        *edge_iter; 
-  const GList  *strut_iter;
+  const GList  *strut_rect_iter;
 
   /* The algorithm is basically as follows:
    *   Make sure the struts are disjoint
@@ -1627,18 +1700,19 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
    */
 
   /* Make sure the struts are disjoint */
-  fixed_struts = get_disjoint_strut_list_in_region (all_struts, basic_rect);
+  fixed_strut_rects =
+    get_disjoint_strut_rect_list_in_region (all_struts, basic_rect);
 
   /* Start off the list with the edges of basic_rect */
   ret = add_edges (NULL, basic_rect, TRUE);
 
-  strut_iter = fixed_struts;
-  while (strut_iter)
+  strut_rect_iter = fixed_strut_rects;
+  while (strut_rect_iter)
     {
-      MetaRectangle *strut = (MetaRectangle*) strut_iter->data;
+      MetaRectangle *strut_rect = (MetaRectangle*) strut_rect_iter->data;
 
       /* Get the new possible edges we may need to add from the strut */
-      GList *new_strut_edges = add_edges (NULL, strut, FALSE);
+      GList *new_strut_edges = add_edges (NULL, strut_rect, FALSE);
 
       edge_iter = ret;
       while (edge_iter)
@@ -1647,7 +1721,7 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
           GList *splits_of_cur_edge = NULL;
           gboolean edge_needs_removal = FALSE;
 
-          fix_up_edges (strut,            cur_edge, 
+          fix_up_edges (strut_rect,       cur_edge, 
                         &new_strut_edges, &splits_of_cur_edge,
                         &edge_needs_removal);
 
@@ -1671,14 +1745,14 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
         }
 
       ret = g_list_concat (new_strut_edges, ret);
-      strut_iter = strut_iter->next;
+      strut_rect_iter = strut_rect_iter->next;
     }
 
   /* Sort the list */
   ret = g_list_sort (ret, meta_rectangle_edge_cmp);
 
   /* Free the fixed struts list */
-  meta_rectangle_free_list_and_elements (fixed_struts);
+  meta_rectangle_free_list_and_elements (fixed_strut_rects);
 
   return ret;
 }
@@ -1695,6 +1769,7 @@ meta_rectangle_find_nonintersected_xinerama_edges (
    */
   GList *ret;
   const GList  *cur;
+  GSList *temp_rects;
 
   /* Initialize the return list to be empty */
   ret = NULL;
@@ -1802,8 +1877,13 @@ meta_rectangle_find_nonintersected_xinerama_edges (
       cur = cur->next;
     }
 
+  temp_rects = NULL;
+  for (; all_struts; all_struts = all_struts->next)
+    temp_rects = g_slist_prepend (temp_rects,
+                                  &((MetaStrut*)all_struts->data)->rect);
   ret = meta_rectangle_remove_intersections_with_boxes_from_edges (ret, 
-                                                                   all_struts);
+                                                                   temp_rects);
+  g_slist_free (temp_rects);
 
   /* Sort the list */
   ret = g_list_sort (ret, meta_rectangle_edge_cmp);

src/core/compositor.h

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity compositing manager */
 
 /* 
@@ -25,14 +27,12 @@
 #include "util.h"
 #include "display.h"
 
-typedef void (* MetaAnimationFinishedFunc) (gpointer data);
-
 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,
+                                               MetaWindow        *window,
                                                Window             xwindow,
                                                XWindowAttributes *attrs);
 void            meta_compositor_remove_window (MetaCompositor    *compositor,
@@ -45,21 +45,11 @@ void meta_compositor_manage_screen   (MetaCompositor *compositor,
 void meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                       MetaScreen     *screen);
 
-void meta_compositor_minimize (MetaCompositor            *compositor,
-			       MetaWindow                *window,
-			       int                        x,
-			       int                        y,
-			       int                        width,
-			       int                        height,
-			       MetaAnimationFinishedFunc  finished_cb,
-			       gpointer                   finished_data);
+void meta_compositor_set_updates (MetaCompositor *compositor,
+                                  MetaWindow     *window,
+                                  gboolean        updates);
 
-void
-meta_compositor_set_updates (MetaCompositor *compositor,
-			     MetaWindow *window,
-			     gboolean updates);
-void
-meta_compositor_destroy (MetaCompositor *compositor);
+void meta_compositor_destroy (MetaCompositor *compositor);
 
 void meta_compositor_begin_move (MetaCompositor *compositor,
 				 MetaWindow *window,
@@ -72,7 +62,10 @@ void meta_compositor_end_move (MetaCompositor *compositor,
 			       MetaWindow *window);
 void meta_compositor_free_window (MetaCompositor *compositor,
 				  MetaWindow *window);
-void meta_compositor_free_window (MetaCompositor *compositor,
-				  MetaWindow *window);
+Pixmap meta_compositor_get_window_pixmap (MetaCompositor *compositor,
+                                          MetaWindow     *window);
+void meta_compositor_set_active_window (MetaCompositor *compositor,
+                                        MetaScreen     *screen,
+                                        MetaWindow     *window);
 
 #endif /* META_COMPOSITOR_H */

src/core/constraints.c

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity size/position constraints */
 
 /*
@@ -89,7 +91,7 @@
 
 typedef enum
 {
-  PRIORITY_MINIMUM = 0, // Dummy value used for loop start = min(all priorities)
+  PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
   PRIORITY_ASPECT_RATIO = 0,
   PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA = 0,
   PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1,
@@ -97,8 +99,9 @@ typedef enum
   PRIORITY_MAXIMIZATION = 2,
   PRIORITY_FULLSCREEN = 2,
   PRIORITY_SIZE_HINTS_LIMITS = 3,
+  PRIORITY_TITLEBAR_VISIBLE = 4,
   PRIORITY_PARTIALLY_VISIBLE_ON_WORKAREA = 4,
-  PRIORITY_MAXIMUM = 4  // Dummy value used for loop end = max(all priorities)
+  PRIORITY_MAXIMUM = 4 /* Dummy value used for loop end = max(all priorities) */
 } ConstraintPriority;
 
 typedef enum
@@ -165,6 +168,10 @@ static gboolean constrain_fully_onscreen     (MetaWindow         *window,
                                               ConstraintInfo     *info,
                                               ConstraintPriority  priority,
                                               gboolean            check_only);
+static gboolean constrain_titlebar_visible   (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
 static gboolean constrain_partially_onscreen (MetaWindow         *window,
                                               ConstraintInfo     *info,
                                               ConstraintPriority  priority,
@@ -209,6 +216,7 @@ static const Constraint all_constraints[] = {
   {constrain_aspect_ratio,       "constrain_aspect_ratio"},
   {constrain_to_single_xinerama, "constrain_to_single_xinerama"},
   {constrain_fully_onscreen,     "constrain_fully_onscreen"},
+  {constrain_titlebar_visible,   "constrain_titlebar_visible"},
   {constrain_partially_onscreen, "constrain_partially_onscreen"},
   {NULL,                         NULL}
 };
@@ -342,7 +350,7 @@ setup_constraint_info (ConstraintInfo      *info,
   else if (flags & META_IS_RESIZE_ACTION)
     info->action_type = ACTION_RESIZE;
   else if (flags & META_IS_MOVE_ACTION)
-    info->action_type = ACTION_MOVE_AND_RESIZE;
+    info->action_type = ACTION_MOVE;
   else
     g_error ("BAD, BAD developer!  No treat for you!  (Fix your calls to "
              "meta_window_move_resize_internal()).\n");
@@ -357,7 +365,7 @@ setup_constraint_info (ConstraintInfo      *info,
    * and (b) ignored it for aspect ratio windows -- at least in those
    * cases where both directions do actually change size.
    */
-  info->fixed_directions = 0;
+  info->fixed_directions = FIXED_DIRECTION_NONE;
   /* If x directions don't change but either y direction does */
   if ( orig->x == new->x && orig->x + orig->width  == new->x + new->width   &&
       (orig->y != new->y || orig->y + orig->height != new->y + new->height))
@@ -377,12 +385,13 @@ setup_constraint_info (ConstraintInfo      *info,
    * aren't explicit user interaction, though, so just clear it out.
    */
   if (!info->is_user_action)
-    info->fixed_directions = 0;
-
-  meta_window_get_work_area_current_xinerama (window, &info->work_area_xinerama);
+    info->fixed_directions = FIXED_DIRECTION_NONE;
 
   xinerama_info =
-    meta_screen_get_xinerama_for_window (window->screen, window);
+    meta_screen_get_xinerama_for_rect (window->screen, &info->current);
+  meta_window_get_work_area_for_xinerama (window,
+                                          xinerama_info->number,
+                                          &info->work_area_xinerama);
   info->entire_xinerama = xinerama_info->rect;
 
   cur_workspace = window->screen->active_workspace;
@@ -392,6 +401,23 @@ setup_constraint_info (ConstraintInfo      *info,
     meta_workspace_get_onxinerama_region (cur_workspace, 
                                           xinerama_info->number);
 
+  /* Workaround braindead legacy apps that don't know how to
+   * fullscreen themselves properly.
+   */
+  if (meta_rectangle_equal (new, &xinerama_info->rect) &&
+      window->has_fullscreen_func &&
+      !window->fullscreen)
+    {
+      /*
+      meta_topic (META_DEBUG_GEOMETRY,
+      */
+      meta_warning (
+                  "Treating resize request of legacy application %s as a "
+                  "fullscreen request\n",
+                  window->desc);
+      meta_window_make_fullscreen_internal (window);
+    }
+
   /* Log all this information for debugging */
   meta_topic (META_DEBUG_GEOMETRY,
               "Setting up constraint info:\n"
@@ -415,7 +441,7 @@ setup_constraint_info (ConstraintInfo      *info,
                 "Freakin' Invalid Stupid",
               (info->is_user_action) ? "true" : "false",
               meta_gravity_to_string (info->resize_gravity),
-              (info->fixed_directions == 0) ? "None" :
+              (info->fixed_directions == FIXED_DIRECTION_NONE) ? "None" :
                 (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
                 (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
                 "Freakin' Invalid Stupid",
@@ -434,13 +460,15 @@ place_window_if_needed(MetaWindow     *window,
 
   /* Do placement if any, so we go ahead and apply position
    * constraints in a move-only context. Don't place
-   * maximized/fullscreen windows until they are unmaximized
-   * and unfullscreened
+   * maximized/minimized/fullscreen windows until they are
+   * unmaximized, unminimized and unfullscreened.
    */
   did_placement = FALSE;
   if (!window->placed &&
       window->calc_placement &&
-      !META_WINDOW_MAXIMIZED (window) &&
+      !(window->maximized_horizontally ||
+        window->maximized_vertically) &&
+      !window->minimized &&
       !window->fullscreen)
     {
       MetaRectangle placed_rect = info->orig;
@@ -472,56 +500,50 @@ place_window_if_needed(MetaWindow     *window,
       /* Since we just barely placed the window, there's no reason to
        * consider any of the directions fixed.
        */
-      info->fixed_directions = 0;
+      info->fixed_directions = FIXED_DIRECTION_NONE;
     }
 
-  if ((window->maximize_horizontally_after_placement ||
-       window->maximize_vertically_after_placement) &&
-      (window->placed || did_placement))
+  if (window->placed || did_placement)
     {
-      /* define a sane saved_rect so that the user can unmaximize to
-       * something reasonable.
-       */
-      if (info->current.width >= info->work_area_xinerama.width)
-        {
-          info->current.width = .75 * info->work_area_xinerama.width;
-          info->current.x = info->work_area_xinerama.x +
-                   .125 * info->work_area_xinerama.width;
-        }
-      if (info->current.height >= info->work_area_xinerama.height)
-        {
-          info->current.height = .75 * info->work_area_xinerama.height;
-          info->current.y = info->work_area_xinerama.y +
-                   .083 * info->work_area_xinerama.height;
-        }
-
-      if (window->maximize_horizontally_after_placement &&
+      if (window->maximize_horizontally_after_placement ||
           window->maximize_vertically_after_placement)
-        meta_window_maximize_internal (window,   
-                                       META_MAXIMIZE_HORIZONTAL |
-                                       META_MAXIMIZE_VERTICAL,
-                                       &info->current);
-      else if (window->maximize_horizontally_after_placement)
         {
-          info->current.x = info->work_area_xinerama.x
-            + info->fgeom->left_width;
-          info->current.width = info->work_area_xinerama.width
-            - info->fgeom->left_width - info->fgeom->right_width;
+          /* define a sane saved_rect so that the user can unmaximize to
+           * something reasonable.
+           */
+          if (info->current.width >= info->work_area_xinerama.width)
+            {
+              info->current.width = .75 * info->work_area_xinerama.width;
+              info->current.x = info->work_area_xinerama.x +
+                       .125 * info->work_area_xinerama.width;
+            }
+          if (info->current.height >= info->work_area_xinerama.height)
+            {
+              info->current.height = .75 * info->work_area_xinerama.height;
+              info->current.y = info->work_area_xinerama.y +
+                       .083 * info->work_area_xinerama.height;
+            }
+
+          if (window->maximize_horizontally_after_placement ||
+              window->maximize_vertically_after_placement)
+            meta_window_maximize_internal (window,   
+                (window->maximize_horizontally_after_placement ?
+                 META_MAXIMIZE_HORIZONTAL : 0 ) |
+                (window->maximize_vertically_after_placement ?
+                 META_MAXIMIZE_VERTICAL : 0), &info->current);
+
+          /* maximization may have changed frame geometry */
+          if (window->frame && !window->fullscreen)
+            meta_frame_calc_geometry (window->frame, info->fgeom);
+
+          window->maximize_horizontally_after_placement = FALSE;
+          window->maximize_vertically_after_placement = FALSE;
         }
-      else if (window->maximize_vertically_after_placement);
+      if (window->minimize_after_placement)
         {
-          info->current.y = info->work_area_xinerama.y
-            + info->fgeom->top_height;
-          info->current.height = info->work_area_xinerama.height
-            - info->fgeom->top_height - info->fgeom->bottom_height;
+          meta_window_minimize (window);
+          window->minimize_after_placement = FALSE;
         }
-
-      /* maximization may have changed frame geometry */
-      if (window->frame && !window->fullscreen)
-        meta_frame_calc_geometry (window->frame, info->fgeom);
-
-      window->maximize_horizontally_after_placement = FALSE;
-      window->maximize_vertically_after_placement = FALSE;
     }
 }
 
@@ -536,23 +558,33 @@ update_onscreen_requirements (MetaWindow     *window,
       window->type == META_WINDOW_DOCK)
     return;
 
-  /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen and
-   * require_on_single_xinerama flags to *become false* due to user
-   * interactions (which is allowed since certain constraints are ignored
-   * for user interactions regardless of the setting of these flags).
-   * However, whether to make these flags *become true* due to just an
-   * application interaction is a little trickier.  It's possible that
-   * users may find not doing that strange since two application
-   * interactions that resize in opposite ways don't necessarily end up
-   * cancelling--but it may also be strange for the user to have an
-   * application resize the window so that it's onscreen, the user forgets
-   * about it, and then later the app is able to resize itself off the
-   * screen.  Anyway, for now, I'm think the latter is the more problematic
-   * case but this may need to be revisited.
+  /* We don't want to update the requirements for fullscreen windows;
+   * fullscreen windows are specially handled anyway, and it updating
+   * the requirements when windows enter fullscreen mode mess up the
+   * handling of the window when it leaves that mode (especially when
+   * the application sends a bunch of configurerequest events).  See
+   * #353699.
+   */
+  if (window->fullscreen)
+    return;
+
+  /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen,
+   * require_on_single_xinerama, and require_titlebar_visible flags to
+   * *become false* due to user interactions (which is allowed since
+   * certain constraints are ignored for user interactions regardless of
+   * the setting of these flags).  However, whether to make these flags
+   * *become true* due to just an application interaction is a little
+   * trickier.  It's possible that users may find not doing that strange
+   * since two application interactions that resize in opposite ways don't
+   * necessarily end up cancelling--but it may also be strange for the user
+   * to have an application resize the window so that it's onscreen, the
+   * user forgets about it, and then later the app is able to resize itself
+   * off the screen.  Anyway, for now, I think the latter is the more
+   * problematic case but this may need to be revisited.
    */
 
-  /* The require onscreen/on-single-xinerama stuff is relative to the
-   * outer window, not the inner
+  /* The require onscreen/on-single-xinerama and titlebar_visible
+   * stuff is relative to the outer window, not the inner
    */
   extend_by_frame (&info->current, info->fgeom);
 
@@ -582,6 +614,26 @@ update_onscreen_requirements (MetaWindow     *window,
                 window->desc, 
                 window->require_on_single_xinerama ? "TRUE" : "FALSE");
 
+  /* Update whether we want future constraint runs to require the
+   * titlebar to be visible.
+   */
+  if (window->frame && window->decorated)
+    {
+      MetaRectangle titlebar_rect;
+
+      titlebar_rect = info->current;
+      titlebar_rect.height = info->fgeom->top_height;
+      old = window->require_titlebar_visible;
+      window->require_titlebar_visible =
+        meta_rectangle_overlaps_with_region (info->usable_screen_region,
+                                             &titlebar_rect);
+      if (old ^ window->require_titlebar_visible)
+        meta_topic (META_DEBUG_GEOMETRY,
+                    "require_titlebar_visible for %s toggled to %s\n",
+                    window->desc,
+                    window->require_titlebar_visible ? "TRUE" : "FALSE");
+    }
+
   /* Don't forget to restore the position of the window */
   unextend_by_frame (&info->current, info->fgeom);
 }
@@ -639,8 +691,9 @@ constrain_maximization (MetaWindow         *window,
                         ConstraintPriority  priority,
                         gboolean            check_only)
 {
-  MetaRectangle min_size, max_size, work_area;
-  gboolean hminbad, vminbad, hmaxbad, vmaxbad;
+  MetaRectangle target_size;
+  MetaRectangle min_size, max_size;
+  gboolean hminbad, vminbad;
   gboolean horiz_equal, vert_equal;
   gboolean constraint_already_satisfied;
 
@@ -651,22 +704,51 @@ constrain_maximization (MetaWindow         *window,
   if (!window->maximized_horizontally && !window->maximized_vertically)
     return TRUE;
 
-  work_area = info->work_area_xinerama;
-  unextend_by_frame (&work_area, info->fgeom);
-  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  /* Calculate target_size = maximized size of (window + frame) */
+  if (window->maximized_horizontally && window->maximized_vertically)
+    target_size = info->work_area_xinerama;
+  else
+    {
+      /* Amount of maximization possible in a single direction depends
+       * on which struts could occlude the window given its current
+       * position.  For example, a vertical partial strut on the right
+       * is only relevant for a horizontally maximized window when the
+       * window is at a vertical position where it could be occluded
+       * by that partial strut.
+       */
+      MetaDirection  direction;
+      GSList        *active_workspace_struts;
 
-  hminbad = work_area.width < min_size.width && window->maximized_horizontally;
-  vminbad = work_area.height < min_size.height && window->maximized_vertically;
-  hmaxbad = work_area.width > max_size.width && window->maximized_horizontally;
-  vmaxbad = work_area.height > max_size.height && window->maximized_vertically;
-  if (hminbad || vminbad || hmaxbad || vmaxbad)
+      if (window->maximized_horizontally)
+        direction = META_DIRECTION_HORIZONTAL;
+      else
+        direction = META_DIRECTION_VERTICAL;
+      active_workspace_struts = window->screen->active_workspace->all_struts;
+
+      target_size = info->current;
+      extend_by_frame (&target_size, info->fgeom);
+      meta_rectangle_expand_to_avoiding_struts (&target_size,
+                                                &info->entire_xinerama,
+                                                direction,
+                                                active_workspace_struts);
+   }
+  /* Now make target_size = maximized size of client window */
+  unextend_by_frame (&target_size, info->fgeom);
+
+  /* Check min size constraints; max size constraints are ignored for maximized
+   * windows, as per bug 327543.
+   */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
+  vminbad = target_size.height < min_size.height && window->maximized_vertically;
+  if (hminbad || vminbad)
     return TRUE;
 
   /* Determine whether constraint is already satisfied; exit if it is */
-  horiz_equal = work_area.x      == info->current.x &&
-                work_area.width  == info->current.width;
-  vert_equal  = work_area.y      == info->current.y &&
-                work_area.height == info->current.height;
+  horiz_equal = target_size.x      == info->current.x &&
+                target_size.width  == info->current.width;
+  vert_equal  = target_size.y      == info->current.y &&
+                target_size.height == info->current.height;
   constraint_already_satisfied =
     (horiz_equal || !window->maximized_horizontally) &&
     (vert_equal  || !window->maximized_vertically);
@@ -676,13 +758,13 @@ constrain_maximization (MetaWindow         *window,
   /*** Enforce constraint ***/
   if (window->maximized_horizontally)
     {
-      info->current.x      = work_area.x;
-      info->current.width  = work_area.width;
+      info->current.x      = target_size.x;
+      info->current.width  = target_size.width;
     }
   if (window->maximized_vertically)
     {
-      info->current.y      = work_area.y;
-      info->current.height = work_area.height;
+      info->current.y      = target_size.y;
+      info->current.height = target_size.height;
     }
   return TRUE;
 }
@@ -727,7 +809,9 @@ constrain_size_increments (MetaWindow         *window,
                            gboolean            check_only)
 {
   int bh, hi, bw, wi, extra_height, extra_width;
+  int new_width, new_height;
   gboolean constraint_already_satisfied;
+  MetaRectangle *start_rect;
 
   if (priority > PRIORITY_SIZE_HINTS_INCREMENTS)
     return TRUE;
@@ -744,10 +828,12 @@ constrain_size_increments (MetaWindow         *window,
   wi = window->size_hints.width_inc;
   extra_height = (info->current.height - bh) % hi;
   extra_width  = (info->current.width  - bw) % wi;
+  /* ignore size increments for maximized windows */
   if (window->maximized_horizontally)
     extra_width *= 0;
   if (window->maximized_vertically)
     extra_height *= 0;
+  /* constraint is satisfied iff there is no extra height or width */
   constraint_already_satisfied = 
     (extra_height == 0 && extra_width == 0);
 
@@ -755,12 +841,32 @@ constrain_size_increments (MetaWindow         *window,
     return constraint_already_satisfied;
 
   /*** Enforce constraint ***/
-  /* Shrink to base + N * inc */
-  meta_rectangle_resize_with_gravity (&info->orig,
+  new_width  = info->current.width  - extra_width;
+  new_height = info->current.height - extra_height;
+
+  /* Adjusting down instead of up (as done in the above two lines) may
+   * violate minimum size constraints; fix the adjustment if this
+   * happens.
+   */
+  if (new_width  < window->size_hints.min_width)
+    new_width  += ((window->size_hints.min_width  - new_width)/wi  + 1)*wi;
+  if (new_height < window->size_hints.min_height)
+    new_height += ((window->size_hints.min_height - new_height)/hi + 1)*hi;
+
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+    
+  /* Resize to the new size */
+  meta_rectangle_resize_with_gravity (start_rect,
                                       &info->current, 
                                       info->resize_gravity,
-                                      info->current.width - extra_width,
-                                      info->current.height - extra_height);
+                                      new_width,
+                                      new_height);
   return TRUE;
 }
 
@@ -773,6 +879,7 @@ constrain_size_limits (MetaWindow         *window,
   MetaRectangle min_size, max_size;
   gboolean too_big, too_small, constraint_already_satisfied;
   int new_width, new_height;
+  MetaRectangle *start_rect;
 
   if (priority > PRIORITY_SIZE_HINTS_LIMITS)
     return TRUE;
@@ -787,8 +894,13 @@ constrain_size_limits (MetaWindow         *window,
 
   /* Determine whether constraint is already satisfied; exit if it is */
   get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
-  too_big = !meta_rectangle_could_fit_rect (&info->current, &min_size);
-  too_small = !meta_rectangle_could_fit_rect (&max_size, &info->current);
+  /* We ignore max-size limits for maximized windows; see #327543 */
+  if (window->maximized_horizontally)
+    max_size.width = MAX (max_size.width, info->current.width);
+  if (window->maximized_vertically)
+    max_size.height = MAX (max_size.height, info->current.height);
+  too_small = !meta_rectangle_could_fit_rect (&info->current, &min_size);
+  too_big   = !meta_rectangle_could_fit_rect (&max_size, &info->current);
   constraint_already_satisfied = !too_big && !too_small;
   if (check_only || constraint_already_satisfied)
     return constraint_already_satisfied;
@@ -796,7 +908,16 @@ constrain_size_limits (MetaWindow         *window,
   /*** Enforce constraint ***/
   new_width  = CLAMP (info->current.width,  min_size.width,  max_size.width);
   new_height = CLAMP (info->current.height, min_size.height, max_size.height);
-  meta_rectangle_resize_with_gravity (&info->orig,
+  
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+  
+  meta_rectangle_resize_with_gravity (start_rect,
                                       &info->current, 
                                       info->resize_gravity,
                                       new_width,
@@ -815,6 +936,7 @@ constrain_aspect_ratio (MetaWindow         *window,
   int fudge, new_width, new_height;
   double best_width, best_height;
   double alt_width, alt_height;
+  MetaRectangle *start_rect;
 
   if (priority > PRIORITY_ASPECT_RATIO)
     return TRUE;
@@ -920,7 +1042,15 @@ constrain_aspect_ratio (MetaWindow         *window,
       break;
     }
 
-  meta_rectangle_resize_with_gravity (&info->orig,
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+
+  meta_rectangle_resize_with_gravity (start_rect,
                                       &info->current, 
                                       info->resize_gravity,
                                       new_width,
@@ -939,13 +1069,15 @@ do_screen_and_xinerama_relative_constraints (
   gboolean exit_early = FALSE, constraint_satisfied;
   MetaRectangle how_far_it_can_be_smushed, min_size, max_size;
 
+#ifdef WITH_VERBOSE_MODE
   /* First, log some debugging information */
   char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
-  (void) spanning_region;  /* Avoid stupid & incorrect compiler warnings... */
+
   meta_topic (META_DEBUG_GEOMETRY,
               "screen/xinerama constraint; region_spanning_rectangles: %s\n",
               meta_rectangle_region_to_string (region_spanning_rectangles, ", ", 
                                                spanning_region));
+#endif
 
   /* Determine whether constraint applies; exit if it doesn't */
   how_far_it_can_be_smushed = info->current;
@@ -1042,6 +1174,7 @@ constrain_fully_onscreen (MetaWindow         *window,
    */
   if (window->type == META_WINDOW_DESKTOP ||
       window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
       !window->require_fully_onscreen     || 
       info->is_user_action)
     return TRUE;
@@ -1053,6 +1186,91 @@ constrain_fully_onscreen (MetaWindow         *window,
                                                  check_only);
 }
 
+static gboolean
+constrain_titlebar_visible (MetaWindow         *window,
+                            ConstraintInfo     *info,
+                            ConstraintPriority  priority,
+                            gboolean            check_only)
+{
+  gboolean unconstrained_user_action;
+  gboolean retval;
+  int bottom_amount;
+  int horiz_amount_offscreen, vert_amount_offscreen;
+  int horiz_amount_onscreen,  vert_amount_onscreen;
+
+  if (priority > PRIORITY_TITLEBAR_VISIBLE)
+    return TRUE;
+
+  /* Allow the titlebar beyond the top of the screen only if the user wasn't
+   * clicking on the frame to start the move.
+   */
+  unconstrained_user_action =
+    info->is_user_action && !window->display->grab_frame_action;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
+      !window->require_titlebar_visible   ||
+      !window->decorated                  ||
+      unconstrained_user_action)
+    return TRUE;
+
+  /* Determine how much offscreen things are allowed.  We first need to
+   * figure out how much must remain on the screen.  For that, we use 25%
+   * window width/height but clamp to the range of (10,75) pixels.  This is
+   * somewhat of a seat of my pants random guess at what might look good.
+   * Then, the amount that is allowed off is just the window size minus
+   * this amount (but no less than 0 for tiny windows).
+   */
+  horiz_amount_onscreen = info->current.width  / 4;
+  vert_amount_onscreen  = info->current.height / 4;
+  horiz_amount_onscreen = CLAMP (horiz_amount_onscreen, 10, 75);
+  vert_amount_onscreen  = CLAMP (vert_amount_onscreen,  10, 75);
+  horiz_amount_offscreen = info->current.width - horiz_amount_onscreen;
+  vert_amount_offscreen  = info->current.height - vert_amount_onscreen;
+  horiz_amount_offscreen = MAX (horiz_amount_offscreen, 0);
+  vert_amount_offscreen  = MAX (vert_amount_offscreen,  0);
+  /* Allow the titlebar to touch the bottom panel;  If there is no titlebar,
+   * require vert_amount to remain on the screen.
+   */
+  if (window->frame)
+    {
+      bottom_amount = info->current.height + info->fgeom->bottom_height;
+      vert_amount_onscreen = info->fgeom->top_height;
+    }
+  else
+    bottom_amount = vert_amount_offscreen;
+
+  /* Extend the region, have a helper function handle the constraint,
+   * then return the region to its original size.
+   */
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              horiz_amount_offscreen,
+                                              horiz_amount_offscreen, 
+                                              0, /* Don't let titlebar off */
+                                              bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+  retval =
+    do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              -horiz_amount_offscreen,
+                                              -horiz_amount_offscreen,
+                                              0, /* Don't let titlebar off */
+                                              -bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+
+  return retval;
+}
+
 static gboolean
 constrain_partially_onscreen (MetaWindow         *window,
                               ConstraintInfo     *info,

src/core/constraints.h

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

src/core/core.c

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity interface used by GTK+ UI to talk to core */
 
 /* 
@@ -27,11 +29,20 @@
 #include "workspace.h"
 #include "prefs.h"
 
-void
-meta_core_get_client_size (Display *xdisplay,
-                           Window   frame_xwindow,
-                           int     *width,
-                           int     *height)
+/* Looks up the MetaWindow representing the frame of the given X window.
+ * Used as a helper function by a bunch of the functions below.
+ *
+ * FIXME: The functions that use this function throw the result away
+ * after use. Many of these functions tend to be called in small groups,
+ * which results in get_window() getting called several times in succession
+ * with the same parameters. We should profile to see whether this wastes
+ * much time, and if it does we should look into a generalised
+ * meta_core_get_window_info() which takes a bunch of pointers to variables
+ * to put its results in, and only fills in the non-null ones.
+ */
+static MetaWindow *
+get_window (Display *xdisplay,
+            Window   frame_xwindow)
 {
   MetaDisplay *display;
   MetaWindow *window;
@@ -40,164 +51,174 @@ meta_core_get_client_size (Display *xdisplay,
   window = meta_display_lookup_x_window (display, frame_xwindow);
 
   if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-  
-  if (width)
-    *width = window->rect.width;
-  if (height)
-    *height = window->rect.height;
-}
-
-gboolean
-meta_core_titlebar_is_onscreen (Display *xdisplay,
-                                Window   frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-
-  return meta_window_titlebar_is_onscreen (window);  
-}
-
-
-Window
-meta_core_get_client_xwindow (Display *xdisplay,
-                              Window   frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-
-  return window->xwindow;
-}
-
-MetaFrameFlags
-meta_core_get_frame_flags (Display *xdisplay,
-                           Window   frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-
-  return meta_frame_get_flags (window->frame);
-}
-
-MetaFrameType
-meta_core_get_frame_type (Display *xdisplay,
-                          Window   frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  MetaFrameType base_type;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-
-  base_type = META_FRAME_TYPE_LAST;
-  
-  switch (window->type)
     {
-    case META_WINDOW_NORMAL:
-      base_type = META_FRAME_TYPE_NORMAL;
-      break;
-      
-    case META_WINDOW_DIALOG:
-      base_type = META_FRAME_TYPE_DIALOG;
-      break;
-      
-    case META_WINDOW_MODAL_DIALOG:
-      base_type = META_FRAME_TYPE_MODAL_DIALOG;
-      break;
-      
-    case META_WINDOW_MENU:
-      base_type = META_FRAME_TYPE_MENU;
-      break;
-
-    case META_WINDOW_UTILITY:
-      base_type = META_FRAME_TYPE_UTILITY;
-      break;
-      
-    case META_WINDOW_DESKTOP:
-    case META_WINDOW_DOCK:
-    case META_WINDOW_TOOLBAR:
-    case META_WINDOW_SPLASHSCREEN:
-      /* No frame */
-      base_type = META_FRAME_TYPE_LAST;
-      break;
+      meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+      return NULL;
     }
 
-  if (base_type == META_FRAME_TYPE_LAST)
-    return META_FRAME_TYPE_LAST; /* can't add border if undecorated */
-  else if (window->border_only)
-    return META_FRAME_TYPE_BORDER; /* override base frame type */
-  else
-    return base_type;
+  return window;
 }
 
-GdkPixbuf*
-meta_core_get_mini_icon (Display *xdisplay,
-                         Window   frame_xwindow)
+void
+meta_core_get (Display *xdisplay,
+    Window xwindow,
+    ...)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
+  va_list args;
+  MetaCoreGetType request;
 
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-  
-  return window->mini_icon;
-}
+  MetaDisplay *display = meta_display_for_x_display (xdisplay);
+  MetaWindow *window = meta_display_lookup_x_window (display, xwindow);
 
-GdkPixbuf*
-meta_core_get_icon (Display *xdisplay,
-                    Window   frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
+  va_start (args, xwindow);
 
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
-  
-  return window->icon;
+  request = va_arg (args, MetaCoreGetType);
+
+  /* Now, we special-case the first request slightly. Mostly, requests
+   * for information on windows which have no frame are errors.
+   * But sometimes we may want to know *whether* a window has a frame.
+   * In this case, pass the key META_CORE_WINDOW_HAS_FRAME
+   * as the *first* request, with a pointer to a boolean; if the window
+   * has no frame, this will be set to False and meta_core_get will
+   * exit immediately (so the values of any other requests will be
+   * undefined). Otherwise it will be set to True and meta_core_get will
+   * continue happily on its way.
+   */
+
+  if (request != META_CORE_WINDOW_HAS_FRAME &&
+      (window == NULL || window->frame == NULL)) {
+    meta_bug ("No such frame window 0x%lx!\n", xwindow);
+    return;
+  }
+
+  while (request != META_CORE_GET_END) {
+    
+    gpointer answer = va_arg (args, gpointer);
+
+    switch (request) {
+      case META_CORE_WINDOW_HAS_FRAME:
+        *((gboolean*)answer) = window != NULL && window->frame != NULL;
+        if (!*((gboolean*)answer)) return; /* see above */
+        break; 
+      case META_CORE_GET_CLIENT_WIDTH:
+        *((gint*)answer) = window->rect.width;
+        break;
+      case META_CORE_GET_CLIENT_HEIGHT:
+        *((gint*)answer) = window->rect.height;
+        break;
+      case META_CORE_IS_TITLEBAR_ONSCREEN:
+        *((gboolean*)answer) = meta_window_titlebar_is_onscreen (window);
+        break;
+      case META_CORE_GET_CLIENT_XWINDOW:
+        *((Window*)answer) = window->xwindow;
+        break;
+      case META_CORE_GET_FRAME_FLAGS:
+        *((MetaFrameFlags*)answer) = meta_frame_get_flags (window->frame);
+        break; 
+      case META_CORE_GET_FRAME_TYPE:
+          {
+          MetaFrameType base_type = META_FRAME_TYPE_LAST;
+
+          switch (window->type)
+            {
+            case META_WINDOW_NORMAL:
+              base_type = META_FRAME_TYPE_NORMAL;
+              break;
+
+            case META_WINDOW_DIALOG:
+              base_type = META_FRAME_TYPE_DIALOG;
+              break;
+
+            case META_WINDOW_MODAL_DIALOG:
+              base_type = META_FRAME_TYPE_MODAL_DIALOG;
+              break;
+
+            case META_WINDOW_MENU:
+              base_type = META_FRAME_TYPE_MENU;
+              break;
+
+            case META_WINDOW_UTILITY:
+              base_type = META_FRAME_TYPE_UTILITY;
+              break;
+
+            case META_WINDOW_DESKTOP:
+            case META_WINDOW_DOCK:
+            case META_WINDOW_TOOLBAR:
+            case META_WINDOW_SPLASHSCREEN:
+              /* No frame */
+              base_type = META_FRAME_TYPE_LAST;
+              break;
+
+            }
+
+          if (base_type == META_FRAME_TYPE_LAST)
+            {
+              /* can't add border if undecorated */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_LAST; 
+            }
+          else if (window->border_only)
+            {
+              /* override base frame type */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_BORDER; 
+            }
+          else
+            {
+              *((MetaFrameType*)answer) = base_type;
+            }
+
+          break; 
+          }
+      case META_CORE_GET_MINI_ICON:
+        *((GdkPixbuf**)answer) = window->mini_icon;
+        break;
+      case META_CORE_GET_ICON:
+        *((GdkPixbuf**)answer) = window->icon;
+        break;
+      case META_CORE_GET_X:
+        meta_window_get_position (window, (int*)answer, NULL);
+        break;
+      case META_CORE_GET_Y:
+        meta_window_get_position (window, NULL, (int*)answer);
+        break;
+      case META_CORE_GET_FRAME_WORKSPACE:
+        *((gint*)answer) = meta_window_get_net_wm_desktop (window);
+        break;
+      case META_CORE_GET_FRAME_X:
+        *((gint*)answer) = window->frame->rect.x;
+        break;
+      case META_CORE_GET_FRAME_Y:
+        *((gint*)answer) = window->frame->rect.y;
+        break;
+      case META_CORE_GET_FRAME_WIDTH:
+        *((gint*)answer) = window->frame->rect.width;
+        break;
+      case META_CORE_GET_FRAME_HEIGHT:
+        *((gint*)answer) = window->frame->rect.height;
+        break;
+      case META_CORE_GET_SCREEN_WIDTH:
+        *((gint*)answer) = window->screen->rect.width;
+        break;
+      case META_CORE_GET_SCREEN_HEIGHT:
+        *((gint*)answer) = window->screen->rect.height;
+        break;
+
+      default:
+        meta_warning(_("Unknown window information request: %d"), request);
+    }
+
+    request = va_arg (args, MetaCoreGetType);
+  } 
+
+  va_end (args);
 }
 
 void
 meta_core_queue_frame_resize (Display *xdisplay,
                               Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  meta_window_queue_move_resize (window);
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
 }
 
 void
@@ -206,14 +227,7 @@ meta_core_user_move (Display *xdisplay,
                      int      x,
                      int      y)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_move (window, TRUE, x, y);
 }
@@ -225,14 +239,7 @@ meta_core_user_resize  (Display *xdisplay,
                         int      width,
                         int      height)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_resize_with_gravity (window, TRUE, width, height, gravity);
 }
@@ -241,14 +248,7 @@ void
 meta_core_user_raise (Display *xdisplay,
                       Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
   meta_window_raise (window);
 }
@@ -256,16 +256,9 @@ meta_core_user_raise (Display *xdisplay,
 void
 meta_core_user_lower_and_unfocus (Display *xdisplay,
                                   Window   frame_xwindow,
-                                  Time     timestamp)
+                                  guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
   meta_window_lower (window);
 
@@ -306,72 +299,18 @@ meta_core_user_lower_and_unfocus (Display *xdisplay,
 void
 meta_core_user_focus (Display *xdisplay,
                       Window   frame_xwindow,
-                      Time     timestamp)
+                      guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
   meta_window_focus (window, timestamp);
 }
 
-void
-meta_core_get_position (Display *xdisplay,
-                        Window   frame_xwindow,
-                        int     *x,
-                        int     *y)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  meta_window_get_position (window, x, y);
-}
-
-void
-meta_core_get_size (Display *xdisplay,
-                    Window   frame_xwindow,
-                    int     *width,
-                    int     *height)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  if (width)
-    *width = window->rect.width;
-  if (height)
-    *height = window->rect.height;
-}
-
-
 void
 meta_core_minimize (Display *xdisplay,
                     Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_minimize (window);
 }
@@ -380,14 +319,7 @@ void
 meta_core_maximize (Display *xdisplay,
                     Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
@@ -396,18 +328,45 @@ meta_core_maximize (Display *xdisplay,
                         META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
 }
 
+void
+meta_core_toggle_maximize_vertically (Display *xdisplay,
+				      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_VERTICALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_VERTICAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_toggle_maximize_horizontally (Display *xdisplay,
+				        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_HORIZONTALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_HORIZONTAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_HORIZONTAL);
+}
+
 void
 meta_core_toggle_maximize (Display *xdisplay,
                            Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
@@ -424,14 +383,7 @@ void
 meta_core_unmaximize (Display *xdisplay,
                       Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
@@ -445,78 +397,63 @@ meta_core_delete (Display *xdisplay,
                   Window   frame_xwindow,
                   guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-  
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
      
   meta_window_delete (window, timestamp);
 }
 
 void
 meta_core_unshade (Display *xdisplay,
-                   Window   frame_xwindow)
+                   Window   frame_xwindow,
+                   guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  meta_window_unshade (window);
+  meta_window_unshade (window, timestamp);
 }
 
 void
 meta_core_shade (Display *xdisplay,
-                 Window   frame_xwindow)
+                 Window   frame_xwindow,
+                 guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  meta_window_shade (window);
+  meta_window_shade (window, timestamp);
 }
 
 void
 meta_core_unstick (Display *xdisplay,
                    Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_unstick (window);
 }
 
+void
+meta_core_make_above (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_make_above (window);
+}
+
+void
+meta_core_unmake_above (Display *xdisplay,
+                        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unmake_above (window);
+}
+
 void
 meta_core_stick (Display *xdisplay,
                  Window   frame_xwindow)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_stick (window);
 }
@@ -526,14 +463,7 @@ meta_core_change_workspace (Display *xdisplay,
                             Window   frame_xwindow,
                             int      new_workspace)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
 
   meta_window_change_workspace (window,
                                 meta_screen_get_workspace_by_index (window->screen,
@@ -560,67 +490,16 @@ meta_core_get_active_workspace (Screen *xscreen)
   return meta_workspace_index (screen->active_workspace);
 }
 
-int
-meta_core_get_frame_workspace (Display *xdisplay,
-                               Window frame_xwindow)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  return meta_window_get_net_wm_desktop (window);
-}
-
-void
-meta_core_get_frame_extents   (Display        *xdisplay,
-                               Window          frame_xwindow,
-                               int            *x,
-                               int            *y,
-                               int            *width,
-                               int            *height)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
-  if (x)
-    *x = window->frame->rect.x;
-  if (y)
-    *y = window->frame->rect.y;
-  if (width)
-    *width = window->frame->rect.width;
-  if (height)
-    *height = window->frame->rect.height;
-}
-
-
 void
 meta_core_show_window_menu (Display *xdisplay,
                             Window   frame_xwindow,
                             int      root_x,
                             int      root_y,
                             int      button,
-                            Time     timestamp)
+                            guint32  timestamp)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
   meta_window_focus (window, timestamp);
@@ -760,36 +639,32 @@ meta_core_begin_grab_op (Display    *xdisplay,
                          Window      frame_xwindow,
                          MetaGrabOp  op,
                          gboolean    pointer_already_grabbed,
-                         int         event_serial,
+                         gboolean    frame_action,
                          int         button,
                          gulong      modmask,
-                         Time        timestamp,
+                         guint32     timestamp,
                          int         root_x,
                          int         root_y)
 {
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
   MetaDisplay *display;
-  MetaWindow *window;
   MetaScreen *screen;
   
   display = meta_display_for_x_display (xdisplay);
   screen = meta_display_screen_for_xwindow (display, frame_xwindow);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
 
   g_assert (screen != NULL);
   
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);  
-
   return meta_display_begin_grab_op (display, screen, window,
                                      op, pointer_already_grabbed,
-                                     event_serial,
+                                     frame_action,
                                      button, modmask,
                                      timestamp, root_x, root_y);
 }
 
 void
 meta_core_end_grab_op (Display *xdisplay,
-                       Time     timestamp)
+                       guint32  timestamp)
 {
   MetaDisplay *display;
   
@@ -847,7 +722,7 @@ meta_core_grab_buttons  (Display *xdisplay,
                          Window   frame_xwindow)
 {
   MetaDisplay *display;
-  
+    
   display = meta_display_for_x_display (xdisplay);
 
   meta_verbose ("Grabbing buttons on frame 0x%lx\n", frame_xwindow);
@@ -859,39 +734,11 @@ meta_core_set_screen_cursor (Display *xdisplay,
                              Window   frame_on_screen,
                              MetaCursor cursor)
 {
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_on_screen);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_on_screen);  
+  MetaWindow *window = get_window (xdisplay, frame_on_screen);
 
   meta_frame_set_screen_cursor (window->frame, cursor);
 }
 
-void
-meta_core_get_screen_size (Display *xdisplay,
-                           Window   frame_on_screen,
-                           int     *width,
-                           int     *height)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_on_screen);
-
-  if (window == NULL || window->frame == NULL)
-    meta_bug ("No such frame window 0x%lx!\n", frame_on_screen);  
-
-  if (width)
-    *width = window->screen->rect.width;
-  if (height)
-    *height = window->screen->rect.height;
-}
-
 void
 meta_core_increment_event_serial (Display *xdisplay)
 {
@@ -902,3 +749,30 @@ meta_core_increment_event_serial (Display *xdisplay)
   meta_display_increment_event_serial (display);
 }
 
+void
+meta_invalidate_default_icons (void)
+{
+  GSList *displays;
+
+  for (displays = meta_displays_list ();
+       displays != NULL;
+       displays = displays->next)
+    {
+      GSList *windows, *l;
+
+      windows = meta_display_list_windows (displays->data);
+      for (l = windows; l != NULL; l = l->next)
+        {
+          MetaWindow *window = (MetaWindow*)l->data;
+
+          if (window->icon_cache.origin == USING_FALLBACK_ICON)
+            {
+              meta_icon_cache_free (&(window->icon_cache));
+              meta_window_update_icon_now (window);
+            }
+        }
+
+      g_slist_free (windows);
+    }
+}
+

src/core/delete.c

@@ -1,3 +1,5 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
 /* Metacity window deletion */
 
 /* 
@@ -20,6 +22,9 @@
  * 02111-1307, USA.
  */
 
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for gethostname() */
+
 #include <config.h>
 #include "util.h"
 #include "window.h"
@@ -34,12 +39,13 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-static void meta_window_present_delete_dialog (MetaWindow *window);
+static void meta_window_present_delete_dialog (MetaWindow *window,
+                                               guint32     timestamp);
 
 static void
 delete_ping_reply_func (MetaDisplay *display,
                         Window       xwindow,
-                        Time         timestamp,
+                        guint32      timestamp,
                         void        *user_data)
 {
   meta_topic (META_DEBUG_PING,
@@ -268,7 +274,7 @@ io_from_ping_dialog (GIOChannel   *channel,
 
       meta_topic (META_DEBUG_PING,
                   "Read %d bytes strlen %d \"%s\" from child\n",
-                  len, str ? strlen (str) : 0, str ? str : "NULL");
+                  len, str ? (int) strlen (str) : 0, str ? str : "NULL");
       
       if (len > 0)
         {
@@ -292,7 +298,7 @@ io_from_ping_dialog (GIOChannel   *channel,
 static void
 delete_ping_timeout_func (MetaDisplay *display,
                           Window       xwindow,
-                          Time         timestamp,
+                          guint32      timestamp,
                           void        *user_data)
 {
   MetaWindow *window = user_data;
@@ -303,6 +309,7 @@ delete_ping_timeout_func (MetaDisplay *display,
   char numbuf[32];
   char timestampbuf[32];
   char *window_id_str;
+  char *window_title;
   GIOChannel *channel;
   
   meta_topic (META_DEBUG_PING,
@@ -311,14 +318,15 @@ delete_ping_timeout_func (MetaDisplay *display,
 
   if (window->dialog_pid >= 0)
     {
-      meta_window_present_delete_dialog (window);
+      meta_window_present_delete_dialog (window, timestamp);
       return;
     }
   
   window_id_str = g_strdup_printf ("0x%lx", window->xwindow);
+  window_title = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
 
   sprintf (numbuf, "%d", window->screen->number);
-  sprintf (timestampbuf, "%lu", timestamp);
+  sprintf (timestampbuf, "%u", timestamp);
   
   argv[0] = METACITY_LIBEXECDIR"/metacity-dialog";
   argv[1] = "--screen";
@@ -326,7 +334,7 @@ delete_ping_timeout_func (MetaDisplay *display,
   argv[3] = "--timestamp";
   argv[4] = timestampbuf;
   argv[5] = "--kill-window-question";
-  argv[6] = window->title;
+  argv[6] = window_title;
   argv[7] = window_id_str;
   argv[8] = NULL;
   
@@ -359,12 +367,13 @@ delete_ping_timeout_func (MetaDisplay *display,
   g_io_channel_unref (channel);
   
  out:
+  g_free (window_title);
   g_free (window_id_str);
 }
 
 void
 meta_window_delete (MetaWindow  *window,
-                    Time         timestamp)
+                    guint32      timestamp)
 {
   meta_error_trap_push (window->display);
   if (window->delete_window)
@@ -476,7 +485,7 @@ meta_window_free_delete_dialog (MetaWindow *window)
 }
 
 static void
-meta_window_present_delete_dialog (MetaWindow *window)
+meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp)
 {
   meta_topic (META_DEBUG_PING,
               "Presenting existing ping dialog for %s\n",
@@ -501,8 +510,7 @@ meta_window_present_delete_dialog (MetaWindow *window)
               w->res_class &&
               g_strcasecmp (w->res_class, "metacity-dialog") == 0)
             {
-              meta_window_activate (w,
-                                    meta_display_get_current_time (w->display));
+              meta_window_activate (w, timestamp);
               break;
             }