Get master's fixes for the file chooser

Call XReconfigureWMWindow with proper screen
Thanks gcc : gdkwindow-x11.c:1731: warning: passing argument 3 of 'XReconfigureWMWindow' makes integer from pointer without a cast /usr/include/X11/Xlib.h:1871: note: expected 'int' but argument is of type 'struct GdkScreen *' Signed-off-by: Pascal Terjan <pterjan@mandriva.com>
2009-10-01 15:59:06 -05:00 · 2009-10-01 18:36:43 +02:00 · 2009-10-01 11:45:28 -04:00 · 2009-10-01 01:23:06 +00:00 · 2009-09-30 18:49:33 -05:00 · 2009-09-30 18:39:33 -05:00
376 changed files with 63613 additions and 60652 deletions
@@ -1,3 +1,273 @@
+Overview of Changes from GTK+ 2.18.0 to 2.18.1
+==============================================
+
+* Client-side Windows:
+ - Fix a problem with the F-Spot screensaver
+ - Request native events that are necessary for grab emulation
+ - Fixes for input device and extended input event handling
+ - Allow up to 255 buttons in extended input events
+
+* OS X:
+ - Improve handling of multi-monitor setups
+ - Basic DND works
+ - Other improvements
+
+* Filechooser:
+ - Support Tracker 0.7 in the search code
+
+* Bugs fixed:
+ 596423 Landscape pages are the wrong way around
+ 588449 DnD doesn't work on GDK/Quartz
+ 596080 Mention "gtk-tooltip" in gtk_widget_set_tooltip_window
+ 596580 Blank rows in entry autocompletion
+ 588649 extended input events sent to widgets that didn't...
+ 596081 Update tracker support for version 0.7
+ 596345 clicking empty space in backgrounds...
+ 596494 New property "cursor" in 2.18's GdkWindow with wrong...
+ 596012 popup menu position is horribly off on gdk quartz...
+ 596250 Gdkcursor-quartz.c doesn't implement GDK_BLANK_CURSOR
+ 586207 Printing dialog with a CUPS printer connected...
+
+* Translation updates:
+ Assamese
+ British English
+ Czech
+ Estonian
+ French
+ Galician
+ German
+ Hungarian
+ Slovenian
+ Spanish
+ Swedish
+
+
+Overview of Changes from GTK+ 2.17.11 to 2.18.0
+===============================================
+
+* Add GtkTreeModelFilter testsuite and fix multiple bugs
+
+* Client-side windows:
+ - Fix issues around recursion and gdk_window_process_updates
+ - Fix issues with grabs and cursors
+ - Handle window hierarchy and geometry changes in expose handlers
+ - New function, gdk_window_flush, that may be needed in certain
+   situations
+ - Automatically flush windows when doing non-double-buffered exposes
+
+* Quartz backend:
+ - Fix various 'stuck UI' issues
+ - Fix the size of the root window
+
+* Bugs fixed:
+ 588455 run application broken when setting background color...
+ 346800 Rework sort/filter models to use indices to parents
+ 593678 select "Manage Custom Sizes" from print dialog hangs gedit
+ 594652 gtk printer dialog does not understand boolean printer options
+ 594668 Add new Xorg keysyms
+ 591583 Padre (a wxPerl+Gtk IDE) hangs when editing Perl code...
+ 594600 Windows only allows 64-character system-tray tooltips
+ 594679 Fix warning in testwindows.c
+ 594880 Drawing issues in ExoIconView
+ 593507 AbiWord's main drawing area not exposed properly
+ 594913 is_composited race ...
+ 594738 Windows often do not respond to events on dual-head
+ 503776 crash when trying to print to non-existent lpr printer
+ 595599 Don't focus unmapped radio buttons
+ 595790 Segfault in gtkiconfactory.c on NULL GError
+ 588649 extended input events sent to widgets that didn't...
+ 550939 GtkFileChooser listbox does not refresh selection
+
+* New deprecation:
+ gdk_event_get_graphics_exposes has been deprecated
+
+* Updated translations:
+ Afrikaans
+ Assamese
+ Bengali India
+ Brazilian Portuguese
+ British English
+ Catalan
+ Danish
+ Dutch
+ German
+ Greek
+ Gujarati
+ Hindi
+ Italian
+ Japanese
+ Lithuanian
+ Maithili
+ Malayalam
+ Marathi
+ Norwegian bokmål
+ Oriya
+ Polish
+ Romanian
+ Simplified Chinese
+ Slovenian
+ Traditional Chinese
+ Ukrainian
+
+
+Overview of Changes from GTK+ 2.17.10 to 2.17.11
+================================================
+
+* Client-side windows:
+ - Add gdk_cairo_reset_clip that lets you get back the original
+   drawable clip
+ - Add gdk_window_restack to more conveniently restack child windows
+ - Add gdk_window_is_destroyed as a replacement for GDK_WINDOW_DESTROYED
+ - Deprecated GDK_WINDOW_OBJECT and GdkWindowObject
+
+* GSEAL:
+ - Add gtk_widget_set_receives_default and gtk_widget_get_receives_default
+   accessors for GTK_RECEIVES_DEFAULT
+
+* GtkTreeView:
+ - Correctly propagate insensitive state to cell renderers
+
+* GtkTextView:
+ - Merge a number of scrolling-related fixes from Maemo
+
+* Bugs fixed:
+ 564160 gtk_combo_box_entry_set_text_column too restrictive
+ 593868 gtk_im_multicontext_set_client_window recreate a new slave...
+ 593644 gdk_x11_screen_get_window_manager_name should not cache...
+ 594178 gdk-pixbuf-query-loaders segfault in write_loader_info
+ 567124 proposal to delay doing something related to immodule...
+ 588788 GTK+ compilation should work with automake1.10
+ 584638 Build of gtkupdateiconcache without NLS breaks
+ 593788 misprint in the returning value of gdk_selection_property_get
+ 593606 Missing include in gtk/gtkcellrendereraccel.c
+ 593877 Undefined symbols while compilation
+
+* Translation updates:
+ French
+ Hebrew
+ Hungarian
+ Norwegian bokmål
+
+
+Overview of Changes from GTK+ 2.17.9 to 2.17.10
+===============================================
+
+* Client-side windows:
+ - Regression fixes continue
+ - Multiple clipping issues have been fixed
+ - gdk_window_beep() works again
+ - gtk-demo now has a few offscreen window demos
+
+* GSEAL:
+ - Several more getters and setters have been added:
+   gtk_widget_is_toplevel(), gtk_widget_is_drawable(), gtk_widget_set_window()
+
+* Bugs fixed:
+ 592752 aisleriot card drag start makes card appear behind...
+ 592901 Crash in JPEG pixbuf loader instead of error
+ 592263 redraw problem in text view
+ 593011 Cannot move applet with middle click
+ 592624 BadAccess from gdk_window_x11_set_events
+ 592606 Activate the default button in a respose-request callback
+ 593249 emacs and acroread don't work properly
+ 592883 Spin cell rendererer problem with double click
+ 588199 GtkTreeView rendering glitch while using a default...
+ 543310 set_enable_tree_lines doesn't work when a cellrenderer...
+ 589636 csw broke DND from panel menus
+ 593595 broken clip handling in GtkLabel
+ 590921 NULL should not be a valid return value for gdk_window_new()
+ 590861 cups_printer_create_cairo_surface() sets a fallback resolution...
+ 544724 delete new line requires two keystrokes
+ 593001 Emit 'update-custom-widget' on page setup change
+ 593317 gtkwindow leaks startup ID
+ 593080 mem leak
+ 593481 GtkEntryCompletion action-activated signal is emitted...
+ 593135 gtk_entry_set_icon_from_pixbuf only works one time
+ 593012 configure doesn't handle --enable-{cups,papi} correctly
+ 592862 There is a misprint on the returning value of gdk_pixmap_lookup()
+ 586466 GtkPrintOperation printing fails if it is the only event source
+ 434318 printer detail acquisition needs events
+ 593712 configure fails to to check properly for cups...
+
+* Translation updates:
+ Asturian
+ Basque
+ Bengali India
+ Czech
+ Finnish
+ Hindi
+ Kannada
+ Oriya
+ Polish
+ Serbian
+ Tamil
+ Telugu
+
+
+Overview of Changes from GTK+ 2.17.8 to 2.17.9
+==============================================
+
+* Client-side windows:
+ - Add a compatibility mode that falls back to always using native windows,
+   triggered by the GDK_NATIVE_WINDOWS environment variable
+
+* Bugs fixed:
+ 589367 gedit crashed with SIGSEGV in IA__g_list_last()
+ 478519 GtkTooltip segfaults on NULL gdk-display-current-tooltip.
+ 592461 preserve errno and use g_strerror
+ 592403 crash when close the second terminal...
+ 591549 Default printer in a network
+ 526149 GtkCellRendererAccel editing conflicts with mnemonics
+ 528283 Problems when using PageUp & PageDown to navigate Playlists pane
+
+* Updated translations:
+ Bengali
+ Brazilian Portuguese
+ Breton
+ Bulgarian
+ Catalan
+ Estonian
+ Galician
+ Irish
+ Korean
+ Norwegian bokmål
+ Portuguese
+ Punjabi
+ Spanish
+ Swedish
+ Thai
+
+
+Overview of Changes from GTK+ 2.17.7 to 2.17.8
+==============================================
+
+* Client-side windows:
+ - various fixes to expose handling
+ - fix memory leaks
+
+* Minor API additions:
+ - New setter as part of the GSEAL effort: gtk_widget_set_allocation
+
+* Bugs fixed:
+ 585211 Add accessor function for GtkWidget->allocation
+ 588437 gtk 2.17.3 causes dragging in firefox bookmarks sidebar t...
+ 589367 gedit crashed with SIGSEGV in IA__g_list_last()
+ 589877 Client side windows leak gdk regions
+ 590959 Set child_has_focus flag properly
+ 591432 There is incomplete information on the returning value of...
+ 591434 firefox-3.5 crashed with SIGSEGV in _gdk_window_process_u...
+ 591526 Accelerator keys with <super> modifier also triggered by ...
+ 591751 bad memory access with duplicated id
+ 591998 Support silent build rules with automake 1.11
+ 592003 Shift+click should always modify selection
+
+* Updated translations:
+ Brazilian
+ Bulgarian
+ Irish
+ Swedish
+
+
 Overview of Changes from GTK+ 2.17.6 to 2.17.7
 ==============================================

@@ -37,6 +37,18 @@ Release notes for 2.18
 * JPEG2000 support is no longer enabled by default. It must be
  explicitly turned on, by passing --with-libjasper to configure.

+* GDK has been reworked to implement 'client-side windows'. This offers
+  exciting new possibilities, such as transformed, offscreen rendering,
+  but it breaks some long-standing assumptions that applications may
+  have about GDK windows. Setting the environment variable
+  GDK_NATIVE_WINDOWS makes GDK create a native X11 window for each
+  GDK window, which might make problematic applications work better.
+
+* GTK+ calls signal (SIGPIPE, SIG_IGN) during initialization, to ignore
+  SIGPIPE signals, since these are almost never wanted in graphical
+  applications. If you do need to handle SIGPIPE for some reason, reset
+  the handler after gtk_init(), but notice that other libraries (e.g.
+  libdbus or gvfs) might do similar things.

 Release notes for 2.16
 ======================
@@ -1,117 +1,184 @@
-The Win32 backend in GTK+ is not as stable or correct as the X11 one.
-
-For prebuilt runtime and developer packages see
-http://ftp.gnome.org/pub/gnome/binaries/win32/
-
-Building GTK+ on Win32
-======================
-
-First you obviously need developer packages for the compile-time
-dependencies: Pango, atk, glib, gettext-runtime, libiconv, libpng,
-zlib, libtiff at least. See
-http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies .
-
-After installing the dependencies, there are two ways to build GTK+
-for win32.
-
-1) GNU tools, ./configure && make install
-----------------------------------------
-
-This requires you have mingw and MSYS.
-
-Use the configure script, and the resulting Makefiles (which use
-libtool and gcc to do the compilation). I use this myself, but it can
-be hard to setup correctly.
-
-The full script I run to build GTK+ 2.10 unpacked from a source
-distribution is as below. This is from bulding GTK+ 2.10.9, slightly
-edited to make it match this 2.11 development branch. Actually I don't
-use any script like this to build the development branch, as I don't
-distribute any binaries from development branches.
-
-MOD=gtk+
-VER=2.10.9
-THIS=$MOD-$VER
-HEX=`echo $THIS | md5sum | cut -d' ' -f1`
-TARGET=c:/devel/target/$HEX
-DEPS="`/devel/src/tml/latest.sh glib atk cairo pango`"
-sed -e 's/need_relink=yes/need_relink=no # no way --tml/' <ltmain.sh >ltmain.temp && mv ltmain.temp ltmain.sh
-usedev
-usemsvs6
-MY_PKG_CONFIG_PATH=""
-for D in $DEPS; do
-    PATH=/devel/dist/$D/bin:$PATH
-    MY_PKG_CONFIG_PATH=/devel/dist/$D/lib/pkgconfig:$MY_PKG_CONFIG_PATH
-done
-PKG_CONFIG_PATH=$MY_PKG_CONFIG_PATH:$PKG_CONFIG_PATH CC='gcc -mtune=pentium3 -mthreads' CPPFLAGS='-I/opt/gnu/include -I/opt/gnuwin32/include -I/opt/misc/include' LDFLAGS='-L/opt/gnu/lib -L/opt/gnuwin32/lib -L/opt/misc/lib -Wl,--enable-auto-image-base' LIBS=-lintl CFLAGS=-O2 ./configure --with-gdktarget=win32 --enable-debug=yes --disable-gtk-doc --disable-static --prefix=$TARGET &&
-libtoolcacheize &&
-unset MY_PKG_CONFIG_PATH &&
-PATH=/devel/target/$HEX/bin:.libs:$PATH make install &&
-(cd $TARGET/bin; strip --strip-unneeded *.dll *.exe) &&
-(cd $TARGET/lib/gtk-2.0/2.10.0/loaders; strip --strip-unneeded *.dll) &&
-(cd $TARGET/lib/gtk-2.0/2.10.0/immodules; strip --strip-unneeded *.dll) &&
-(cd $TARGET/lib/gtk-2.0/2.10.0/engines; strip --strip-unneeded *.dll) &&
-PATH=$TARGET/bin:$PATH gdk-pixbuf-query-loaders >$TARGET/etc/gtk-2.0/gdk-pixbuf.loaders &&
-grep -v -E 'Automatically generated|Created by|LoaderDir =' <$TARGET/etc/gtk-2.0/gdk-pixbuf.loaders >$TARGET/etc/gtk-2.0/gdk-pixbuf.loaders.temp &&
-mv $TARGET/etc/gtk-2.0/gdk-pixbuf.loaders.temp $TARGET/etc/gtk-2.0/gdk-pixbuf.loaders &&
-grep -v -E 'Automatically generated|Created by|ModulesPath =' <$TARGET/etc/gtk-2.0/gtk.immodules >$TARGET/etc/gtk-2.0/gtk.immodules.temp &&
-mv $TARGET/etc/gtk-2.0/gtk.immodules.temp $TARGET/etc/gtk-2.0/gtk.immodules &&
-./gtk-zip.sh &&
-(cd /devel/src/tml && zip /tmp/$MOD-dev-$VER.zip make/$THIS.make) &&
-manifestify /tmp/$MOD*-$VER.zip
-
-You should not just copy the above blindly. There are some things in
-the script that are very specific to *my* build setup on *my* current
-machine. For instance the "latest.sh" script, the "usedev" and
-"usemsvs6" shell functions, the /devel/dist folder. The above script
-is really just meant for reference, to give an idea. You really need
-to understand what things like PKG_CONFIG_PATH are and set them up
-properly after installing the dependencies before building GTK+.
-
-As you see above, after running configure, one can just say "make
-install", like on Unix. A post-build fix is needed, running
-gdk-pixbuf-query-loaders once more to get a correct gdk-pixbuf.loaders
-file.
-
-2) Microsoft's tools
--------------------
-
-Use the Microsoft compiler, cl and Make, nmake. Say nmake -f
-makefile.msc in gdk and gtk. Be prepared to manually edit various
-makefile.msc files, and the makefile snippets in build/win32.
-
-Alternative 1 also generates Microsoft import libraries (.lib), if you
-have lib.exe available. It might also work for cross-compilation from
-Unix.
-
-I use method 1 myself. Hans Breuer has been taking care of the MSVC
-makefiles. At times, we disagree a bit about various issues, and for
-instance the makefile.msc files might not produce identically named
-DLLs and import libraries as the "autoconfiscated" makefiles and
-libtool do. If this bothers you, you will have to fix the makefiles.
-
-Using GTK+ on Win32
-===================
-
-To use GTK+ on Win32, you also need either one of the above mentioned
-compilers. Other compilers might work, but don't count on it. Look for
-prebuilt developer packages (DLLs, import libraries, headers) on the
-above website.
-
-Multi-threaded use of GTK+ on Win32
-===================================
-
-Multi-threaded GTK+ programs might work on Windows in special simple
-cases, but not in general. Sorry. If you have all GTK+ and GDK calls
-in the same thread, it might work. Otherwise, probably not at
-all. Possible ways to fix this are being investigated.
-
-Wintab
-======
-
-The tablet support uses the Wintab API. The Wintab development kit is
-no longer required. The wintab.h header file is bundled with GTK+
-sources. Unfortunately it seems that only Wacom tablets come with
-support for the Wintab API nowadays.
-
--Tor Lillqvist <tml@iki.fi>, <tml@novell.com>
+The Win32 backend in GTK+ is not as stable or correct as the X11 one.
+
+For prebuilt runtime and developer packages see
+http://ftp.gnome.org/pub/gnome/binaries/win32/
+
+Building GTK+ on Win32
+======================
+
+First you obviously need developer packages for the compile-time
+dependencies: Pango, atk, glib, gettext-runtime, libiconv, libpng,
+zlib, libtiff at least. See
+http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies .
+
+After installing the dependencies, there are two ways to build GTK+
+for win32.
+
+1) GNU tools, ./configure && make install
+-----------------------------------------
+
+This requires you have mingw and MSYS.
+
+Use the configure script, and the resulting Makefiles (which use
+libtool and gcc to do the compilation). I use this myself, but it can
+be hard to setup correctly.
+
+The full script I run to build GTK+ 2.16 unpacked from a source
+distribution is as below. This is from bulding GTK+ 2.16.5. I don't
+use any script like this to build the development branch, as I don't
+distribute any binaries from development branches.
+
+# This is a shell script that calls functions and scripts from
+# tml@iki.fi's personal work envíronment. It is not expected to be
+# usable unmodified by others, and is included only for reference.
+
+MOD=gtk+
+VER=2.16.5
+REV=1
+ARCH=win32
+
+THIS=${MOD}_${VER}-${REV}_${ARCH}
+
+RUNZIP=${MOD}_${VER}-${REV}_${ARCH}.zip
+DEVZIP=${MOD}-dev_${VER}-${REV}_${ARCH}.zip
+
+HEX=`echo $THIS | md5sum | cut -d' ' -f1`
+TARGET=c:/devel/target/$HEX
+
+usedev
+usemsvs6
+
+(
+
+set -x
+
+DEPS=`latest --arch=${ARCH} glib atk cairo pango libpng zlib libtiff jpeg`
+PROXY_LIBINTL=`latest --arch=${ARCH} proxy-libintl`
+
+PKG_CONFIG_PATH=
+for D in $DEPS; do
+    PATH=/devel/dist/${ARCH}/$D/bin:$PATH
+    [ -d /devel/dist/${ARCH}/$D/lib/pkgconfig ] && PKG_CONFIG_PATH=/devel/dist/${ARCH}/$D/lib/pkgconfig:$PKG_CONFIG_PATH
+done
+
+LIBPNG=`latest --arch=${ARCH} libpng`
+ZLIB=`latest --arch=${ARCH} zlib`
+LIBTIFF=`latest --arch=${ARCH} libtiff`
+JPEG=`latest --arch=${ARCH} jpeg`
+
+patch -p0 <<'EOF'
+EOF
+
+lt_cv_deplibs_check_method='pass_all' \
+CC='gcc -mtune=pentium3 -mthreads' \
+CPPFLAGS="-I/devel/dist/${ARCH}/${LIBPNG}/include \
+-I/devel/dist/${ARCH}/${ZLIB}/include \
+-I/devel/dist/${ARCH}/${LIBTIFF}/include \
+-I/devel/dist/${ARCH}/${JPEG}/include \
+-I/devel/dist/${ARCH}/${PROXY_LIBINTL}/include" \
+LDFLAGS="-L/devel/dist/${ARCH}/${LIBPNG}/lib \
+-L/devel/dist/${ARCH}/${ZLIB}/lib \
+-L/devel/dist/${ARCH}/${LIBTIFF}/lib \
+-L/devel/dist/${ARCH}/${JPEG}/lib \
+-L/devel/dist/${ARCH}/${PROXY_LIBINTL}/lib -Wl,--exclude-libs=libintl.a \
+-Wl,--enable-auto-image-base" \
+LIBS=-lintl \
+CFLAGS=-O2 \
+./configure \
+--with-gdktarget=win32 \
+--disable-gdiplus \
+--with-included-immodules \
+--without-libjasper \
+--enable-debug=yes \
+--enable-explicit-deps=no \
+--disable-gtk-doc \
+--disable-static \
+--prefix=$TARGET &&
+
+libtoolcacheize &&
+rm gtk/gtk.def &&
+(PATH="$PWD/gdk-pixbuf/.libs:/devel/target/$HEX/bin:$PATH" make -j3 install || (rm .libtool-cache* && PATH="/devel/target/$HEX/bin:$PATH" make -j3 install)) &&
+
+PATH="/devel/target/$HEX/bin:$PATH" gdk-pixbuf-query-loaders >/devel/target/$HEX/etc/gtk-2.0/gdk-pixbuf.loaders &&
+
+grep -v -E 'Automatically generated|Created by|LoaderDir =' <$TARGET/etc/gtk-2.0/gdk-pixbuf.loaders >$TARGET/etc/gtk-2.0/gdk-pixbuf.loaders.temp &&
+    mv $TARGET/etc/gtk-2.0/gdk-pixbuf.loaders.temp $TARGET/etc/gtk-2.0/gdk-pixbuf.loaders &&
+grep -v -E 'Automatically generated|Created by|ModulesPath =' <$TARGET/etc/gtk-2.0/gtk.immodules >$TARGET/etc/gtk-2.0/gtk.immodules.temp &&
+    mv $TARGET/etc/gtk-2.0/gtk.immodules.temp $TARGET/etc/gtk-2.0/gtk.immodules &&
+
+./gtk-zip.sh &&
+
+mv /tmp/${MOD}-${VER}.zip /tmp/$RUNZIP &&
+mv /tmp/${MOD}-dev-${VER}.zip /tmp/$DEVZIP
+
+) 2>&1 | tee /devel/src/tml/packaging/$THIS.log
+
+(cd /devel && zip /tmp/$DEVZIP src/tml/packaging/$THIS.{sh,log}) &&
+manifestify /tmp/$RUNZIP /tmp/$DEVZIP
+
+You should not just copy the above blindly. There are some things in
+the script that are very specific to *my* build setup on *my* current
+machine. For instance the "latest" command, the "usedev" and
+"usemsvs6" shell functions, the /devel/dist folder. The above script
+is really just meant for reference, to give an idea. You really need
+to understand what things like PKG_CONFIG_PATH are and set them up
+properly after installing the dependencies before building GTK+.
+
+As you see above, after running configure, one can just say "make
+install", like on Unix. A post-build fix is needed, running
+gdk-pixbuf-query-loaders once more to get a correct gdk-pixbuf.loaders
+file.
+
+For a 64-bit build you need to remove the gtk/gtk.def file and let it
+be regenerated by the makefilery. This is because the 64-bit GTK dll
+has a slightly different list of exported function names. This is on
+purpose and not a bug. The API is the same at the source level, and
+the same #defines of some function names to actually have a _utf8
+suffix is used (just to keep the header simpler). But the
+corresponding non-suffixed function to maintain ABI stability are not
+needed in the 64-bit case (because there are no older EXEs around that
+would require such for ABI stability).
+
+
+2) Microsoft's tools
+--------------------
+
+Use the Microsoft compiler, cl and Make, nmake. Say nmake -f
+makefile.msc in gdk and gtk. Be prepared to manually edit various
+makefile.msc files, and the makefile snippets in build/win32.
+
+Alternative 1 also generates Microsoft import libraries (.lib), if you
+have lib.exe available. It might also work for cross-compilation from
+Unix.
+
+I use method 1 myself. Hans Breuer has been taking care of the MSVC
+makefiles. At times, we disagree a bit about various issues, and for
+instance the makefile.msc files might not produce identically named
+DLLs and import libraries as the "autoconfiscated" makefiles and
+libtool do. If this bothers you, you will have to fix the makefiles.
+
+Using GTK+ on Win32
+===================
+
+To use GTK+ on Win32, you also need either one of the above mentioned
+compilers. Other compilers might work, but don't count on it. Look for
+prebuilt developer packages (DLLs, import libraries, headers) on the
+above website.
+
+Multi-threaded use of GTK+ on Win32
+===================================
+
+Multi-threaded GTK+ programs might work on Windows in special simple
+cases, but not in general. Sorry. If you have all GTK+ and GDK calls
+in the same thread, it might work. Otherwise, probably not at
+all. Possible ways to fix this are being investigated.
+
+Wintab
+======
+
+The tablet support uses the Wintab API. The Wintab development kit is
+no longer required. The wintab.h header file is bundled with GTK+
+sources. Unfortunately it seems that only Wacom tablets come with
+support for the Wintab API nowadays.
+
+--Tor Lillqvist <tml@iki.fi>, <tml@novell.com>
@@ -14,7 +14,10 @@ DIE=0

 have_libtool=false
 if libtoolize --version < /dev/null > /dev/null 2>&1 ; then
-	libtool_version=`libtoolize --version | sed 's/^[^0-9]*\([0-9.][0-9.]*\).*/\1/'`
+	libtool_version=`libtoolize --version |
+			 head -1 |
+			 sed -e 's/^\(.*\)([^)]*)\(.*\)$/\1\2/g' \
+			     -e 's/^[^0-9]*\([0-9.][0-9.]*\).*/\1/'`
 	case $libtool_version in
 	    1.4*|1.5*|2.2*)
 		have_libtool=true
@@ -45,16 +48,24 @@ fi
 	DIE=1
 }

-if automake-1.7 --version < /dev/null > /dev/null 2>&1 ; then
+if automake-1.11 --version < /dev/null > /dev/null 2>&1 ; then
+    AUTOMAKE=automake-1.11
+    ACLOCAL=aclocal-1.11
+else if automake-1.10 --version < /dev/null > /dev/null 2>&1 ; then
+    AUTOMAKE=automake-1.10
+    ACLOCAL=aclocal-1.10
+else if 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.x installed to compile $PROJECT."
+	echo "You must have automake 1.7.x, 1,10.x or 1.11.x installed to compile $PROJECT."
 	echo "Install the appropriate package for your distribution,"
 	echo "or get the source tarball at http://ftp.gnu.org/gnu/automake/"
 	DIE=1
 fi
+fi
+fi

 if test "$DIE" -eq 1; then
 	exit 1
@@ -11,9 +11,9 @@ AC_PREREQ(2.54)
 # set GTK_BINARY_AGE and GTK_INTERFACE_AGE to 0.

 m4_define([gtk_major_version], [2])
-m4_define([gtk_minor_version], [17])
-m4_define([gtk_micro_version], [7])
-m4_define([gtk_interface_age], [0])
+m4_define([gtk_minor_version], [18])
+m4_define([gtk_micro_version], [2])
+m4_define([gtk_interface_age], [2])
 m4_define([gtk_binary_age],
          [m4_eval(100 * gtk_minor_version + gtk_micro_version)])
 m4_define([gtk_version],
@@ -49,6 +49,11 @@ cflags_set=${CFLAGS+set}
 AM_INIT_AUTOMAKE(no-define)
 AM_CONFIG_HEADER(config.h)

+# Support silent build rules, requires at least automake-1.11. Enable
+# by either passing --enable-silent-rules to configure or passing V=0
+# to make
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([no])])
+
 #
 # For each of the libraries we build, we define the following
 
@@ -302,6 +307,7 @@ AM_SANITY_CHECK
 # Checks for programs.
 AC_ISC_POSIX
 AM_PROG_CC_STDC
+AM_PROG_CC_C_O
 AC_PROG_INSTALL
 AC_PROG_MAKE_SET

@@ -1836,10 +1842,19 @@ AC_ARG_ENABLE(cups,
                              [disable cups print backend])],,
              [enable_cups=auto])

-if test "x$enable_cups" = "xauto"
-then
+if test "x$enable_cups" = "xno"; then
+  AM_CONDITIONAL(HAVE_CUPS, false)
+else
  AC_PATH_PROG(CUPS_CONFIG, cups-config, no)
-  if test "x$CUPS_CONFIG" != "xno"; then
+  if test "x$CUPS_CONFIG" = "xno"; then
+    if test "x$enable_cups" = "xauto"; then
+      AM_CONDITIONAL(HAVE_CUPS, false)
+    else
+      AC_MSG_ERROR([
+*** cups not found.
+])
+    fi
+  else
    CUPS_CFLAGS=`$CUPS_CONFIG --cflags | sed 's/-O[0-9]*//' | sed 's/-m[^\t]*//g'`
    CUPS_LIBS=`$CUPS_CONFIG --libs`

@@ -1859,26 +1874,24 @@ then
    AC_SUBST(CUPS_LIBS)

    AC_CHECK_HEADER(cups/cups.h,,AC_MSG_ERROR([[*** Sorry, cups-config present but cups/cups.h missing.]]))
+
+    AM_CONDITIONAL(HAVE_CUPS, true)
+
+    gtk_save_cflags="$CFLAGS"
+    CFLAGS="$CUPS_CFLAGS"
+    AC_TRY_COMPILE([#include <cups/http.h>],
+                   [http_t http; char *s = http.authstring;],
+                   [AC_DEFINE(HAVE_HTTP_AUTHSTRING, [],
+                              [Define if cups http_t authstring field is accessible])],)
+    CFLAGS="$gtk_save_cflags"
+
+    AC_SUBST(HAVE_HTTP_AUTHSTRING)
+
+    gtk_save_libs="$LIBS"
+    LIBS="$CUPS_LIBS"
+    AC_CHECK_FUNCS(httpGetAuthString)
+    LIBS="$gtk_save_libs"
  fi
-  AM_CONDITIONAL(HAVE_CUPS, test "x$CUPS_CONFIG" != "xno")
-
-  gtk_save_cflags="$CFLAGS"
-  CFLAGS="$CUPS_CFLAGS"
-  AC_TRY_COMPILE([#include <cups/http.h>],
-                 [http_t http; char *s = http.authstring;],
-                 [AC_DEFINE(HAVE_HTTP_AUTHSTRING, [],
-                            [Define if cups http_t authstring field is accessible])],)
-  CFLAGS="$gtk_save_cflags"
-
-  AC_SUBST(HAVE_HTTP_AUTHSTRING)
-
-  gtk_save_libs="$LIBS"
-  LIBS="$CUPS_LIBS"
-  AC_CHECK_FUNCS(httpGetAuthString)
-  LIBS="$gtk_save_libs"
-
-else
-  AM_CONDITIONAL(HAVE_CUPS, false)
 fi

 # Checks to see if we should compile with PAPI backend for GTK+
@@ -1889,19 +1902,23 @@ AC_ARG_ENABLE(papi,
                              [disable papi print backend])],,
             [enable_papi=auto])

-if test "x$enable_papi" = "xauto"
-then
+if test "x$enable_papi" = "xno"; then
+  AM_CONDITIONAL(HAVE_PAPI, false)
+else
  AC_MSG_CHECKING(libpapi)
  AC_CHECK_LIB(papi, papiServiceCreate, have_papi=yes, have_papi=no)
  if test $have_papi = yes; then
    AC_DEFINE([HAVE_PAPI], [], [Define to 1 if libpapi available])
  fi
  AM_CONDITIONAL(HAVE_PAPI, test $have_papi = yes)
-else
-  AM_CONDITIONAL(HAVE_PAPI, false)
+  if test "x$enable_papi" = "xyes" -a "x$have_papi" = "xno"; then
+    AC_MSG_ERROR([
+*** papi not found.
+])
+  fi
 fi

-AM_CONDITIONAL(HAVE_PAPI_CUPS, test $have_papi = yes && test "x$CUPS_CONFIG" != "xno")
+AM_CONDITIONAL(HAVE_PAPI_CUPS, test "x$have_papi" = "xyes" -a "x$CUPS_CONFIG" != "xno")

 gtk_save_cppflags="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS $GTK_DEP_CFLAGS $GDK_DEP_CFLAGS"
@@ -28,6 +28,8 @@ demos =						\
 	links.c					\
 	list_store.c				\
 	menus.c					\
+	offscreen_window.c			\
+	offscreen_window2.c			\
 	panes.c					\
 	pickers.c				\
 	pixbufs.c				\
@@ -203,6 +203,10 @@ do_clipboard (GtkWidget *do_widget)
      GtkClipboard *clipboard;

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+                             gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Clipboard demo");
+
      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);

@@ -43,10 +43,11 @@ activate_link (GtkWidget   *label,
  return FALSE;
 }

+static GtkWidget *window = NULL;
+
 GtkWidget *
 do_links (GtkWidget *do_widget)
 {
-  static GtkWidget *window = NULL;
  GtkWidget *label;

  if (!window)
@@ -54,11 +55,10 @@ do_links (GtkWidget *do_widget)
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_screen (GTK_WINDOW (window),
 			     gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Links");
      gtk_container_set_border_width (GTK_CONTAINER (window), 12);
      g_signal_connect (window, "destroy",
-			G_CALLBACK(gtk_widget_destroyed), &window);
-      g_signal_connect (window, "delete-event",
-			G_CALLBACK (gtk_true), NULL);
+			G_CALLBACK (gtk_widget_destroyed), &window);

      label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\""
                             "title=\"plain text\">text</a> may be marked up\n"
@@ -2,10 +2,10 @@
 *
 * There are several widgets involved in displaying menus. The
 * GtkMenuBar widget is a menu bar, which normally appears horizontally
- * at the top of an application, but can also be layed out vertically. 
- * The GtkMenu widget is the actual menu that pops up. Both GtkMenuBar 
- * and GtkMenu are subclasses of GtkMenuShell; a GtkMenuShell contains 
- * menu items (GtkMenuItem). Each menu item contains text and/or images 
+ * at the top of an application, but can also be layed out vertically.
+ * The GtkMenu widget is the actual menu that pops up. Both GtkMenuBar
+ * and GtkMenu are subclasses of GtkMenuShell; a GtkMenuShell contains
+ * menu items (GtkMenuItem). Each menu item contains text and/or images
 * and can be selected by the user.
 *
 * There are several kinds of menu item, including plain GtkMenuItem,
@@ -22,7 +22,6 @@
 * GtkUIManager provides a higher-level interface for creating menu bars
 * and menus; while you can construct menus manually, most people don't
 * do that. There's a separate demo for GtkUIManager.
- * 
 */

 #include <gtk/gtk.h>
@@ -118,37 +117,35 @@ change_orientation (GtkWidget *button,
    }
 }

+static GtkWidget *window = NULL;
+
 GtkWidget *
 do_menus (GtkWidget *do_widget)
 {
-  static GtkWidget *window = NULL;
  GtkWidget *box;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
-  
+
  if (!window)
    {
      GtkWidget *menubar;
      GtkWidget *menu;
      GtkWidget *menuitem;
      GtkAccelGroup *accel_group;
-      
+
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_screen (GTK_WINDOW (window),
 			     gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Menus");
      g_signal_connect (window, "destroy",
 			G_CALLBACK(gtk_widget_destroyed), &window);
-      g_signal_connect (window, "delete-event",
-			G_CALLBACK (gtk_true), NULL);
-      
+
      accel_group = gtk_accel_group_new ();
      gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);

-      gtk_window_set_title (GTK_WINDOW (window), "menus");
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
-      
-            
+
      box = gtk_hbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box);
      gtk_widget_show (box);
@@ -156,18 +153,18 @@ do_menus (GtkWidget *do_widget)
      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (box), box1);
      gtk_widget_show (box1);
-      
+
      menubar = gtk_menu_bar_new ();
      gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
      gtk_widget_show (menubar);
-      
+
      menu = create_menu (2, TRUE);
-      
+
      menuitem = gtk_menu_item_new_with_label ("test\nline2");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
-      
+
      menuitem = gtk_menu_item_new_with_label ("foo");
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
@@ -178,7 +175,7 @@ do_menus (GtkWidget *do_widget)
      gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
      gtk_widget_show (menuitem);
-      
+
      box2 = gtk_vbox_new (FALSE, 10);
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
@@ -0,0 +1,579 @@
+/* Offscreen windows/Rotated button
+ *
+ * Offscreen windows can be used to transform parts of a widget
+ * hierarchy. Note that the rotated button is fully functional.
+ */
+#include <math.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_ROTATED_BIN              (gtk_rotated_bin_get_type ())
+#define GTK_ROTATED_BIN(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBin))
+#define GTK_ROTATED_BIN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
+#define GTK_IS_ROTATED_BIN(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ROTATED_BIN))
+#define GTK_IS_ROTATED_BIN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ROTATED_BIN))
+#define GTK_ROTATED_BIN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
+
+typedef struct _GtkRotatedBin   GtkRotatedBin;
+typedef struct _GtkRotatedBinClass  GtkRotatedBinClass;
+
+struct _GtkRotatedBin
+{
+  GtkContainer container;
+
+  GtkWidget *child;
+  GdkWindow *offscreen_window;
+  gdouble angle;
+};
+
+struct _GtkRotatedBinClass
+{
+  GtkContainerClass parent_class;
+};
+
+GType      gtk_rotated_bin_get_type  (void) G_GNUC_CONST;
+GtkWidget* gtk_rotated_bin_new       (void);
+void       gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
+                                      gdouble        angle);
+
+/*** implementation ***/
+
+static void     gtk_rotated_bin_realize       (GtkWidget       *widget);
+static void     gtk_rotated_bin_unrealize     (GtkWidget       *widget);
+static void     gtk_rotated_bin_size_request  (GtkWidget       *widget,
+                                               GtkRequisition  *requisition);
+static void     gtk_rotated_bin_size_allocate (GtkWidget       *widget,
+                                               GtkAllocation   *allocation);
+static gboolean gtk_rotated_bin_damage        (GtkWidget       *widget,
+                                               GdkEventExpose  *event);
+static gboolean gtk_rotated_bin_expose        (GtkWidget       *widget,
+                                               GdkEventExpose  *offscreen);
+
+static void     gtk_rotated_bin_add           (GtkContainer    *container,
+                                               GtkWidget       *child);
+static void     gtk_rotated_bin_remove        (GtkContainer    *container,
+                                               GtkWidget       *widget);
+static void     gtk_rotated_bin_forall        (GtkContainer    *container,
+                                               gboolean         include_internals,
+                                               GtkCallback      callback,
+                                               gpointer         callback_data);
+static GType    gtk_rotated_bin_child_type    (GtkContainer    *container);
+
+G_DEFINE_TYPE (GtkRotatedBin, gtk_rotated_bin, GTK_TYPE_CONTAINER);
+
+static void
+to_child (GtkRotatedBin *bin,
+          double         widget_x,
+          double         widget_y,
+          double        *x_out,
+          double        *y_out)
+{
+  GtkAllocation child_area;
+  double x, y, xr, yr;
+  double c, s;
+  double w, h;
+
+  s = sin (bin->angle);
+  c = cos (bin->angle);
+  child_area = bin->child->allocation;
+
+  w = c * child_area.width + s * child_area.height;
+  h = s * child_area.width + c * child_area.height;
+
+  x = widget_x;
+  y = widget_y;
+
+  x -= (w - child_area.width) / 2;
+  y -= (h - child_area.height) / 2;
+
+  x -= child_area.width / 2;
+  y -= child_area.height / 2;
+
+  xr = x * c + y * s;
+  yr = y * c - x * s;
+  x = xr;
+  y = yr;
+
+  x += child_area.width / 2;
+  y += child_area.height / 2;
+
+  *x_out = x;
+  *y_out = y;
+}
+
+static void
+to_parent (GtkRotatedBin *bin,
+           double         offscreen_x,
+           double         offscreen_y,
+           double        *x_out,
+           double        *y_out)
+{
+  GtkAllocation child_area;
+  double x, y, xr, yr;
+  double c, s;
+  double w, h;
+
+  s = sin (bin->angle);
+  c = cos (bin->angle);
+  child_area = bin->child->allocation;
+
+  w = c * child_area.width + s * child_area.height;
+  h = s * child_area.width + c * child_area.height;
+
+  x = offscreen_x;
+  y = offscreen_y;
+
+  x -= child_area.width / 2;
+  y -= child_area.height / 2;
+
+  xr = x * c - y * s;
+  yr = x * s + y * c;
+  x = xr;
+  y = yr;
+
+  x += child_area.width / 2;
+  y += child_area.height / 2;
+
+  x -= (w - child_area.width) / 2;
+  y -= (h - child_area.height) / 2;
+
+  *x_out = x;
+  *y_out = y;
+}
+
+static void
+gtk_rotated_bin_class_init (GtkRotatedBinClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
+
+  widget_class->realize = gtk_rotated_bin_realize;
+  widget_class->unrealize = gtk_rotated_bin_unrealize;
+  widget_class->size_request = gtk_rotated_bin_size_request;
+  widget_class->size_allocate = gtk_rotated_bin_size_allocate;
+  widget_class->expose_event = gtk_rotated_bin_expose;
+
+  g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
+                                   GTK_TYPE_ROTATED_BIN,
+                                   g_cclosure_new (G_CALLBACK (gtk_rotated_bin_damage),
+                                                   NULL, NULL));
+
+  container_class->add = gtk_rotated_bin_add;
+  container_class->remove = gtk_rotated_bin_remove;
+  container_class->forall = gtk_rotated_bin_forall;
+  container_class->child_type = gtk_rotated_bin_child_type;
+}
+
+static void
+gtk_rotated_bin_init (GtkRotatedBin *bin)
+{
+  GTK_WIDGET_UNSET_FLAGS (bin, GTK_NO_WINDOW);
+}
+
+GtkWidget *
+gtk_rotated_bin_new (void)
+{
+  return g_object_new (GTK_TYPE_ROTATED_BIN, NULL);
+}
+
+static GdkWindow *
+pick_offscreen_child (GdkWindow     *offscreen_window,
+                      double         widget_x,
+                      double         widget_y,
+                      GtkRotatedBin *bin)
+{
+ GtkAllocation child_area;
+ double x, y;
+
+ if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      to_child (bin, widget_x, widget_y, &x, &y);
+
+      child_area = bin->child->allocation;
+
+      if (x >= 0 && x < child_area.width &&
+          y >= 0 && y < child_area.height)
+        return bin->offscreen_window;
+    }
+
+  return NULL;
+}
+
+static void
+offscreen_window_to_parent (GdkWindow     *offscreen_window,
+                            double         offscreen_x,
+                            double         offscreen_y,
+                            double        *parent_x,
+                            double        *parent_y,
+                            GtkRotatedBin *bin)
+{
+  to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
+}
+
+static void
+offscreen_window_from_parent (GdkWindow     *window,
+                              double         parent_x,
+                              double         parent_y,
+                              double        *offscreen_x,
+                              double        *offscreen_y,
+                              GtkRotatedBin *bin)
+{
+  to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
+}
+
+static void
+gtk_rotated_bin_realize (GtkWidget *widget)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+  gint border_width;
+  GtkRequisition child_requisition;
+
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+
+  border_width = GTK_CONTAINER (widget)->border_width;
+
+  attributes.x = widget->allocation.x + border_width;
+  attributes.y = widget->allocation.y + border_width;
+  attributes.width = widget->allocation.width - 2 * border_width;
+  attributes.height = widget->allocation.height - 2 * border_width;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.event_mask = gtk_widget_get_events (widget)
+                        | GDK_EXPOSURE_MASK
+                        | GDK_POINTER_MOTION_MASK
+                        | GDK_BUTTON_PRESS_MASK
+                        | GDK_BUTTON_RELEASE_MASK
+                        | GDK_SCROLL_MASK
+                        | GDK_ENTER_NOTIFY_MASK
+                        | GDK_LEAVE_NOTIFY_MASK;
+
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (widget);
+  attributes.wclass = GDK_INPUT_OUTPUT;
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+                                   &attributes, attributes_mask);
+  gdk_window_set_user_data (widget->window, widget);
+  g_signal_connect (widget->window, "pick-embedded-child",
+                    G_CALLBACK (pick_offscreen_child), bin);
+
+  attributes.window_type = GDK_WINDOW_OFFSCREEN;
+
+  child_requisition.width = child_requisition.height = 0;
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      attributes.width = bin->child->allocation.width;
+      attributes.height = bin->child->allocation.height;
+    }
+  bin->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
+                                          &attributes, attributes_mask);
+  gdk_window_set_user_data (bin->offscreen_window, widget);
+  if (bin->child)
+    gtk_widget_set_parent_window (bin->child, bin->offscreen_window);
+  gdk_offscreen_window_set_embedder (bin->offscreen_window, widget->window);
+  g_signal_connect (bin->offscreen_window, "to-embedder",
+                    G_CALLBACK (offscreen_window_to_parent), bin);
+  g_signal_connect (bin->offscreen_window, "from-embedder",
+                    G_CALLBACK (offscreen_window_from_parent), bin);
+
+  widget->style = gtk_style_attach (widget->style, widget->window);
+
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+  gtk_style_set_background (widget->style, bin->offscreen_window, GTK_STATE_NORMAL);
+  gdk_window_show (bin->offscreen_window);
+}
+
+static void
+gtk_rotated_bin_unrealize (GtkWidget *widget)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
+
+  gdk_window_set_user_data (bin->offscreen_window, NULL);
+  gdk_window_destroy (bin->offscreen_window);
+  bin->offscreen_window = NULL;
+
+  GTK_WIDGET_CLASS (gtk_rotated_bin_parent_class)->unrealize (widget);
+}
+
+static GType
+gtk_rotated_bin_child_type (GtkContainer *container)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
+
+  if (bin->child)
+    return G_TYPE_NONE;
+
+  return GTK_TYPE_WIDGET;
+}
+
+static void
+gtk_rotated_bin_add (GtkContainer *container,
+                     GtkWidget    *widget)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
+
+  if (!bin->child)
+    {
+      gtk_widget_set_parent_window (widget, bin->offscreen_window);
+      gtk_widget_set_parent (widget, GTK_WIDGET (bin));
+      bin->child = widget;
+    }
+  else
+    g_warning ("GtkRotatedBin cannot have more than one child\n");
+}
+
+static void
+gtk_rotated_bin_remove (GtkContainer *container,
+                        GtkWidget    *widget)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
+  gboolean was_visible;
+
+  was_visible = GTK_WIDGET_VISIBLE (widget);
+
+  if (bin->child == widget)
+    {
+      gtk_widget_unparent (widget);
+
+      bin->child = NULL;
+
+      if (was_visible && GTK_WIDGET_VISIBLE (container))
+        gtk_widget_queue_resize (GTK_WIDGET (container));
+    }
+}
+
+static void
+gtk_rotated_bin_forall (GtkContainer *container,
+                        gboolean      include_internals,
+                        GtkCallback   callback,
+                        gpointer      callback_data)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
+
+  g_return_if_fail (callback != NULL);
+
+  if (bin->child)
+    (*callback) (bin->child, callback_data);
+}
+
+void
+gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
+                           gdouble        angle)
+{
+  g_return_if_fail (GTK_IS_ROTATED_BIN (bin));
+
+  bin->angle = angle;
+  gtk_widget_queue_resize (GTK_WIDGET (bin));
+
+  gdk_window_geometry_changed (bin->offscreen_window);
+}
+
+static void
+gtk_rotated_bin_size_request (GtkWidget      *widget,
+                              GtkRequisition *requisition)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
+  GtkRequisition child_requisition;
+  double s, c;
+  double w, h;
+
+  child_requisition.width = 0;
+  child_requisition.height = 0;
+
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    gtk_widget_size_request (bin->child, &child_requisition);
+
+  s = sin (bin->angle);
+  c = cos (bin->angle);
+  w = c * child_requisition.width + s * child_requisition.height;
+  h = s * child_requisition.width + c * child_requisition.height;
+
+  requisition->width = GTK_CONTAINER (widget)->border_width * 2 + w;
+  requisition->height = GTK_CONTAINER (widget)->border_width * 2 + h;
+}
+
+static void
+gtk_rotated_bin_size_allocate (GtkWidget     *widget,
+                               GtkAllocation *allocation)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
+  gint border_width;
+  gint w, h;
+  gdouble s, c;
+
+  widget->allocation = *allocation;
+
+  border_width = GTK_CONTAINER (widget)->border_width;
+
+  w = allocation->width - border_width * 2;
+  h = allocation->height - border_width * 2;
+
+  if (GTK_WIDGET_REALIZED (widget))
+    gdk_window_move_resize (widget->window,
+                            allocation->x + border_width,
+                            allocation->y + border_width,
+                            w, h);
+
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      GtkRequisition child_requisition;
+      GtkAllocation child_allocation;
+
+      s = sin (bin->angle);
+      c = cos (bin->angle);
+
+      gtk_widget_get_child_requisition (bin->child, &child_requisition);
+      child_allocation.x = 0;
+      child_allocation.y = 0;
+      child_allocation.height = child_requisition.height;
+      if (c == 0.0)
+        child_allocation.width = h / s;
+      else if (s == 0.0)
+        child_allocation.width = w / c;
+      else
+        child_allocation.width = MIN ((w - s * child_allocation.height) / c,
+                                      (h - c * child_allocation.height) / s);
+
+      if (GTK_WIDGET_REALIZED (widget))
+        gdk_window_move_resize (bin->offscreen_window,
+                                child_allocation.x,
+                                child_allocation.y,
+                                child_allocation.width,
+                                child_allocation.height);
+
+      child_allocation.x = child_allocation.y = 0;
+      gtk_widget_size_allocate (bin->child, &child_allocation);
+    }
+}
+
+static gboolean
+gtk_rotated_bin_damage (GtkWidget      *widget,
+                        GdkEventExpose *event)
+{
+  gdk_window_invalidate_rect (widget->window, NULL, FALSE);
+
+  return TRUE;
+}
+
+static gboolean
+gtk_rotated_bin_expose (GtkWidget      *widget,
+                        GdkEventExpose *event)
+{
+  GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
+  gint width, height;
+  gdouble s, c;
+  gdouble w, h;
+
+  if (GTK_WIDGET_DRAWABLE (widget))
+    {
+      if (event->window == widget->window)
+        {
+          GdkPixmap *pixmap;
+          GtkAllocation child_area;
+          cairo_t *cr;
+
+          if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+            {
+              pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
+              child_area = bin->child->allocation;
+
+              cr = gdk_cairo_create (widget->window);
+
+              /* transform */
+              s = sin (bin->angle);
+              c = cos (bin->angle);
+              w = c * child_area.width + s * child_area.height;
+              h = s * child_area.width + c * child_area.height;
+
+              cairo_translate (cr, (w - child_area.width) / 2, (h - child_area.height) / 2);
+              cairo_translate (cr, child_area.width / 2, child_area.height / 2);
+              cairo_rotate (cr, bin->angle);
+              cairo_translate (cr, -child_area.width / 2, -child_area.height / 2);
+
+              /* clip */
+              gdk_drawable_get_size (pixmap, &width, &height);
+              cairo_rectangle (cr, 0, 0, width, height);
+              cairo_clip (cr);
+              /* paint */
+              gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
+              cairo_paint (cr);
+
+              cairo_destroy (cr);
+            }
+        }
+      else if (event->window == bin->offscreen_window)
+        {
+          gtk_paint_flat_box (widget->style, event->window,
+                              GTK_STATE_NORMAL, GTK_SHADOW_NONE,
+                              &event->area, widget, "blah",
+                              0, 0, -1, -1);
+
+          if (bin->child)
+            gtk_container_propagate_expose (GTK_CONTAINER (widget),
+                                            bin->child,
+                                            event);
+        }
+    }
+
+  return FALSE;
+}
+
+/*** ***/
+
+static void
+scale_changed (GtkRange      *range,
+               GtkRotatedBin *bin)
+{
+  gtk_rotated_bin_set_angle (bin, gtk_range_get_value (range));
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_offscreen_window (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *bin, *vbox, *scale, *button;
+      GdkColor black;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+                             gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Rotated widget");
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      gdk_color_parse ("black", &black);
+      gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &black);
+      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+      vbox = gtk_vbox_new (0, FALSE);
+      scale = gtk_hscale_new_with_range (0, G_PI/2, 0.01);
+      gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
+
+      button = gtk_button_new_with_label ("A Button");
+      bin = gtk_rotated_bin_new ();
+
+      g_signal_connect (scale, "value-changed", G_CALLBACK (scale_changed), bin);
+
+      gtk_container_add (GTK_CONTAINER (window), vbox);
+      gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), bin, TRUE, TRUE, 0);
+      gtk_container_add (GTK_CONTAINER (bin), button);
+    }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    {
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}
+
@@ -0,0 +1,500 @@
+/* Offscreen windows/Effects
+ *
+ * Offscreen windows can be used to render elements multiple times to achieve
+ * various effects.
+ */
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_MIRROR_BIN              (gtk_mirror_bin_get_type ())
+#define GTK_MIRROR_BIN(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MIRROR_BIN, GtkMirrorBin))
+#define GTK_MIRROR_BIN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MIRROR_BIN, GtkMirrorBinClass))
+#define GTK_IS_MIRROR_BIN(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MIRROR_BIN))
+#define GTK_IS_MIRROR_BIN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MIRROR_BIN))
+#define GTK_MIRROR_BIN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MIRROR_BIN, GtkMirrorBinClass))
+
+typedef struct _GtkMirrorBin   GtkMirrorBin;
+typedef struct _GtkMirrorBinClass  GtkMirrorBinClass;
+
+struct _GtkMirrorBin
+{
+  GtkContainer container;
+
+  GtkWidget *child;
+  GdkWindow *offscreen_window;
+};
+
+struct _GtkMirrorBinClass
+{
+  GtkContainerClass parent_class;
+};
+
+GType      gtk_mirror_bin_get_type  (void) G_GNUC_CONST;
+GtkWidget* gtk_mirror_bin_new       (void);
+
+/*** implementation ***/
+
+static void     gtk_mirror_bin_realize       (GtkWidget       *widget);
+static void     gtk_mirror_bin_unrealize     (GtkWidget       *widget);
+static void     gtk_mirror_bin_size_request  (GtkWidget       *widget,
+                                               GtkRequisition  *requisition);
+static void     gtk_mirror_bin_size_allocate (GtkWidget       *widget,
+                                               GtkAllocation   *allocation);
+static gboolean gtk_mirror_bin_damage        (GtkWidget       *widget,
+                                               GdkEventExpose  *event);
+static gboolean gtk_mirror_bin_expose        (GtkWidget       *widget,
+                                               GdkEventExpose  *offscreen);
+
+static void     gtk_mirror_bin_add           (GtkContainer    *container,
+                                               GtkWidget       *child);
+static void     gtk_mirror_bin_remove        (GtkContainer    *container,
+                                               GtkWidget       *widget);
+static void     gtk_mirror_bin_forall        (GtkContainer    *container,
+                                               gboolean         include_internals,
+                                               GtkCallback      callback,
+                                               gpointer         callback_data);
+static GType    gtk_mirror_bin_child_type    (GtkContainer    *container);
+
+G_DEFINE_TYPE (GtkMirrorBin, gtk_mirror_bin, GTK_TYPE_CONTAINER);
+
+static void
+to_child (GtkMirrorBin *bin,
+          double         widget_x,
+          double         widget_y,
+          double        *x_out,
+          double        *y_out)
+{
+  *x_out = widget_x;
+  *y_out = widget_y;
+}
+
+static void
+to_parent (GtkMirrorBin *bin,
+           double         offscreen_x,
+           double         offscreen_y,
+           double        *x_out,
+           double        *y_out)
+{
+  *x_out = offscreen_x;
+  *y_out = offscreen_y;
+}
+
+static void
+gtk_mirror_bin_class_init (GtkMirrorBinClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
+
+  widget_class->realize = gtk_mirror_bin_realize;
+  widget_class->unrealize = gtk_mirror_bin_unrealize;
+  widget_class->size_request = gtk_mirror_bin_size_request;
+  widget_class->size_allocate = gtk_mirror_bin_size_allocate;
+  widget_class->expose_event = gtk_mirror_bin_expose;
+
+  g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
+                                   GTK_TYPE_MIRROR_BIN,
+                                   g_cclosure_new (G_CALLBACK (gtk_mirror_bin_damage),
+                                                   NULL, NULL));
+
+  container_class->add = gtk_mirror_bin_add;
+  container_class->remove = gtk_mirror_bin_remove;
+  container_class->forall = gtk_mirror_bin_forall;
+  container_class->child_type = gtk_mirror_bin_child_type;
+}
+
+static void
+gtk_mirror_bin_init (GtkMirrorBin *bin)
+{
+  GTK_WIDGET_UNSET_FLAGS (bin, GTK_NO_WINDOW);
+}
+
+GtkWidget *
+gtk_mirror_bin_new (void)
+{
+  return g_object_new (GTK_TYPE_MIRROR_BIN, NULL);
+}
+
+static GdkWindow *
+pick_offscreen_child (GdkWindow     *offscreen_window,
+                      double         widget_x,
+                      double         widget_y,
+                      GtkMirrorBin *bin)
+{
+ GtkAllocation child_area;
+ double x, y;
+
+ if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      to_child (bin, widget_x, widget_y, &x, &y);
+
+      child_area = bin->child->allocation;
+
+      if (x >= 0 && x < child_area.width &&
+          y >= 0 && y < child_area.height)
+        return bin->offscreen_window;
+    }
+
+  return NULL;
+}
+
+static void
+offscreen_window_to_parent (GdkWindow     *offscreen_window,
+                            double         offscreen_x,
+                            double         offscreen_y,
+                            double        *parent_x,
+                            double        *parent_y,
+                            GtkMirrorBin *bin)
+{
+  to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
+}
+
+static void
+offscreen_window_from_parent (GdkWindow     *window,
+                              double         parent_x,
+                              double         parent_y,
+                              double        *offscreen_x,
+                              double        *offscreen_y,
+                              GtkMirrorBin *bin)
+{
+  to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
+}
+
+static void
+gtk_mirror_bin_realize (GtkWidget *widget)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+  gint border_width;
+  GtkRequisition child_requisition;
+
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+
+  border_width = GTK_CONTAINER (widget)->border_width;
+
+  attributes.x = widget->allocation.x + border_width;
+  attributes.y = widget->allocation.y + border_width;
+  attributes.width = widget->allocation.width - 2 * border_width;
+  attributes.height = widget->allocation.height - 2 * border_width;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.event_mask = gtk_widget_get_events (widget)
+                        | GDK_EXPOSURE_MASK
+                        | GDK_POINTER_MOTION_MASK
+                        | GDK_BUTTON_PRESS_MASK
+                        | GDK_BUTTON_RELEASE_MASK
+                        | GDK_SCROLL_MASK
+                        | GDK_ENTER_NOTIFY_MASK
+                        | GDK_LEAVE_NOTIFY_MASK;
+
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (widget);
+  attributes.wclass = GDK_INPUT_OUTPUT;
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+                                   &attributes, attributes_mask);
+  gdk_window_set_user_data (widget->window, widget);
+  g_signal_connect (widget->window, "pick-embedded-child",
+                    G_CALLBACK (pick_offscreen_child), bin);
+
+  attributes.window_type = GDK_WINDOW_OFFSCREEN;
+
+  child_requisition.width = child_requisition.height = 0;
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      attributes.width = bin->child->allocation.width;
+      attributes.height = bin->child->allocation.height;
+    }
+  bin->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
+                                          &attributes, attributes_mask);
+  gdk_window_set_user_data (bin->offscreen_window, widget);
+  if (bin->child)
+    gtk_widget_set_parent_window (bin->child, bin->offscreen_window);
+  gdk_offscreen_window_set_embedder (bin->offscreen_window, widget->window);
+  g_signal_connect (bin->offscreen_window, "to-embedder",
+                    G_CALLBACK (offscreen_window_to_parent), bin);
+  g_signal_connect (bin->offscreen_window, "from-embedder",
+                    G_CALLBACK (offscreen_window_from_parent), bin);
+
+  widget->style = gtk_style_attach (widget->style, widget->window);
+
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+  gtk_style_set_background (widget->style, bin->offscreen_window, GTK_STATE_NORMAL);
+  gdk_window_show (bin->offscreen_window);
+}
+
+static void
+gtk_mirror_bin_unrealize (GtkWidget *widget)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
+
+  gdk_window_set_user_data (bin->offscreen_window, NULL);
+  gdk_window_destroy (bin->offscreen_window);
+  bin->offscreen_window = NULL;
+
+  GTK_WIDGET_CLASS (gtk_mirror_bin_parent_class)->unrealize (widget);
+}
+
+static GType
+gtk_mirror_bin_child_type (GtkContainer *container)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
+
+  if (bin->child)
+    return G_TYPE_NONE;
+
+  return GTK_TYPE_WIDGET;
+}
+
+static void
+gtk_mirror_bin_add (GtkContainer *container,
+                     GtkWidget    *widget)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
+
+  if (!bin->child)
+    {
+      gtk_widget_set_parent_window (widget, bin->offscreen_window);
+      gtk_widget_set_parent (widget, GTK_WIDGET (bin));
+      bin->child = widget;
+    }
+  else
+    g_warning ("GtkMirrorBin cannot have more than one child\n");
+}
+
+static void
+gtk_mirror_bin_remove (GtkContainer *container,
+                        GtkWidget    *widget)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
+  gboolean was_visible;
+
+  was_visible = GTK_WIDGET_VISIBLE (widget);
+
+  if (bin->child == widget)
+    {
+      gtk_widget_unparent (widget);
+
+      bin->child = NULL;
+
+      if (was_visible && GTK_WIDGET_VISIBLE (container))
+        gtk_widget_queue_resize (GTK_WIDGET (container));
+    }
+}
+
+static void
+gtk_mirror_bin_forall (GtkContainer *container,
+                        gboolean      include_internals,
+                        GtkCallback   callback,
+                        gpointer      callback_data)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
+
+  g_return_if_fail (callback != NULL);
+
+  if (bin->child)
+    (*callback) (bin->child, callback_data);
+}
+
+static void
+gtk_mirror_bin_size_request (GtkWidget      *widget,
+                              GtkRequisition *requisition)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
+  GtkRequisition child_requisition;
+
+  child_requisition.width = 0;
+  child_requisition.height = 0;
+
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    gtk_widget_size_request (bin->child, &child_requisition);
+
+  requisition->width = GTK_CONTAINER (widget)->border_width * 2 + child_requisition.width + 10;
+  requisition->height = GTK_CONTAINER (widget)->border_width * 2 + child_requisition.height * 2 + 10;
+}
+
+static void
+gtk_mirror_bin_size_allocate (GtkWidget     *widget,
+                               GtkAllocation *allocation)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
+  gint border_width;
+  gint w, h;
+  widget->allocation = *allocation;
+
+  border_width = GTK_CONTAINER (widget)->border_width;
+
+  w = allocation->width - border_width * 2;
+  h = allocation->height - border_width * 2;
+
+  if (GTK_WIDGET_REALIZED (widget))
+    gdk_window_move_resize (widget->window,
+                            allocation->x + border_width,
+                            allocation->y + border_width,
+                            w, h);
+
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      GtkRequisition child_requisition;
+      GtkAllocation child_allocation;
+
+      gtk_widget_get_child_requisition (bin->child, &child_requisition);
+      child_allocation.x = 0;
+      child_allocation.y = 0;
+      child_allocation.height = child_requisition.height;
+      child_allocation.width = child_requisition.width;
+
+      if (GTK_WIDGET_REALIZED (widget))
+        gdk_window_move_resize (bin->offscreen_window,
+                                allocation->x + border_width,
+                                allocation->y + border_width,
+                                child_allocation.width, child_allocation.height);
+      gtk_widget_size_allocate (bin->child, &child_allocation);
+    }
+}
+
+static gboolean
+gtk_mirror_bin_damage (GtkWidget      *widget,
+                        GdkEventExpose *event)
+{
+  gdk_window_invalidate_rect (widget->window, NULL, FALSE);
+
+  return TRUE;
+}
+
+static gboolean
+gtk_mirror_bin_expose (GtkWidget      *widget,
+                        GdkEventExpose *event)
+{
+  GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
+  gint width, height;
+
+  if (GTK_WIDGET_DRAWABLE (widget))
+    {
+      if (event->window == widget->window)
+        {
+          GdkPixmap *pixmap;
+          cairo_t *cr;
+          cairo_matrix_t matrix;
+          cairo_pattern_t *mask;
+
+          if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+            {
+              pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
+              gdk_drawable_get_size (pixmap, &width, &height);
+
+              cr = gdk_cairo_create (widget->window);
+
+              cairo_save (cr);
+
+              cairo_rectangle (cr, 0, 0, width, height);
+              cairo_clip (cr);
+
+              /* paint the offscreen child */
+              gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
+              cairo_paint (cr);
+
+              cairo_restore (cr);
+
+              cairo_matrix_init (&matrix, 1.0, 0.0, 0.3, 1.0, 0.0, 0.0);
+              cairo_matrix_scale (&matrix, 1.0, -1.0);
+              cairo_matrix_translate (&matrix, -10, - 3 * height - 10);
+              cairo_transform (cr, &matrix);
+
+              cairo_rectangle (cr, 0, height, width, height);
+              cairo_clip (cr);
+
+              gdk_cairo_set_source_pixmap (cr, pixmap, 0, height);
+
+              /* create linear gradient as mask-pattern to fade out the source */
+              mask = cairo_pattern_create_linear (0.0, height, 0.0, 2*height);
+              cairo_pattern_add_color_stop_rgba (mask, 0.0,  0.0, 0.0, 0.0, 0.0);
+              cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.01);
+              cairo_pattern_add_color_stop_rgba (mask, 0.5,  0.0, 0.0, 0.0, 0.25);
+              cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.5);
+              cairo_pattern_add_color_stop_rgba (mask, 1.0,  0.0, 0.0, 0.0, 1.0);
+
+              /* paint the reflection */
+              cairo_mask (cr, mask);
+
+              cairo_pattern_destroy (mask);
+              cairo_destroy (cr);
+            }
+        }
+      else if (event->window == bin->offscreen_window)
+        {
+          gtk_paint_flat_box (widget->style, event->window,
+                              GTK_STATE_NORMAL, GTK_SHADOW_NONE,
+                              &event->area, widget, "blah",
+                              0, 0, -1, -1);
+
+          if (bin->child)
+            gtk_container_propagate_expose (GTK_CONTAINER (widget),
+                                            bin->child,
+                                            event);
+        }
+    }
+
+  return FALSE;
+}
+
+/*** ***/
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_offscreen_window2 (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *bin, *vbox;
+      GtkWidget *hbox, *entry, *applybutton, *backbutton;
+      GtkSizeGroup *group;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+                             gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Effects");
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+      vbox = gtk_vbox_new (0, FALSE);
+
+      bin = gtk_mirror_bin_new ();
+
+      group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+
+      hbox = gtk_hbox_new (FALSE, 6);
+      backbutton = gtk_button_new ();
+      gtk_container_add (GTK_CONTAINER (backbutton),
+                         gtk_image_new_from_stock (GTK_STOCK_GO_BACK, 4));
+      gtk_size_group_add_widget (group, backbutton);
+      entry = gtk_entry_new ();
+      gtk_size_group_add_widget (group, entry);
+      applybutton = gtk_button_new ();
+      gtk_size_group_add_widget (group, applybutton);
+      gtk_container_add (GTK_CONTAINER (applybutton),
+                         gtk_image_new_from_stock (GTK_STOCK_APPLY, 4));
+
+      gtk_container_add (GTK_CONTAINER (window), vbox);
+      gtk_box_pack_start (GTK_BOX (vbox), bin, TRUE, TRUE, 0);
+      gtk_container_add (GTK_CONTAINER (bin), hbox);
+      gtk_box_pack_start (GTK_BOX (hbox), backbutton, FALSE, FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
+      gtk_box_pack_start (GTK_BOX (hbox), applybutton, FALSE, FALSE, 0);
+    }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    {
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}
+
@@ -640,6 +640,7 @@ gdk_window_at_pointer
 gdk_window_show
 gdk_window_show_unraised
 gdk_window_hide
+gdk_window_is_destroyed
 gdk_window_is_visible
 gdk_window_is_viewable
 gdk_window_get_state
@@ -661,6 +662,7 @@ gdk_window_resize
 gdk_window_move_resize
 gdk_window_scroll
 gdk_window_move_region
+gdk_window_flush
 gdk_window_ensure_native
 gdk_window_reparent
 gdk_window_clear
@@ -669,6 +671,7 @@ gdk_window_clear_area_e
 gdk_window_copy_area
 gdk_window_raise
 gdk_window_lower
+gdk_window_restack
 gdk_window_focus
 gdk_window_register_dnd
 gdk_window_begin_resize_drag
@@ -720,6 +723,7 @@ gdk_window_set_background
 gdk_window_set_back_pixmap
 GDK_PARENT_RELATIVE
 gdk_window_set_cursor
+gdk_window_get_cursor
 gdk_window_set_colormap
 gdk_window_get_user_data
 gdk_window_get_geometry
@@ -911,6 +915,7 @@ gdk_cairo_set_source_pixbuf
 gdk_cairo_set_source_pixmap
 gdk_cairo_rectangle
 gdk_cairo_region
+gdk_cairo_reset_clip
 </SECTION>

 <SECTION>
@@ -85,3 +85,12 @@ Cairo paths and to use pixbufs as sources for drawing operations.
@region: 


+<!-- ##### FUNCTION gdk_cairo_reset_clip ##### -->
+<para>
+
+</para>
+
+@cr: 
+@drawable: 
+
+
@@ -15,6 +15,11 @@ header file. <filename>&lt;gdk/gdkkeysyms.h&gt;</filename> is not included in <f
 it must be included independently, because the file is quite large.
 </para>
 <para>
+Key values are regularly updated from the upstream X.org X11 implementation,
+so new values are added regularly. They will be prefixed with GDK_ rather than
+XF86XK_ or XK_ (for older symbols).
+</para>
+<para>
 Key values can be converted into a string representation using
 gdk_keyval_name(). The reverse function, converting a string to a key value,
 is provided by gdk_keyval_from_name().
@@ -8,10 +8,18 @@ Onscreen display areas in the target window system
 <para>
 A #GdkWindow is a rectangular region on the screen. It's a low-level object,
 used to implement high-level objects such as #GtkWidget and #GtkWindow on the
-GTK+ level. A #GtkWindow is a toplevel window, the thing a user might think of 
-as a "window" with a titlebar and so on; a #GtkWindow may contain many #GdkWindow. 
+GTK+ level. A #GtkWindow is a toplevel window, the thing a user might think of
+as a "window" with a titlebar and so on; a #GtkWindow may contain many #GdkWindow.
 For example, each #GtkButton has a #GdkWindow associated with it.
 </para>
+<refsect2 id="COMPOSITED-WINDOWS"><title>Composited Windows</title>
+<para>
+Normally, the windowing system takes care of rendering the contents of a child
+window onto its parent window. This mechanism can be intercepted by calling
+gdk_window_set_composited() on the child window. For a
+<firstterm>composited</firstterm> window it is the responsibility of the
+application to render the window contents at the right spot.
+</para>
 <example id="composited-window-example"><title>Composited windows</title>
 <programlisting><![CDATA[
 #include <gtk/gtk.h>
@@ -54,7 +62,7 @@ transparent_expose (GtkWidget      *widget,
 * this handler is called after the red has been drawn. If it was
 * called before then GTK would just blindly paint over our work.
 *
- * Note: if the child window has children, then you need a cairo 1.16
+ * Note: if the child window has children, then you need a cairo 1.6
 * feature to make this work correctly.
 */
 static gboolean
@@ -153,10 +161,10 @@ main (int argc, char **argv)
 ]]>
 </programlisting></example>
 <para>
-In the example <xref linkend="composited-window-example"/>, a button is 
-placed inside of an event box inside of a window. The event box is 
-set as composited and therefore is no longer automatically drawn to 
-the screen. 
+In the example <xref linkend="composited-window-example"/>, a button is
+placed inside of an event box inside of a window. The event box is
+set as composited and therefore is no longer automatically drawn to
+the screen.
 </para>
 <para>
 When the contents of the event box change, an expose event is
@@ -168,8 +176,31 @@ that it wishes.
 <para>
 In our case, we merge the contents with a 50% transparency. We
 also set the background colour of the window to red. The effect is
-that the background shows through the button. 
+that the background shows through the button.
 </para>
+</refsect2>
+<refsect2 id="OFFSCREEN-WINDOWS"><title>Offscreen Windows</title>
+<para>
+Offscreen windows are more general than composited windows, since they
+allow not only to modify the rendering of the child window onto its parent,
+but also to apply coordinate transformations.
+</para>
+<para>
+To integrate an offscreen window into a window hierarchy, one has to call
+gdk_window_set_embedder() and handle a number of signals. The
+gdk_offscreen_window_set_embedder() and handle a number of signals. The
+#GdkWindow::pick-embedded-child signal on the embedder window is used to
+select an offscreen child at given coordinates, and the #GdkWindow::to-embedder
+and #GdkWindow::from-embedder signals on the offscreen window are used to
+translate coordinates between the embedder and the offscreen window.
+</para>
+
+<para>
+For rendering an offscreen window onto its embedder, the contents of the
+offscreen window are available as a pixmap, via
+gdk_offscreen_window_get_pixmap().
+</para>
+</refsect2>

 <!-- ##### SECTION See_Also ##### -->
 <para>
@@ -237,7 +268,7 @@ Describes the kind of window.
@GDK_WINDOW_DIALOG: useless/deprecated compatibility type
@GDK_WINDOW_TEMP: override redirect temporary window (used to implement #GtkMenu)
@GDK_WINDOW_FOREIGN: foreign window (see gdk_window_foreign_new())
-@GDK_WINDOW_OFFSCREEN: offscreen window. Since 2.18
+@GDK_WINDOW_OFFSCREEN: offscreen window (see <xref linkend="OFFSCREEN-WINDOWS"/>). Since 2.18

 <!-- ##### ENUM GdkWindowClass ##### -->
 <para>
@@ -535,6 +566,15 @@ Deprecated equivalent of g_object_unref()
@window: 


+<!-- ##### FUNCTION gdk_window_is_destroyed ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gdk_window_is_visible ##### -->
 <para>

@@ -723,6 +763,14 @@ Deprecated equivalent of g_object_unref()
@dy: 


+<!-- ##### FUNCTION gdk_window_flush ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
 <!-- ##### FUNCTION gdk_window_ensure_native ##### -->
 <para>

@@ -811,6 +859,16 @@ Deprecated equivalent to gdk_draw_drawable(), see that function for docs
@window: 


+<!-- ##### FUNCTION gdk_window_restack ##### -->
+<para>
+
+</para>
+
+@window: 
+@sibling: 
+@above: 
+
+
 <!-- ##### FUNCTION gdk_window_focus ##### -->
 <para>

@@ -1247,6 +1305,15 @@ window.
@cursor: 


+<!-- ##### FUNCTION gdk_window_get_cursor ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
 <!-- ##### MACRO gdk_window_set_colormap ##### -->
 <para>
 Deprecated equivalent to gdk_drawable_set_colormap()
@@ -129,6 +129,7 @@ content_files =					\
 	drawing-model.xml			\
 	glossary.xml				\
 	migrating-checklist.sgml		\
+        migrating-ClientSideWindows.sgml	\
 	migrating-GtkAboutDialog.sgml		\
 	migrating-GtkAction.sgml		\
 	migrating-GtkAssistant.sgml		\
@@ -159,6 +160,7 @@ expand_content_files = 				\
 	drawing-model.xml			\
 	glossary.xml				\
 	migrating-checklist.sgml		\
+        migrating-ClientSideWindows.sgml	\
 	migrating-GtkAction.sgml		\
 	migrating-GtkComboBox.sgml		\
 	migrating-GtkEntry-icons.sgml		\
@@ -435,6 +435,7 @@ that is, GUI components such as #GtkButton or #GtkTextView.
    <xi:include href="xml/migrating-GtkTooltip.sgml" />
    <xi:include href="xml/migrating-GtkEntry-icons.sgml" />
    <xi:include href="xml/migrating-GtkLabel-links.sgml" />
+    <xi:include href="xml/migrating-ClientSideWindows.sgml" />
  </part>

  <part>
@@ -3074,6 +3074,8 @@ gtk_range_set_lower_stepper_sensitivity
 gtk_range_get_lower_stepper_sensitivity
 gtk_range_set_upper_stepper_sensitivity
 gtk_range_get_upper_stepper_sensitivity
+gtk_range_get_flippable
+gtk_range_set_flippable
 <SUBSECTION Standard>
 GTK_RANGE
 GTK_IS_RANGE
@@ -5032,6 +5034,14 @@ gtk_cell_renderer_editing_canceled
 gtk_cell_renderer_stop_editing
 gtk_cell_renderer_get_fixed_size
 gtk_cell_renderer_set_fixed_size
+gtk_cell_renderer_get_visible
+gtk_cell_renderer_set_visible
+gtk_cell_renderer_get_sensitive
+gtk_cell_renderer_set_sensitive
+gtk_cell_renderer_get_alignment
+gtk_cell_renderer_set_alignment
+gtk_cell_renderer_get_padding
+gtk_cell_renderer_set_padding

 <SUBSECTION Standard>
 GTK_CELL_RENDERER
@@ -5137,6 +5147,9 @@ gtk_cell_renderer_toggle_get_radio
 gtk_cell_renderer_toggle_set_radio
 gtk_cell_renderer_toggle_get_active
 gtk_cell_renderer_toggle_set_active
+gtk_cell_renderer_toggle_get_activatable
+gtk_cell_renderer_toggle_set_activatable
+
 <SUBSECTION Standard>
 GTK_CELL_RENDERER_TOGGLE
 GTK_IS_CELL_RENDERER_TOGGLE
@@ -5566,6 +5579,30 @@ gtk_widget_set_has_tooltip
 gtk_widget_trigger_tooltip_query
 gtk_widget_get_snapshot
 gtk_widget_get_window
+gtk_widget_get_allocation
+gtk_widget_set_allocation
+gtk_widget_get_app_paintable
+gtk_widget_get_can_default
+gtk_widget_set_can_default
+gtk_widget_get_can_focus
+gtk_widget_set_can_focus
+gtk_widget_get_double_buffered
+gtk_widget_get_has_window
+gtk_widget_set_has_window
+gtk_widget_get_sensitive
+gtk_widget_is_sensitive
+gtk_widget_get_state
+gtk_widget_get_visible
+gtk_widget_set_visible
+gtk_widget_has_default
+gtk_widget_has_focus
+gtk_widget_has_grab
+gtk_widget_is_drawable
+gtk_widget_is_toplevel
+gtk_widget_set_window
+gtk_widget_set_receives_default
+gtk_widget_get_receives_default
+
 <SUBSECTION>
 gtk_requisition_copy
 gtk_requisition_free
@@ -0,0 +1,70 @@
+<?xml version="1.0"?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
+               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
+]>
+<chapter id="gtk-migrating-ClientSideWindows">
+
+  <title>Migrating to client-side windows</title>
+
+  <para>
+    In version 2.18, GDK has been changed to use client-side windows. This
+    means that there is no longer a 1-1 correspondence between #GdkWindows
+    and windows in the underlying window system. In particular, it is no
+    longer correct to assume that each window has an associated XID.
+    Code that makes this assumption can sometimes be fixed by calling
+    gdk_window_ensure_native() on the windows in question.
+    Calling gdk_x11_drawable_get_xid() (or GDK_WINDOW_XID()) from the
+    X11-specific API on a non-native window will explicitly call
+    gdk_window_ensure_native(), so old code using this will continue to
+    work. A small gotcha is that the GDK_WINDOW_XID() call is no longer a
+    trivial accessor for the XID of the window, and thus must not be called
+    from another thread without taking locking precautions.
+  </para>
+
+  <para>
+    GDK looks for the <envar>GDK_NATIVE_WINDOWS</envar> environment variable
+    and makes all windows native if it is set. It also tries to be more
+    compatible with the way prior versions worked in some other ways.
+  </para>
+
+  <para>
+    Some applications assume that they can just operate on the X windows
+    corresponding to their GDK windows without ever telling GDK. One
+    example that we've seen is changing the child window stacking order
+    using XRestackWindows(). Fixing this properly requires to fix the code
+    to use GDK functions to achieve whatever it is trying to achieve.
+    To make this easier in the case of stacking order changes, we've added
+    a gdk_window_restack() function.
+  </para>
+
+  <para>
+    One change that can cause problems for some applications is that GDK
+    is more aggressive about optimizing away expose events. Code that does
+    more than just repainting exposed areas in response to expose events
+    may be affected by this.
+  </para>
+
+  <para>
+    Problems can also occur when using cairo for drawing. One thing that can
+    go wrong is clip handling. If you ever need to reset the clip region on
+    a cairo_t (i.e. use cairo_reset_clip()), you have to to use
+    gdk_cairo_reset_clip() instead. The reason for this is that the cairo_reset_clip() call will remove the initial clip region that limits your drawing to
+    the client-side window at hand, so you will end up drawing over stuff
+    outside the window. You also need to use gdk_cairo_reset_clip() if you
+    use a cairo_t that was not allocated in a double-buffered expose handler
+    and keep it in use after window hierarchy changes (resizing, moving,
+    stacking order changes). The easiest fix for this kind of problem is to
+    simply create a new cairo context for each expose event.
+  </para>
+
+  <para>
+    Due to a weird API in XClearArea the gdk_window_clear_area() call handled
+    a specified width or height of zero to mean "to end of window" for
+    non-double-buffered drawing. This has been changed to be consistent with
+    the docs and what happens in the double-buffered case. All code in GTK+
+    that relied on this has been fixed, but it is possible (although unlikely)
+    that third party applications rely on this. If you need to do this, just
+    implement it yourself using gdk_drawable_get_size().
+  </para>
+
+</chapter>
@@ -341,6 +341,16 @@ nevertheless.
  </para>
 </formalpara>

+<formalpara>
+  <title><envar>GDK_NATIVE_WINDOWS</envar></title>
+
+  <para>
+    If set, GDK creates all windows as native windows. This can help
+    applications that make assumptions about 1-1 correspondence between
+    GDK windows and X11 windows.
+  </para>
+</formalpara>
+
 <formalpara>
  <title><envar>XDG_DATA_HOME</envar>, <envar>XDG_DATA_DIRS</envar></title>

@@ -3885,14 +3885,6 @@ fundamental type.
@group_cycling: 
@Returns: 

-<!-- ##### FUNCTION gtk_widget_get_allocation ##### -->
-<para>
-
-</para>
-
-@widget: 
-@Returns: 
-
 <!-- ##### FUNCTION gtk_widget_get_usize ##### -->
 <para>

@@ -282,3 +282,79 @@ it cannot be individually modified.
@height: 


+<!-- ##### FUNCTION gtk_cell_renderer_get_visible ##### -->
+<para>
+
+</para>
+
+@cell: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_set_visible ##### -->
+<para>
+
+</para>
+
+@cell: 
+@visible: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_get_sensitive ##### -->
+<para>
+
+</para>
+
+@cell: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_set_sensitive ##### -->
+<para>
+
+</para>
+
+@cell: 
+@sensitive: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_get_alignment ##### -->
+<para>
+
+</para>
+
+@cell: 
+@xalign: 
+@yalign: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_set_alignment ##### -->
+<para>
+
+</para>
+
+@cell: 
+@xalign: 
+@yalign: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_get_padding ##### -->
+<para>
+
+</para>
+
+@cell: 
+@xpad: 
+@ypad: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_set_padding ##### -->
+<para>
+
+</para>
+
+@cell: 
+@xpad: 
+@ypad: 
+
+
@@ -103,3 +103,21 @@ property. When activated, it emits the toggled signal.
@setting: 


+<!-- ##### FUNCTION gtk_cell_renderer_toggle_get_activatable ##### -->
+<para>
+
+</para>
+
+@toggle: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_cell_renderer_toggle_set_activatable ##### -->
+<para>
+
+</para>
+
+@toggle: 
+@setting: 
+
+
@@ -196,7 +196,7 @@ functions), but they will all return %NULL values.
@GTK_IMAGE_ANIMATION: the widget contains a #GdkPixbufAnimation
@GTK_IMAGE_ICON_NAME: the widget contains a named icon. 
  This image type was added in GTK+ 2.6
-@GTK_IMAGE_GICON: the widgte contains a #GIcon.
+@GTK_IMAGE_GICON: the widget contains a #GIcon.
  This image type was added in GTK+ 2.14

 <!-- ##### FUNCTION gtk_image_get_icon_set ##### -->
@@ -288,7 +288,7 @@ formats are supported.
    the printer in PDF format
@GTK_PRINT_CAPABILITY_GENERATE_PS: The program will send the document to 
    the printer in Postscript format
-@GTK_PRINT_CAPABILITY_PREVIEW: Print dialog will offer a previe
+@GTK_PRINT_CAPABILITY_PREVIEW: Print dialog will offer a preview
@GTK_PRINT_CAPABILITY_NUMBER_UP: Print dialog will offer printing multiple 
    pages per sheet. Since 2.12
@GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT: Print dialog will allow to rearrange 
@@ -346,3 +346,21 @@ at the end of range widgets.
@Returns: 


+<!-- ##### FUNCTION gtk_range_get_flippable ##### -->
+<para>
+
+</para>
+
+@range: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_range_set_flippable ##### -->
+<para>
+
+</para>
+
+@range: 
+@flippable: 
+
+
@@ -2641,6 +2641,213 @@ This function is deprecated; it does nothing.
@Returns: 


+<!-- ##### FUNCTION gtk_widget_get_allocation ##### -->
+<para>
+
+</para>
+
+@widget: 
+@allocation: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_allocation ##### -->
+<para>
+
+</para>
+
+@widget: 
+@allocation: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_app_paintable ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_can_default ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_can_default ##### -->
+<para>
+
+</para>
+
+@widget: 
+@can_default: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_can_focus ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_can_focus ##### -->
+<para>
+
+</para>
+
+@widget: 
+@can_focus: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_double_buffered ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_has_window ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_has_window ##### -->
+<para>
+
+</para>
+
+@widget: 
+@has_window: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_sensitive ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_is_sensitive ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_state ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_visible ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_visible ##### -->
+<para>
+
+</para>
+
+@widget: 
+@visible: 
+
+
+<!-- ##### FUNCTION gtk_widget_has_default ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_has_focus ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_has_grab ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_is_drawable ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_is_toplevel ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_window ##### -->
+<para>
+
+</para>
+
+@widget: 
+@window: 
+
+
+<!-- ##### FUNCTION gtk_widget_set_receives_default ##### -->
+<para>
+
+</para>
+
+@widget: 
+@receives_default: 
+
+
+<!-- ##### FUNCTION gtk_widget_get_receives_default ##### -->
+<para>
+
+</para>
+
+@widget: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_requisition_copy ##### -->
 <para>

@@ -277,6 +277,7 @@ correct_prefix (gchar **path)
  if (strncmp (*path, GTK_PREFIX "/", strlen (GTK_PREFIX "/")) == 0 ||
      strncmp (*path, GTK_PREFIX "\\", strlen (GTK_PREFIX "\\")) == 0)
    {
+	  gchar *tem = NULL;
      if (strlen(*path) > 5 && strncmp (*path - 5, ".libs", 5) == 0)
        {
          /* We are being run from inside the build tree, and shouldn't mess about. */
@@ -290,7 +291,7 @@ correct_prefix (gchar **path)
       * builder's machine. Replace the build-time prefix with the
       * installation prefix on this machine.
       */
-      gchar *tem = *path;
+      tem = *path;
      *path = g_strconcat (get_toplevel (), tem + strlen (GTK_PREFIX), NULL);
      g_free (tem);
    }
@@ -353,7 +353,6 @@ gdip_buffer_to_bitmap (const gchar *buffer, size_t size, GError **error)
  if (!hg)
    return NULL;

-  IStream_SetSize (stream, *(ULARGE_INTEGER *)&size64);
  hr = CreateStreamOnHGlobal (hg, FALSE, (LPSTREAM *)&stream);

  if (!SUCCEEDED (hr)) {
@@ -361,7 +360,9 @@ gdip_buffer_to_bitmap (const gchar *buffer, size_t size, GError **error)
    GlobalFree (hg);
    return NULL;
  }
-  
+
+  IStream_SetSize (stream, *(ULARGE_INTEGER *)&size64);
+
  status = GdipCreateBitmapFromStream (stream, &bitmap);

  if (Ok != status)
@@ -220,7 +220,7 @@ gif_read (GifContext *context, guchar *buffer, size_t len)
                                     G_FILE_ERROR,
                                     g_file_error_from_errno (save_errno),
                                     _("Failure reading GIF: %s"), 
-                                     strerror (save_errno));
+                                     g_strerror (save_errno));
                }
                
 #ifdef IO_GIFDEBUG
@@ -468,7 +468,6 @@ gdk_pixbuf__jpeg_image_load (FILE *f, GError **error)
 	cinfo.err = jpeg_std_error (&jerr.pub);
 	jerr.pub.error_exit = fatal_error_handler;
        jerr.pub.output_message = output_message_handler;
-
        jerr.error = error;
        
 	if (sigsetjmp (jerr.setjmp_buffer, 1)) {
@@ -1190,11 +1189,11 @@ real_save_jpeg (GdkPixbuf          *pixbuf,
       }

       /* set up error handling */
+       cinfo.err = jpeg_std_error (&(jerr.pub));
       jerr.pub.error_exit = fatal_error_handler;
       jerr.pub.output_message = output_message_handler;
       jerr.error = error;
       
-       cinfo.err = jpeg_std_error (&(jerr.pub));
       if (sigsetjmp (jerr.setjmp_buffer, 1)) {
               jpeg_destroy_compress (&cinfo);
               g_free (buf);
@@ -596,7 +596,7 @@ pixbuf_create_from_xpm (const gchar * (*get_buf) (enum buf_op op, gpointer handl
 		if ((!buffer) || (strlen (buffer) < wbytes))
 			continue;

-		for (n = 0, cnt = 0, xcnt = 0; n < wbytes; n += cpp, xcnt++) {
+		for (n = 0, xcnt = 0; n < wbytes; n += cpp, xcnt++) {
 			strncpy (pixel_str, &buffer[n], cpp);
 			pixel_str[cpp] = 0;

@@ -119,17 +119,20 @@ loader_sanity_check (const char *path, GdkPixbufFormat *info, GdkPixbufModule *v
 	return 0;
 }

-static void 
+static void
 write_loader_info (const char *path, GdkPixbufFormat *info)
 {
 	const GdkPixbufModulePattern *pattern;
-	char **mime; 
-	char **ext; 
+	char **mime;
+	char **ext;

 	g_printf("\"%s\"\n", path);
-	g_printf ("\"%s\" %u \"%s\" \"%s\" \"%s\"\n", 
-		  info->name, info->flags, 
-		  info->domain ? info->domain : GETTEXT_PACKAGE, info->description, info->license);
+	g_printf ("\"%s\" %u \"%s\" \"%s\" \"%s\"\n",
+		  info->name,
+                  info->flags,
+		  info->domain ? info->domain : GETTEXT_PACKAGE,
+                  info->description,
+                  info->license ? info->license : "");
 	for (mime = info->mime_types; *mime; mime++) {
 		g_printf ("\"%s\" ", *mime);
 	}
@@ -68,12 +68,14 @@ extern gboolean            gdk_directfb_monochrome_fonts;
 void        gdk_directfb_window_set_opacity (GdkWindow             *window,
                                             guchar                 opacity);

+#ifndef GDK_DISABLE_DEPRECATED
 GdkWindow * gdk_directfb_window_new         (GdkWindow             *parent,
                                             GdkWindowAttr         *attributes,
                                             gint                   attributes_mask,
                                             DFBWindowCapabilities  window_caps,
                                             DFBWindowOptions       window_options,
                                             DFBSurfaceCapabilities surface_caps);
+#endif /* GDK_DISABLE_DEPRECATED */

 GdkVisual * gdk_directfb_visual_by_format   (DFBSurfacePixelFormat  pixel_format);

@@ -351,6 +351,213 @@ _gdk_windowing_window_init (void)
 }


+GdkWindow *
+gdk_directfb_window_new (GdkWindow              *parent,
+                         GdkWindowAttr          *attributes,
+                         gint                    attributes_mask,
+                         DFBWindowCapabilities   window_caps,
+                         DFBWindowOptions        window_options,
+                         DFBSurfaceCapabilities  surface_caps)
+{
+  GdkWindow             *window;
+  GdkWindowObject       *private;
+  GdkWindowObject       *parent_private;
+  GdkWindowImplDirectFB *impl;
+  GdkWindowImplDirectFB *parent_impl;
+  GdkVisual             *visual;
+  DFBWindowDescription   desc;
+  gint x, y;
+
+  g_return_val_if_fail (attributes != NULL, NULL);
+
+  D_DEBUG_AT( GDKDFB_Window, "%s( %p )\n", __FUNCTION__, parent );
+
+  if (!parent || attributes->window_type != GDK_WINDOW_CHILD)
+    parent = _gdk_parent_root;
+
+  window = g_object_new (GDK_TYPE_WINDOW, NULL);
+  private = GDK_WINDOW_OBJECT (window);
+  private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
+
+  parent_private = GDK_WINDOW_OBJECT (parent);
+  parent_impl = GDK_WINDOW_IMPL_DIRECTFB (parent_private->impl);
+  private->parent = parent_private;
+
+  x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
+  y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
+
+  gdk_window_set_events (window, attributes->event_mask | GDK_STRUCTURE_MASK);
+
+  impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
+  impl->drawable.wrapper = GDK_DRAWABLE (window);
+  impl->gdkWindow      = window;
+
+  private->x = x;
+  private->y = y;
+
+  _gdk_directfb_calc_abs (window);
+
+  impl->drawable.width  = MAX (1, attributes->width);
+  impl->drawable.height = MAX (1, attributes->height);
+
+  private->window_type = attributes->window_type;
+
+  desc.flags = 0;
+
+  if (attributes_mask & GDK_WA_VISUAL)
+    visual = attributes->visual;
+  else
+    visual = gdk_drawable_get_visual (parent);
+
+  switch (attributes->wclass)
+    {
+    case GDK_INPUT_OUTPUT:
+      private->input_only = FALSE;
+
+      desc.flags |= DWDESC_PIXELFORMAT;
+      desc.pixelformat = ((GdkVisualDirectFB *) visual)->format;
+
+      if (DFB_PIXELFORMAT_HAS_ALPHA (desc.pixelformat))
+        {
+          desc.flags |= DWDESC_CAPS;
+          desc.caps = DWCAPS_ALPHACHANNEL;
+        }
+      break;
+
+    case GDK_INPUT_ONLY:
+      private->input_only = TRUE;
+      desc.flags |= DWDESC_CAPS;
+      desc.caps = DWCAPS_INPUTONLY;
+      break;
+
+    default:
+      g_warning ("gdk_window_new: unsupported window class\n");
+      _gdk_window_destroy (window, FALSE);
+      return NULL;
+    }
+
+  switch (private->window_type)
+    {
+    case GDK_WINDOW_TOPLEVEL:
+    case GDK_WINDOW_DIALOG:
+    case GDK_WINDOW_TEMP:
+      desc.flags |= ( DWDESC_WIDTH | DWDESC_HEIGHT |
+                      DWDESC_POSX  | DWDESC_POSY );
+      desc.posx   = x;
+      desc.posy   = y;
+      desc.width  = impl->drawable.width;
+      desc.height = impl->drawable.height;
+
+#if 0
+      if (window_caps)
+        {
+          if (! (desc.flags & DWDESC_CAPS))
+            {
+              desc.flags |= DWDESC_CAPS;
+              desc.caps   = DWCAPS_NONE;
+            }
+
+          desc.caps |= window_caps;
+        }
+
+      if (surface_caps)
+        {
+          desc.flags |= DWDESC_SURFACE_CAPS;
+          desc.surface_caps = surface_caps;
+        }
+#endif
+
+      if (!create_directfb_window (impl, &desc, window_options))
+        {
+          g_assert(0);
+          _gdk_window_destroy (window, FALSE);
+
+          return NULL;
+        }
+
+      if (desc.caps != DWCAPS_INPUTONLY)
+        {
+          impl->window->SetOpacity(impl->window, 0x00 );
+        }
+
+      break;
+
+    case GDK_WINDOW_CHILD:
+      impl->window=NULL;
+
+      if (!private->input_only && parent_impl->drawable.surface)
+        {
+
+          DFBRectangle rect =
+          { x, y, impl->drawable.width, impl->drawable.height };
+          parent_impl->drawable.surface->GetSubSurface (parent_impl->drawable.surface,
+                                                        &rect,
+                                                        &impl->drawable.surface);
+        }
+
+      break;
+
+    default:
+      g_warning ("gdk_window_new: unsupported window type: %d",
+                 private->window_type);
+      _gdk_window_destroy (window, FALSE);
+
+      return NULL;
+    }
+
+  if (impl->drawable.surface)
+    {
+      GdkColormap *colormap;
+
+      impl->drawable.surface->GetPixelFormat (impl->drawable.surface,
+                                              &impl->drawable.format);
+
+      private->depth = DFB_BITS_PER_PIXEL(impl->drawable.format);
+
+      if ((attributes_mask & GDK_WA_COLORMAP) && attributes->colormap)
+        {
+          colormap = attributes->colormap;
+        }
+      else
+        {
+          if (gdk_visual_get_system () == visual)
+            colormap = gdk_colormap_get_system ();
+          else
+            colormap =gdk_drawable_get_colormap (parent);
+        }
+
+      gdk_drawable_set_colormap (GDK_DRAWABLE (window), colormap);
+    }
+  else
+    {
+      impl->drawable.format = ((GdkVisualDirectFB *)visual)->format;
+      private->depth = visual->depth;
+    }
+
+  gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
+                                  (attributes->cursor) : NULL));
+
+  if (parent_private)
+    parent_private->children = g_list_prepend (parent_private->children,
+                                               window);
+
+  /* we hold a reference count on ourselves */
+  g_object_ref (window);
+
+  if (impl->window)
+    {
+      impl->window->GetID (impl->window, &impl->dfb_id);
+      gdk_directfb_window_id_table_insert (impl->dfb_id, window);
+      gdk_directfb_event_windows_add (window);
+    }
+
+  if (attributes_mask & GDK_WA_TYPE_HINT)
+    gdk_window_set_type_hint (window, attributes->type_hint);
+
+  return window;
+}
+
+
 void
 _gdk_window_impl_new (GdkWindow     *window,
                      GdkWindow     *real_parent,
@@ -1892,6 +2099,26 @@ _gdk_windowing_window_at_pointer (GdkDisplay *display,
  if (win_y)
    *win_y = wy;

+  if (get_toplevel)
+    {
+      GdkWindowObject *w = (GdkWindowObject *)retval;
+      /* Requested toplevel, find it. */
+      /* TODO: This can be implemented more efficient by never
+	 recursing into children in the first place */
+      if (w)
+	{
+	  /* Convert to toplevel */
+	  while (w->parent != NULL &&
+		 w->parent->window_type != GDK_WINDOW_ROOT)
+	    {
+	      *win_x += w->x;
+	      *win_y += w->y;
+	      w = w->parent;
+	    }
+	  retval = (GdkWindow *)w;
+	}
+    }
+
  return retval;
 }

@@ -1957,6 +2184,7 @@ gdk_directfb_window_input_shape_combine_region (GdkWindow       *window,

 static void
 gdk_directfb_window_queue_translation (GdkWindow *window,
+				       GdkGC     *gc,
                                       GdkRegion *region,
                                       gint       dx,
                                       gint       dy)
@@ -206,6 +206,14 @@ gdk_pre_parse_libgtk_only (void)
  }
 #endif	/* G_ENABLE_DEBUG */

+  if (getenv ("GDK_NATIVE_WINDOWS"))
+    {
+      _gdk_native_windows = TRUE;
+      /* Ensure that this is not propagated
+	 to spawned applications */
+      g_unsetenv ("GDK_NATIVE_WINDOWS");
+    }
+
  g_type_init ();

  /* Do any setup particular to the windowing system
@@ -22,7 +22,9 @@
 #if IN_HEADER(__GDK_EVENTS_H__)
 #if IN_FILE(__GDK_EVENTS_X11_C__)
 gdk_add_client_message_filter
+#ifndef GDK_DISABLE_DEPRECATED
 gdk_event_get_graphics_expose
+#endif
 gdk_events_pending
 #endif
 #endif
@@ -299,6 +301,7 @@ gdk_fontset_load_for_display
 #if IN_HEADER(__GDK_CAIRO_H__)
 #if IN_FILE(__GDK_CAIRO_C__)
 gdk_cairo_create
+gdk_cairo_reset_clip
 gdk_cairo_set_source_color
 gdk_cairo_set_source_pixbuf
 gdk_cairo_set_source_pixmap
@@ -650,6 +653,7 @@ gdk_window_get_events
 gdk_window_set_events
 gdk_window_raise
 gdk_window_lower
+gdk_window_restack
 gdk_window_move
 gdk_window_resize
 gdk_window_move_resize
@@ -683,6 +687,7 @@ gdk_window_clear_area_e
 gdk_window_constrain_size
 gdk_window_destroy
 gdk_window_end_paint
+gdk_window_flush
 gdk_window_foreign_new
 gdk_window_freeze_toplevel_updates_libgtk_only
 gdk_window_freeze_updates
@@ -699,6 +704,7 @@ gdk_window_get_toplevels
 gdk_window_get_update_area
 gdk_window_get_user_data
 gdk_window_get_window_type
+gdk_window_is_destroyed
 gdk_window_invalidate_maybe_recurse
 gdk_window_invalidate_rect
 gdk_window_invalidate_region
@@ -1216,6 +1222,8 @@ gdk_x11_display_get_startup_notification_id
 #if IN_FILE(__GDK_DRAWABLE_X11_C__)
 gdk_x11_drawable_get_xdisplay
 gdk_x11_drawable_get_xid
+gdk_x11_window_get_drawable_impl
+gdk_x11_pixmap_get_drawable_impl
 #endif

 #if IN_FILE(__GDK_FONT_X11_C__)
@@ -59,6 +59,34 @@ gdk_cairo_create (GdkDrawable *drawable)
  return cr;
 }

+/**
+ * gdk_cairo_reset_clip:
+ * @cr: a #cairo_t
+ * @drawable: a #GdkDrawable
+ *
+ * Resets the clip region for a Cairo context created by gdk_cairo_create().
+ *
+ * This resets the clip region to the "empty" state for the given drawable.
+ * This is required for non-native windows since a direct call to
+ * cairo_reset_clip() would unset the clip region inherited from the
+ * drawable (i.e. the window clip region), and thus let you e.g.
+ * draw outside your window.
+ *
+ * This is rarely needed though, since most code just create a new cairo_t
+ * using gdk_cairo_create() each time they want to draw something.
+ *
+ * Since: 2.18
+ **/
+void
+gdk_cairo_reset_clip (cairo_t            *cr,
+		      GdkDrawable        *drawable)
+{
+  cairo_reset_clip (cr);
+
+  if (GDK_DRAWABLE_GET_CLASS (drawable)->set_cairo_clip)
+    GDK_DRAWABLE_GET_CLASS (drawable)->set_cairo_clip (drawable, cr);
+}
+
 /**
 * gdk_cairo_set_source_color:
 * @cr: a #cairo_t
@@ -31,6 +31,8 @@
 G_BEGIN_DECLS

 cairo_t *gdk_cairo_create            (GdkDrawable        *drawable);
+void     gdk_cairo_reset_clip        (cairo_t            *cr,
+				      GdkDrawable        *drawable);

 void     gdk_cairo_set_source_color  (cairo_t            *cr,
                                      const GdkColor     *color);
@@ -510,7 +510,7 @@ gdk_display_real_get_window_at_pointer (GdkDisplay *display,
  GdkWindow *window;
  gint x, y;

-  window = _gdk_windowing_window_at_pointer (display, &x, &y, NULL);
+  window = _gdk_windowing_window_at_pointer (display, &x, &y, NULL, FALSE);

  /* This might need corrections, as the native window returned
     may contain client side children */
@@ -836,6 +836,10 @@ synthesize_crossing_events (GdkDisplay *display,
  GdkWindow *src_toplevel, *dest_toplevel;
  GdkModifierType state;
  int x, y;
+
+  /* We use the native crossing events if all native */
+  if (_gdk_native_windows)
+    return;
  
  if (src_window)
    src_toplevel = gdk_window_get_toplevel (src_window);
@@ -909,34 +913,20 @@ get_current_toplevel (GdkDisplay *display,
 		      GdkModifierType *state_out)
 {
  GdkWindow *pointer_window;
-  GdkWindowObject *w;
  int x, y;
  GdkModifierType state;

-  pointer_window = _gdk_windowing_window_at_pointer (display,  &x, &y, &state);
+  pointer_window = _gdk_windowing_window_at_pointer (display,  &x, &y, &state, TRUE);
  if (pointer_window != NULL &&
      (GDK_WINDOW_DESTROYED (pointer_window) ||
       GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_ROOT ||
       GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_FOREIGN))
    pointer_window = NULL;

-  w = (GdkWindowObject *)pointer_window;
-  if (w)
-    {
-      /* Convert to toplevel */
-      while (w->parent != NULL &&
-	     w->parent->window_type != GDK_WINDOW_ROOT)
-	{
-	  x += w->x;
-	  y += w->y;
-	  w = w->parent;
-	}
-    }
-
  *x_out = x;
  *y_out = y;
  *state_out = state;
-  return (GdkWindow *)w;
+  return pointer_window;
 }

 static void
@@ -1033,11 +1023,6 @@ switch_to_pointer_grab (GdkDisplay *display,
 	  
 	  /* We're now ungrabbed, update the window_under_pointer */
 	  _gdk_display_set_window_under_pointer (display, pointer_window);
-
-	  if (last_grab->implicit_ungrab)
-	    generate_grab_broken_event (last_grab->window,
-					FALSE, TRUE,
-					NULL);
 	}
    }
  
@@ -1061,9 +1046,7 @@ _gdk_display_pointer_grab_update (GdkDisplay *display,
      if (current_grab->serial_start > current_serial)
 	return; /* Hasn't started yet */
      
-      if (current_grab->serial_end > current_serial ||
-	  (current_grab->serial_end == current_serial &&
-	   current_grab->grab_one_pointer_release_event))
+      if (current_grab->serial_end > current_serial)
 	{
 	  /* This one hasn't ended yet.
 	     its the currently active one or scheduled to be active */
@@ -1085,13 +1068,12 @@ _gdk_display_pointer_grab_update (GdkDisplay *display,
 	    next_grab = NULL; /* Actually its not yet active */
 	}

-      if (next_grab == NULL ||
-	  current_grab->window != next_grab->window)
+      if ((next_grab == NULL && current_grab->implicit_ungrab) ||
+	  (next_grab != NULL && current_grab->window != next_grab->window))
 	generate_grab_broken_event (GDK_WINDOW (current_grab->window),
 				    FALSE, current_grab->implicit,
 				    next_grab? next_grab->window : NULL);

-
      /* Remove old grab */
      display->pointer_grabs =
 	g_list_delete_link (display->pointer_grabs,
@@ -1138,7 +1120,9 @@ _gdk_display_has_pointer_grab (GdkDisplay *display,
  return NULL;
 }

-/* Returns true if last grab was ended */
+/* Returns true if last grab was ended
+ * If if_child is non-NULL, end the grab only if the grabbed
+ * window is the same as if_child or a descendant of it */
 gboolean
 _gdk_display_end_pointer_grab (GdkDisplay *display,
 			       gulong serial,
@@ -1156,7 +1140,7 @@ _gdk_display_end_pointer_grab (GdkDisplay *display,
  grab = l->data;
  if (grab &&
      (if_child == NULL ||
-       _gdk_window_event_parent_of (grab->window, if_child)))
+       _gdk_window_event_parent_of (if_child, grab->window)))
    {
      grab->serial_end = serial;
      grab->implicit_ungrab = implicit;
@@ -634,7 +634,7 @@ gdk_draw_drawable (GdkDrawable *drawable,
 		   gint         width,
 		   gint         height)
 {
-  GdkDrawable *composite, *composite_impl;
+  GdkDrawable *composite;
  gint composite_x_offset = 0;
  gint composite_y_offset = 0;

@@ -663,24 +663,13 @@ gdk_draw_drawable (GdkDrawable *drawable,
                                                          &composite_x_offset,
                                                          &composite_y_offset);

-  /* The draw_drawable call below is will recurse into gdk_draw_drawable again,
-   * specifying the right impl for the destination. This means the composite
-   * we got here will be fed to get_composite_drawable again, which is a problem
-   * for window as that causes double the composite offset. Avoid this by passing
-   * in the impl directly.
-   */
-  if (GDK_IS_WINDOW (composite))
-    composite_impl = GDK_WINDOW_OBJECT (src)->impl;
-  else
-    composite_impl = composite;
-
  /* TODO: For non-native windows this may copy stuff from other overlapping
     windows. We should clip that and (for windows with bg != None) clear that
     area in the destination instead. */

  if (GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable_with_src)
    GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable_with_src (drawable, gc,
-							       composite_impl,
+							       composite,
 							       xsrc - composite_x_offset,
 							       ysrc - composite_y_offset,
 							       xdest, ydest,
@@ -688,7 +677,7 @@ gdk_draw_drawable (GdkDrawable *drawable,
 							       src);
  else /* backwards compat for old out-of-tree implementations of GdkDrawable (are there any?) */
    GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable (drawable, gc,
-						      composite_impl,
+						      composite,
 						      xsrc - composite_x_offset,
 						      ysrc - composite_y_offset,
 						      xdest, ydest,
@@ -1638,12 +1627,14 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
     have already retargeted the destination to any
     impl window and set the clip, so what we really
     want to do is draw directly on the impl, ignoring
-     client side subwindows. */
+     client side subwindows. We also use the impl
+     in the pixmap target case to avoid resetting the
+     already set clip on the GC. */
  if (GDK_IS_WINDOW (drawable))
    real_drawable = GDK_WINDOW_OBJECT (drawable)->impl;
  else
-    real_drawable = drawable;
-  
+    real_drawable = GDK_PIXMAP_OBJECT (drawable)->impl;
+
  if (pixbuf->has_alpha)
    {
      GdkVisual *visual = gdk_drawable_get_visual (drawable);
@@ -519,7 +519,9 @@ gboolean  gdk_events_pending	 	(void);
 GdkEvent* gdk_event_get			(void);

 GdkEvent* gdk_event_peek                (void);
+#ifndef GDK_DISABLE_DEPRECATED
 GdkEvent* gdk_event_get_graphics_expose (GdkWindow 	*window);
+#endif
 void      gdk_event_put	 		(const GdkEvent *event);

 GdkEvent* gdk_event_new                 (GdkEventType    type);
@@ -648,7 +648,7 @@ _gdk_gc_add_drawable_clip (GdkGC     *gc,
      GdkColor black = {0, 0, 0, 0};
      GdkRectangle r;
      GdkOverlapType overlap;
-      
+
      gdk_drawable_get_size (priv->clip_mask, &w, &h);

      r.x = 0;
@@ -659,7 +659,7 @@ _gdk_gc_add_drawable_clip (GdkGC     *gc,
      /* Its quite common to expose areas that are completely in or outside
       * the region, so we try to avoid allocating bitmaps that are just fully
       * set or completely unset.
-       */ 
+       */
      overlap = gdk_region_rect_in (region, &r);
      if (overlap == GDK_OVERLAP_RECTANGLE_PART)
 	{
@@ -683,11 +683,19 @@ _gdk_gc_add_drawable_clip (GdkGC     *gc,
 	}
      else if (overlap == GDK_OVERLAP_RECTANGLE_OUT)
 	{
+	  /* No intersection, set empty clip region */
 	  GdkRegion *empty = gdk_region_new ();

+	  gdk_region_destroy (region);
 	  priv->old_clip_mask = g_object_ref (priv->clip_mask);
+	  priv->clip_region = empty;
 	  _gdk_windowing_gc_set_clip_region (gc, empty, FALSE);
-	  gdk_region_destroy (empty);
+	}
+      else
+	{
+	  /* Completely inside region, don't set unnecessary clip */
+	  gdk_region_destroy (region);
+	  return;
 	}
    }
  else
@@ -696,7 +704,7 @@ _gdk_gc_add_drawable_clip (GdkGC     *gc,
      priv->clip_region = region;
      if (priv->old_clip_region)
 	gdk_region_intersect (region, priv->old_clip_region);
-      
+
      _gdk_windowing_gc_set_clip_region (gc, priv->clip_region, FALSE);
    }

@@ -718,6 +726,12 @@ _gdk_gc_remove_drawable_clip (GdkGC *gc)
 	  gdk_gc_set_clip_mask (gc, priv->old_clip_mask);
 	  g_object_unref (priv->old_clip_mask);
 	  priv->old_clip_mask = NULL;
+
+	  if (priv->clip_region)
+	    {
+	      g_object_unref (priv->clip_region);
+	      priv->clip_region = NULL;
+	    }
 	}
      else
 	{
@@ -1382,6 +1396,8 @@ _gdk_gc_update_context (GdkGC          *gc,

  priv = GDK_GC_GET_PRIVATE (gc);

+  _gdk_gc_remove_drawable_clip (gc);
+
  fill = priv->fill;
  if (override_stipple && fill != GDK_OPAQUE_STIPPLED)
    fill = GDK_STIPPLED;
@@ -1472,6 +1488,10 @@ _gdk_gc_update_context (GdkGC          *gc,
    return;

  cairo_reset_clip (cr);
+  /* The reset above resets the window clip rect, so we want to re-set that */
+  if (target_drawable && GDK_DRAWABLE_GET_CLASS (target_drawable)->set_cairo_clip)
+    GDK_DRAWABLE_GET_CLASS (target_drawable)->set_cairo_clip (target_drawable, cr);
+
  if (priv->clip_region)
    {
      cairo_save (cr);
@@ -1487,9 +1507,6 @@ _gdk_gc_update_context (GdkGC          *gc,
      cairo_clip (cr);
    }

-  /* The reset above resets the window clip rect, so we want to re-set that */
-  if (target_drawable && GDK_DRAWABLE_GET_CLASS (target_drawable)->set_cairo_clip)
-    GDK_DRAWABLE_GET_CLASS (target_drawable)->set_cairo_clip (target_drawable, cr);
 }


@@ -39,6 +39,7 @@ GList              *_gdk_default_filters = NULL;
 gchar              *_gdk_display_name = NULL;
 gint                _gdk_screen_number = -1;
 gchar              *_gdk_display_arg_name = NULL;
+gboolean            _gdk_native_windows = FALSE;

 GSList             *_gdk_displays = NULL;

@@ -107,6 +107,7 @@ extern gint		 _gdk_error_code;
 extern gint		 _gdk_error_warnings;

 extern guint _gdk_debug_flags;
+extern gboolean _gdk_native_windows;

 #ifdef G_ENABLE_DEBUG

@@ -184,7 +185,6 @@ typedef struct

  gboolean activated;
  gboolean implicit_ungrab;
-  gboolean grab_one_pointer_release_event;
 } GdkPointerGrabInfo;

 typedef struct _GdkInputWindow GdkInputWindow;
@@ -261,6 +261,7 @@ struct _GdkWindowObject
  guint visibility : 2; /* The visibility wrt the toplevel (i.e. based on clip_region) */
  guint native_visibility : 2; /* the native visibility of a impl windows */
  guint viewable : 1; /* mapped and all parents mapped */
+  guint applied_shape : 1;

  guint num_offscreen_children;
  GdkWindowPaint *implicit_paint;
@@ -274,6 +275,8 @@ struct _GdkWindowObject
  cairo_surface_t *cairo_surface;
 };

+#define GDK_WINDOW_TYPE(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->window_type)
+#define GDK_WINDOW_DESTROYED(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->destroyed)

 extern GdkEventFunc   _gdk_event_func;    /* Callback for events */
 extern gpointer       _gdk_event_data;
@@ -457,7 +460,8 @@ void       _gdk_windowing_get_pointer        (GdkDisplay       *display,
 GdkWindow* _gdk_windowing_window_at_pointer  (GdkDisplay       *display,
 					      gint             *win_x,
 					      gint             *win_y,
-					      GdkModifierType  *mask);
+					      GdkModifierType  *mask,
+					      gboolean          get_toplevel);
 GdkGrabStatus _gdk_windowing_pointer_grab    (GdkWindow        *window,
 					      GdkWindow        *native,
 					      gboolean          owner_events,
@@ -605,7 +609,7 @@ void _gdk_display_enable_motion_hints     (GdkDisplay *display);


 void _gdk_window_invalidate_for_expose (GdkWindow       *window,
-					const GdkRegion *region);
+					GdkRegion       *region);

 void _gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
 					    int width,
@@ -628,6 +632,8 @@ GdkEvent * _gdk_make_event (GdkWindow    *window,
 			    GdkEventType  type,
 			    GdkEvent     *event_in_queue,
 			    gboolean      before_event);
+gboolean _gdk_window_event_parent_of (GdkWindow *parent,
+                                      GdkWindow *child);

 void _gdk_synthesize_crossing_events (GdkDisplay                 *display,
 				      GdkWindow                  *src,
@@ -1,13 +1,15 @@
 #!/usr/bin/env perl

-# Updates http://svn.gnome.org/viewcvs/gtk%2B/trunk/gdk/gdkkeysyms.h?view=log from upstream (X.org 7.x),
+# Updates http://git.gnome.org/cgit/gtk+/tree/gdk/gdkkeysyms.h from upstream (X.org 7.x),
 # from http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=keysymdef.h
 # 
 # Author  : Simos Xenitellis <simos at gnome dot org>.
+# Authos  : Bastien Nocera <hadess@hadess.net>
 # Version : 1.2
 #
 # Input   : http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=keysymdef.h
-# Output  : http://svn.gnome.org/svn/gtk+/trunk/gdk/gdkkeysyms.h
+# Input   : http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=XF86keysym.h
+# Output  : http://git.gnome.org/cgit/gtk+/tree/gdk/gdkkeysyms.h
 # 
 # Notes   : It downloads keysymdef.h from the Internet, if not found locally,
 # Notes   : and creates an updated gdkkeysyms.h
@@ -33,6 +35,20 @@ else
 	print "as found at http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob;f=keysymdef.h\n\n";
 }

+if ( ! -f "XF86keysym.h" )
+{
+	print "Trying to download XF86keysym.h from\n";
+	print "http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=XF86keysym.h\n";
+	die "Unable to download keysymdef.h from http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=XF86keysym.h\n" 
+		unless system("wget -c -O XF86keysym.h \"http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=XF86keysym.h\"") == 0;
+	print " done.\n\n";
+}
+else
+{
+	print "We are using existing XF86keysym.h found in this directory.\n";
+	print "It is assumed that you took care and it is a recent version\n";
+	print "as found at http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob;f=XF86keysym.h\n\n";
+}

 if ( -f "gdkkeysyms.h" )
 {
@@ -41,7 +57,7 @@ if ( -f "gdkkeysyms.h" )
 	die "Exiting...\n\n";
 }

-# Source: http://cvs.freedesktop.org/xorg/xc/include/keysymdef.h
+# Source: http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob;f=keysymdef.h
 die "Could not open file keysymdef.h: $!\n" unless open(IN_KEYSYMDEF, "<:utf8", "keysymdef.h");

 # Output: gtk+/gdk/gdkkeysyms.h
@@ -50,7 +66,7 @@ die "Could not open file gdkkeysyms.h: $!\n" unless open(OUT_GDKKEYSYMS, ">:utf8
 print OUT_GDKKEYSYMS<<EOF;
 /* GDK - The GIMP Drawing Kit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- * Copyright (C) 2005, 2006, 2007 GNOME Foundation
+ * Copyright (C) 2005, 2006, 2007, 2009 GNOME Foundation
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -69,9 +85,11 @@ print OUT_GDKKEYSYMS<<EOF;
 */

 /*
- * File auto-generated from script http://svn.gnome.org/viewcvs/gtk%2B/trunk/gdk/gdkkeysyms-update.pl
+ * File auto-generated from script http://git.gnome.org/cgit/gtk+/tree/gdk/gdkkeysyms-update.pl
 * using the input file
 * http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=keysymdef.h
+ * and
+ * http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob_plain;f=XF86keysym.h
 */

 /*
@@ -106,9 +124,50 @@ while (<IN_KEYSYMDEF>)
 	printf OUT_GDKKEYSYMS "#define %s 0x%03x\n", $keysymelements[1], hex($keysymelements[2]);
 }

+close IN_KEYSYMDEF;
+
 #$gdksyms{"0"} = "0000";

-close IN_KEYSYMDEF;
+# Source: http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob;f=XF86keysym.h
+die "Could not open file XF86keysym.h: $!\n" unless open(IN_XF86KEYSYM, "<:utf8", "XF86keysym.h");
+
+while (<IN_XF86KEYSYM>)
+{
+	next if ( ! /^#define / );
+
+	@keysymelements = split(/\s+/);
+	die "Internal error, no \@keysymelements: $_\n" unless @keysymelements;
+
+	$_ = $keysymelements[1];
+	die "Internal error, was expecting \"XF86XK_*\", found: $_\n" if ( ! /^XF86XK_/ );
+
+	# Work-around https://bugs.freedesktop.org/show_bug.cgi?id=11193
+	if ($_ eq "XF86XK_XF86BackForward") {
+		$keysymelements[1] = "XF86XK_AudioForward";
+	}
+	# XF86XK_Clear could end up a dupe of XK_Clear
+	# XF86XK_Select could end up a dupe of XK_Select
+	if ($_ eq "XF86XK_Clear") {
+		$keysymelements[1] = "XF86XK_WindowClear";
+	}
+	if ($_ eq "XF86XK_Select") {
+		$keysymelements[1] = "XF86XK_SelectButton";
+	}
+
+	# Ignore XF86XK_Q
+	next if ( $_ eq "XF86XK_Q");
+	# XF86XK_Calculater is misspelled, and a dupe
+	next if ( $_ eq "XF86XK_Calculater");
+
+	$_ = $keysymelements[2];
+	die "Internal error, was expecting \"0x*\", found: $_\n" if ( ! /^0x/ );
+
+	$keysymelements[1] =~ s/^XF86XK_/GDK_/g;
+
+	printf OUT_GDKKEYSYMS "#define %s 0x%03x\n", $keysymelements[1], hex($keysymelements[2]);
+}
+
+close IN_XF86KEYSYM;


 print OUT_GDKKEYSYMS<<EOF;
@@ -601,7 +601,6 @@ _gdk_offscreen_window_new (GdkWindow     *window,
 			   GdkWindowAttr *attributes,
 			   gint           attributes_mask)
 {
-  GdkWindowObject *parent_private;
  GdkWindowObject *private;
  GdkOffscreenWindow *offscreen;

@@ -615,7 +614,6 @@ _gdk_offscreen_window_new (GdkWindow     *window,
  if (private->parent != NULL && GDK_WINDOW_DESTROYED (private->parent))
    return;

-  parent_private = (GdkWindowObject*) private->parent;
  private->impl = g_object_new (GDK_TYPE_OFFSCREEN_WINDOW, NULL);
  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
  offscreen->wrapper = window;
@@ -650,7 +648,6 @@ gdk_offscreen_window_reparent (GdkWindow *window,
  GdkWindowObject *private = (GdkWindowObject *)window;
  GdkWindowObject *new_parent_private = (GdkWindowObject *)new_parent;
  GdkWindowObject *old_parent;
-  GdkOffscreenWindow *offscreen;
  gboolean was_mapped;

  if (new_parent)
@@ -664,8 +661,6 @@ gdk_offscreen_window_reparent (GdkWindow *window,
 	return FALSE;
    }

-  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
-
  was_mapped = GDK_WINDOW_IS_MAPPED (window);

  gdk_window_hide (window);
@@ -837,6 +832,8 @@ gdk_offscreen_window_get_pointer (GdkWindow       *window,
 * add a reference to it.
 *
 * Returns: The offscreen pixmap, or %NULL if not offscreen
+ *
+ * Since: 2.18
 */
 GdkPixmap *
 gdk_offscreen_window_get_pixmap (GdkWindow *window)
@@ -1119,9 +1116,6 @@ gdk_offscreen_window_get_geometry (GdkWindow *window,
 				   gint      *depth)
 {
  GdkWindowObject *private = (GdkWindowObject *)window;
-  GdkOffscreenWindow *offscreen;
-
-  offscreen = GDK_OFFSCREEN_WINDOW (private->impl);

  g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));

@@ -1149,6 +1143,7 @@ gdk_offscreen_window_queue_antiexpose (GdkWindow *window,

 static void
 gdk_offscreen_window_queue_translation (GdkWindow *window,
+					GdkGC     *gc,
 					GdkRegion *area,
 					gint       dx,
 					gint       dy)
@@ -1160,6 +1155,13 @@ gdk_offscreen_window_queue_translation (GdkWindow *window,
 * @window: a #GdkWindow
 * @embedder: the #GdkWindow that @window gets embedded in
 *
+ * Sets @window to be embedded in @embedder.
+ *
+ * To fully embed an offscreen window, in addition to calling this
+ * function, it is also necessary to handle the #GdkWindow::pick-embedded-child
+ * signal on the @embedder and the #GdkWindow::to-embedder and
+ * #GdkWindow::from-embedder signals on @window.
+ *
 * Since: 2.18
 */
 void
@@ -385,10 +385,14 @@ gdk_pixmap_draw_drawable (GdkDrawable *drawable,
 {
  GdkPixmapObject *private = (GdkPixmapObject *)drawable;

-  _gdk_gc_remove_drawable_clip (gc);  
-  gdk_draw_drawable (private->impl, gc, src, xsrc, ysrc,
-                     xdest, ydest,
-                     width, height);
+  _gdk_gc_remove_drawable_clip (gc);
+  /* Call the method directly to avoid getting the composite drawable again */
+  GDK_DRAWABLE_GET_CLASS (private->impl)->draw_drawable_with_src (private->impl, gc,
+								  src,
+								  xsrc, ysrc,
+								  xdest, ydest,
+								  width, height,
+								  original_src);
 }

 static void
@@ -34,8 +34,10 @@ G_BEGIN_DECLS
 #define GDK_PARENT_RELATIVE_BG ((GdkPixmap *)1L)
 #define GDK_NO_BG ((GdkPixmap *)2L)

-#define GDK_WINDOW_TYPE(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->window_type)
-#define GDK_WINDOW_DESTROYED(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->destroyed)
+#ifndef GDK_COMPILATION
+#define GDK_WINDOW_TYPE(d) (gdk_window_get_window_type (GDK_WINDOW (d)))
+#define GDK_WINDOW_DESTROYED(d) (gdk_window_is_destroyed (GDK_WINDOW (d)))
+#endif

 void gdk_window_destroy_notify	     (GdkWindow *window);

@@ -43,9 +45,6 @@ void gdk_synthesize_window_state (GdkWindow     *window,
                                  GdkWindowState unset_flags,
                                  GdkWindowState set_flags);

-gboolean _gdk_window_event_parent_of (GdkWindow *parent,
-                                      GdkWindow *child);
-
 /* Tests whether a pair of x,y may cause overflows when converted to Pango
 * units (multiplied by PANGO_SCALE).  We don't allow the entire range, leave
 * some space for additions afterwards, to be safe...
@@ -86,7 +86,7 @@ void	   gdk_selection_convert   (GdkWindow	 *requestor,
 				    GdkAtom	  selection,
 				    GdkAtom	  target,
 				    guint32	  time_);
-gboolean   gdk_selection_property_get (GdkWindow  *requestor,
+gint       gdk_selection_property_get (GdkWindow  *requestor,
 				       guchar	 **data,
 				       GdkAtom	  *prop_type,
 				       gint	  *prop_format);
@@ -258,9 +258,12 @@ typedef struct _GdkWindowObjectClass GdkWindowObjectClass;
 #define GDK_IS_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
 #define GDK_IS_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
 #define GDK_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowObjectClass))
+
+#ifndef GDK_DISABLE_DEPRECATED
 #define GDK_WINDOW_OBJECT(object)    ((GdkWindowObject *) GDK_WINDOW (object))

 #ifndef GDK_COMPILATION
+
 /* We used to export all of GdkWindowObject, but we don't want to keep doing so.
   However, there are various parts of it accessed by macros and other code,
   so we keep the old exported version public, but in reality it is larger. */
@@ -316,6 +319,7 @@ struct _GdkWindowObject
  GdkWindowRedirect *redirect;
 };
 #endif
+#endif

 struct _GdkWindowObjectClass
 {
@@ -330,6 +334,7 @@ GdkWindow*    gdk_window_new                   (GdkWindow     *parent,
                                                gint           attributes_mask);
 void          gdk_window_destroy               (GdkWindow     *window);
 GdkWindowType gdk_window_get_window_type       (GdkWindow     *window);
+gboolean      gdk_window_is_destroyed          (GdkWindow     *window);
 GdkWindow*    gdk_window_at_pointer            (gint          *win_x,
                                                gint          *win_y);
 void          gdk_window_show                  (GdkWindow     *window);
@@ -364,6 +369,9 @@ void          gdk_window_clear_area_e          (GdkWindow     *window,
                                                gint           height);
 void          gdk_window_raise                 (GdkWindow     *window);
 void          gdk_window_lower                 (GdkWindow     *window);
+void          gdk_window_restack               (GdkWindow     *window,
+						GdkWindow     *sibling,
+						gboolean       above);
 void          gdk_window_focus                 (GdkWindow     *window,
                                                guint32        timestamp);
 void          gdk_window_set_user_data         (GdkWindow     *window,
@@ -501,6 +509,7 @@ void	      gdk_window_begin_paint_rect   (GdkWindow          *window,
 void	      gdk_window_begin_paint_region (GdkWindow          *window,
 					     const GdkRegion    *region);
 void	      gdk_window_end_paint          (GdkWindow          *window);
+void	      gdk_window_flush             (GdkWindow          *window);

 void	      gdk_window_set_title	   (GdkWindow	  *window,
 					    const gchar	  *title);
@@ -51,6 +51,9 @@ struct _GdkWindowImplIface
  void         (* lower)                (GdkWindow       *window);
  void         (* restack_under)        (GdkWindow       *window,
 					 GList           *native_siblings);
+  void         (* restack_toplevel)     (GdkWindow       *window,
+					 GdkWindow       *sibling,
+					 gboolean        above);

  void         (* move_resize)          (GdkWindow       *window,
                                         gboolean         with_move,
@@ -118,6 +121,7 @@ struct _GdkWindowImplIface
  gboolean     (* queue_antiexpose)     (GdkWindow       *window,
 					 GdkRegion       *update_area);
  void         (* queue_translation)    (GdkWindow       *window,
+					 GdkGC           *gc,
 					 GdkRegion       *area,
 					 gint            dx,
 					 gint            dy);
@@ -72,6 +72,13 @@
  if (NSEqualRects (rect, NSZeroRect))
    return;

+  /* Clear our own bookkeeping of regions that need display */
+  if (impl->needs_display_region)
+    {
+      gdk_region_destroy (impl->needs_display_region);
+      impl->needs_display_region = NULL;
+    }
+
  [self getRectsBeingDrawn:&drawn_rects count:&count];

  /* Note: arbitrary limit here to not degrade performace too much. It would
@@ -401,8 +401,29 @@ drag_operation_to_drag_action (NSDragOperation operation)
 {
  GdkDragAction result = 0;

+  /* GDK and Quartz drag operations do not map 1:1.
+   * This mapping represents about the best that we
+   * can come up.
+   *
+   * Note that NSDragOperationPrivate and GDK_ACTION_PRIVATE
+   * have almost opposite meanings: the GDK one means that the
+   * destination is solely responsible for the action; the Quartz
+   * one means that the source and destination will agree
+   * privately on the action. NSOperationGeneric is close in meaning
+   * to GDK_ACTION_PRIVATE but there is a problem: it will be
+   * sent for any ordinary drag, and likely not understood
+   * by any intra-widget drag (since the source & dest are the
+   * same).
+   */
+
  if (operation & NSDragOperationGeneric)
+    result |= GDK_ACTION_MOVE;
+  if (operation & NSDragOperationCopy)
    result |= GDK_ACTION_COPY;
+  if (operation & NSDragOperationMove)
+    result |= GDK_ACTION_MOVE;
+  if (operation & NSDragOperationLink)
+    result |= GDK_ACTION_LINK;

  return result;
 }
@@ -414,6 +435,10 @@ drag_action_to_drag_operation (GdkDragAction action)

  if (action & GDK_ACTION_COPY)
    result |= NSDragOperationCopy;
+  if (action & GDK_ACTION_LINK)
+    result |= NSDragOperationLink;
+  if (action & GDK_ACTION_MOVE)
+    result |= NSDragOperationMove;

  return result;
 }
@@ -425,6 +450,7 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)

  GDK_DRAG_CONTEXT_PRIVATE (current_context)->dragging_info = sender;
  current_context->suggested_action = drag_operation_to_drag_action ([sender draggingSourceOperationMask]);
+  current_context->actions = current_context->suggested_action;
 }

 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
@@ -450,6 +476,10 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)

 - (void)draggingEnded:(id <NSDraggingInfo>)sender
 {
+  /* leave a note for the source about what action was taken */
+  if (_gdk_quartz_drag_source_context && current_context)
+   _gdk_quartz_drag_source_context->action = current_context->action;
+
  if (current_context)
    g_object_unref (current_context);
  current_context = NULL;
@@ -45,6 +45,21 @@ gdk_quartz_cursor_new_from_nscursor (NSCursor      *nscursor,
  return cursor;
 }

+static GdkCursor *
+create_blank_cursor (void)
+{
+  NSCursor *nscursor;
+  NSImage *nsimage;
+  NSSize size = { 1.0, 1.0 };
+
+  nsimage = [[NSImage alloc] initWithSize:size];
+  nscursor = [[NSCursor alloc] initWithImage:nsimage
+                               hotSpot:NSMakePoint(0.0, 0.0)];
+  [nsimage release];
+
+  return gdk_quartz_cursor_new_from_nscursor (nscursor, GDK_BLANK_CURSOR);
+}
+
 static gboolean
 get_bit (const guchar *data,
         gint          width,
@@ -79,7 +94,7 @@ create_builtin_cursor (GdkCursorType cursor_type)
  NSImage *image;
  NSCursor *nscursor;

-  if (cursor_type >= G_N_ELEMENTS (xcursors))
+  if (cursor_type >= G_N_ELEMENTS (xcursors) || cursor_type < 0)
    return NULL;

  cursor = cached_xcursors[cursor_type];
@@ -210,6 +225,10 @@ gdk_cursor_new_for_display (GdkDisplay    *display,
    case GDK_HAND2:
      nscursor = [NSCursor pointingHandCursor];
      break;
+    case GDK_CURSOR_IS_PIXMAP:
+      return NULL;
+    case GDK_BLANK_CURSOR:
+      return create_blank_cursor ();
    default:
      return gdk_cursor_ref (create_builtin_cursor (cursor_type));
    }
@@ -101,6 +101,12 @@ gdk_drag_context_unref (GdkDragContext *context)

 GdkDragContext *_gdk_quartz_drag_source_context = NULL;

+GdkDragContext *
+gdk_quartz_drag_source_context ()
+{
+  return _gdk_quartz_drag_source_context;
+}
+
 GdkDragContext * 
 gdk_drag_begin (GdkWindow     *window,
 		GList         *targets)
@@ -33,6 +33,9 @@
 #include "gdkkeysyms.h"
 #include "gdkprivate-quartz.h"

+#define GRIP_WIDTH 15
+#define GRIP_HEIGHT 15
+
 /* This is the window corresponding to the key window */
 static GdkWindow   *current_keyboard_window;

@@ -498,7 +501,11 @@ find_window_for_ns_event (NSEvent *nsevent,
        grab = _gdk_display_get_last_pointer_grab (display);
 	if (grab)
 	  {
-	    if ((grab->event_mask & get_event_mask_from_ns_event (nsevent)) == 0)
+            /* Implicit grabs do not go through XGrabPointer and thus the
+             * event mask should not be checked.
+             */
+	    if (!grab->implicit
+                && (grab->event_mask & get_event_mask_from_ns_event (nsevent)) == 0)
              return NULL;

            if (grab->owner_events)
@@ -560,8 +567,6 @@ find_window_for_ns_event (NSEvent *nsevent,
              if (*y < 0)
                return NULL;

-            /* FIXME: Also need to leave resize events to cocoa somehow? */
-
            /* As for owner events, we need to use the toplevel under the
             * pointer, not the window from the NSEvent.
             */
@@ -570,7 +575,38 @@ find_window_for_ns_event (NSEvent *nsevent,
                                                                  &x_tmp, &y_tmp);
            if (toplevel_under_pointer)
              {
+                GdkWindowObject *toplevel_private;
+                GdkWindowImplQuartz *toplevel_impl;
+
                toplevel = toplevel_under_pointer;
+
+                toplevel_private = (GdkWindowObject *)toplevel;
+                toplevel_impl = (GdkWindowImplQuartz *)toplevel_private->impl;
+
+                if ([toplevel_impl->toplevel showsResizeIndicator])
+                  {
+                    NSRect frame;
+
+                    /* If the resize indicator is visible and the event
+                     * is in the lower right 15x15 corner, we leave these
+                     * events to Cocoa as to be handled as resize events.
+                     * Applications may have widgets in this area.  These
+                     * will most likely be larger than 15x15 and for
+                     * scroll bars there are also other means to move
+                     * the scroll bar.  Since the resize indicator is
+                     * the only way of resizing windows on Mac OS, it
+                     * is too important to not make functional.
+                     */
+                    frame = [toplevel_impl->view bounds];
+                    if (x_tmp > frame.size.width - GRIP_WIDTH
+                        && x_tmp < frame.size.width
+                        && y_tmp > frame.size.height - GRIP_HEIGHT
+                        && y_tmp < frame.size.height)
+                      {
+                        return NULL;
+                      }
+                  }
+
                *x = x_tmp;
                *y = y_tmp;
              }
@@ -24,10 +24,37 @@

 void
 _gdk_quartz_window_queue_translation (GdkWindow *window,
+				      GdkGC     *gc,
                                      GdkRegion *area,
                                      gint       dx,
                                      gint       dy)
 {
+  GdkWindowObject *private = (GdkWindowObject *)window;
+  GdkWindowImplQuartz *impl = (GdkWindowImplQuartz *)private->impl;
+
+  int i, n_rects;
+  GdkRegion *intersection;
+  GdkRectangle *rects;
+
+  /* We will intersect the known region that needs display with the given
+   * area.  This intersection will be translated by dx, dy.  For the end
+   * result, we will also set that it needs display.
+   */
+
+  if (!impl->needs_display_region)
+    return;
+
+  intersection = gdk_region_copy (impl->needs_display_region);
+  gdk_region_intersect (intersection, area);
+  gdk_region_offset (intersection, dx, dy);
+
+  gdk_region_get_rectangles (intersection, &rects, &n_rects);
+
+  for (i = 0; i < n_rects; i++)
+    _gdk_quartz_window_set_needs_display_in_rect (window, &rects[i]);
+
+  g_free (rects);
+  gdk_region_destroy (intersection);
 }

 gboolean
@@ -149,6 +149,9 @@ void       _gdk_quartz_window_did_resign_main       (GdkWindow *window);
 void       _gdk_quartz_window_debug_highlight       (GdkWindow *window,
                                                     gint       number);

+void       _gdk_quartz_window_set_needs_display_in_rect (GdkWindow    *window,
+                                                         GdkRectangle *rect);
+
 /* Events */
 typedef enum {
  GDK_QUARTZ_EVENT_SUBTYPE_EVENTLOOP
@@ -187,6 +190,7 @@ void        _gdk_quartz_window_scroll      (GdkWindow       *window,
                                            gint             dx,
                                            gint             dy);
 void        _gdk_quartz_window_queue_translation (GdkWindow *window,
+						  GdkGC     *gc,
                                                  GdkRegion *area,
                                                  gint       dx,
                                                  gint       dy);
@@ -82,6 +82,13 @@ gdk_screen_set_default_colormap (GdkScreen   *screen,
    g_object_unref (old_colormap);
 }

+/* FIXME: note on the get_width() and the get_height() methods.  For
+ * now we only support screen layouts where the screens are laid out
+ * horizontally.  Mac OS X also supports laying out the screens vertically
+ * and the screens having "non-standard" offsets from eachother.  In the
+ * future we need a much more sophiscated algorithm to translate these
+ * layouts to GDK coordinate space and GDK screen layout.
+ */
 gint
 gdk_screen_get_width (GdkScreen *screen)
 {
@@ -221,6 +228,8 @@ screen_get_monitor_geometry (GdkScreen    *screen,
  NSArray *array;
  NSScreen *nsscreen;
  NSRect rect;
+  NSRect largest_rect;
+  int i;

  GDK_QUARTZ_ALLOC_POOL;

@@ -229,10 +238,31 @@ screen_get_monitor_geometry (GdkScreen    *screen,
  rect = [nsscreen frame];
  
  dest->x = rect.origin.x;
-  dest->y = rect.origin.y;
  dest->width = rect.size.width;
  dest->height = rect.size.height;

+  /* FIXME: as stated above the get_width() and get_height() functions
+   * in this file, we only support horizontal screen layouts for now.
+   */
+
+  /* Find the monitor with the largest height.  All monitors should be
+   * offset to this one in the GDK screen space instead of offset to
+   * the screen with the menu bar.
+   */
+  largest_rect = [[array objectAtIndex:0] frame];
+  for (i = 1; i < [array count]; i++)
+    {
+      NSRect rect = [[array objectAtIndex:i] frame];
+
+      if (rect.size.height > largest_rect.size.height)
+        largest_rect = [[array objectAtIndex:i] frame];
+    }
+
+  if (largest_rect.size.height - rect.size.height == 0)
+    dest->y = 0;
+  else
+    dest->y = largest_rect.size.height - rect.size.height + largest_rect.origin.y;
+
  if (in_mm)
    {
      dest->x = get_mm_from_pixels (nsscreen, dest->x);
@@ -347,12 +347,30 @@ gdk_window_impl_quartz_end_paint (GdkPaintable *paintable)
    }
 }

+void
+_gdk_quartz_window_set_needs_display_in_rect (GdkWindow    *window,
+                                              GdkRectangle *rect)
+{
+  GdkWindowObject *private;
+  GdkWindowImplQuartz *impl;
+
+  private = GDK_WINDOW_OBJECT (window);
+  impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
+
+  if (!impl->needs_display_region)
+    impl->needs_display_region = gdk_region_new ();
+
+  gdk_region_union_with_rect (impl->needs_display_region, rect);
+
+  [impl->view setNeedsDisplayInRect:NSMakeRect (rect->x, rect->y,
+                                                rect->width, rect->height)];
+
+}
+
 void
 _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
                                               GdkRegion *region)
 {
-  GdkWindowObject *private = (GdkWindowObject *)window;
-  GdkWindowImplQuartz *impl = (GdkWindowImplQuartz *)private->impl;
  int i, n_rects;
  GdkRectangle *rects;

@@ -389,10 +407,7 @@ _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
  gdk_region_get_rectangles (region, &rects, &n_rects);

  for (i = 0; i < n_rects; i++)
-    {
-      [impl->view setNeedsDisplayInRect:NSMakeRect (rects[i].x, rects[i].y,
-                                                    rects[i].width, rects[i].height)];
-    }
+    _gdk_quartz_window_set_needs_display_in_rect (window, &rects[i]);

  g_free (rects);

@@ -639,9 +654,16 @@ _gdk_quartz_window_is_ancestor (GdkWindow *ancestor,
 gint 
 _gdk_quartz_window_get_inverted_screen_y (gint y)
 {
-  NSRect rect = [[NSScreen mainScreen] frame];
+  int index;
+  GdkRectangle gdk_rect;
+  NSScreen *main_screen = [NSScreen mainScreen];
+  NSRect rect = [main_screen frame];

-  return rect.size.height - y;
+  index = [[NSScreen screens] indexOfObject:main_screen];
+
+  gdk_screen_get_monitor_geometry (_gdk_screen, index, &gdk_rect);
+
+  return gdk_rect.height - y + rect.origin.y + gdk_rect.y;
 }

 static GdkWindow *
@@ -732,13 +754,76 @@ _gdk_quartz_window_find_child (GdkWindow *window,
  return NULL;
 }

+
+static void
+generate_motion_event (GdkWindow *window)
+{
+  NSPoint point;
+  NSPoint screen_point;
+  NSWindow *nswindow;
+  GdkQuartzView *view;
+  GdkWindowObject *private;
+  GdkEvent *event;
+  gint x, y, x_root, y_root;
+  gdouble xx, yy;
+  GList *node;
+  GdkWindow *pointer_window;
+
+  event = gdk_event_new (GDK_MOTION_NOTIFY);
+  event->any.window = NULL;
+  event->any.send_event = TRUE;
+
+  private = (GdkWindowObject *)window;
+  nswindow = ((GdkWindowImplQuartz *)private->impl)->toplevel;
+  view = (GdkQuartzView *)[nswindow contentView];
+
+  screen_point = [NSEvent mouseLocation];
+
+  x_root = screen_point.x;
+  y_root = _gdk_quartz_window_get_inverted_screen_y (screen_point.y);
+
+  point = [nswindow convertScreenToBase:screen_point];
+
+  x = point.x;
+  y = private->height - point.y;
+
+  pointer_window = _gdk_window_find_descendant_at (window, x, y,
+                                                   &xx, &yy);
+
+  event->any.type = GDK_MOTION_NOTIFY;
+  event->motion.window = window;
+  event->motion.time = GDK_CURRENT_TIME;
+  event->motion.x = x;
+  event->motion.y = y;
+  event->motion.x_root = x_root;
+  event->motion.y_root = y_root;
+  /* FIXME event->axes */
+  event->motion.state = 0;
+  event->motion.is_hint = FALSE;
+  event->motion.device = _gdk_display->core_pointer;
+
+  if (event->any.window)
+    g_object_ref (event->any.window);
+
+  node = _gdk_event_queue_append (gdk_display_get_default (), event);
+  _gdk_windowing_got_event (gdk_display_get_default (), node, event, 0);
+}
+
 void
 _gdk_quartz_window_did_become_main (GdkWindow *window)
 {
  main_window_stack = g_slist_remove (main_window_stack, window);

  if (GDK_WINDOW_OBJECT (window)->window_type != GDK_WINDOW_TEMP)
-    main_window_stack = g_slist_prepend (main_window_stack, window);
+    {
+      main_window_stack = g_slist_prepend (main_window_stack, window);
+
+      /* We just became the active window, send a motion-notify
+       * event so things like highlights get set up correctly.
+       * This motion-notify is sent to the key window.
+       */
+      generate_motion_event (window);
+    }

  clear_toplevel_order ();
 }
@@ -945,7 +1030,6 @@ _gdk_windowing_window_init (void)
  GdkWindowObject *private;
  GdkWindowImplQuartz *impl;
  GdkDrawableImplQuartz *drawable_impl;
-  NSRect rect;

  g_assert (_gdk_root == NULL);

@@ -955,16 +1039,20 @@ _gdk_windowing_window_init (void)
  private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
  private->impl_window = private;

-  /* Note: This needs to be reworked for multi-screen support. */
  impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (_gdk_root)->impl);
-  rect = [[NSScreen mainScreen] frame];

+  /* The size of the root window should be the same as the size of
+   * the screen it belongs to.
+   *
+   * FIXME: Of course this needs to be updated when you change the monitor
+   * configuration (add another one, remove one, etc).
+   */
  private->x = 0;
  private->y = 0;
  private->abs_x = 0;
  private->abs_y = 0;
-  private->width = rect.size.width;
-  private->height = rect.size.height;
+  private->width = gdk_screen_get_width (_gdk_screen);
+  private->height = gdk_screen_get_height (_gdk_screen);

  private->state = 0; /* We don't want GDK_WINDOW_STATE_WITHDRAWN here */
  private->window_type = GDK_WINDOW_ROOT;
@@ -1290,12 +1378,7 @@ move_resize_window_internal (GdkWindow *window,
              gdk_region_get_rectangles (expose_region, &rects, &n_rects);

              for (n = 0; n < n_rects; ++n)
-                {
-                  [impl->view setNeedsDisplayInRect:NSMakeRect (rects[n].x,
-                                                                rects[n].y,
-                                                                rects[n].width,
-                                                                rects[n].height)];
-                }
+                _gdk_quartz_window_set_needs_display_in_rect (window, &rects[n]);

              g_free (rects);
            }
@@ -1541,6 +1624,14 @@ gdk_window_quartz_lower (GdkWindow *window)
    }
 }

+static void
+gdk_window_quartz_restack_toplevel (GdkWindow *window,
+				    GdkWindow *sibling,
+				    gboolean   above)
+{
+  /* FIXME: Implement this */
+}
+
 static void
 gdk_window_quartz_set_background (GdkWindow      *window,
                                  const GdkColor *color)
@@ -1847,7 +1938,8 @@ GdkWindow *
 _gdk_windowing_window_at_pointer (GdkDisplay      *display,
 				  gint            *win_x,
 				  gint            *win_y,
-                                  GdkModifierType *mask)
+                                  GdkModifierType *mask,
+				  gboolean         get_toplevel)
 {
  GdkWindow *found_window;
  gint x, y;
@@ -1885,6 +1977,26 @@ _gdk_windowing_window_at_pointer (GdkDisplay      *display,
  if (mask)
    *mask = tmp_mask;

+  if (get_toplevel)
+    {
+      GdkWindowObject *w = (GdkWindowObject *)found_window;
+      /* Requested toplevel, find it. */
+      /* TODO: This can be implemented more efficient by never
+	 recursing into children in the first place */
+      if (w)
+	{
+	  /* Convert to toplevel */
+	  while (w->parent != NULL &&
+		 w->parent->window_type != GDK_WINDOW_ROOT)
+	    {
+	      *win_x += w->x;
+	      *win_y += w->y;
+	      w = w->parent;
+	    }
+	  found_window = (GdkWindow *)w;
+	}
+    }
+
  return found_window;
 }

@@ -2907,6 +3019,7 @@ gdk_window_impl_iface_init (GdkWindowImplIface *iface)
  iface->get_events = gdk_window_quartz_get_events;
  iface->raise = gdk_window_quartz_raise;
  iface->lower = gdk_window_quartz_lower;
+  iface->restack_toplevel = gdk_window_quartz_restack_toplevel;
  iface->move_resize = gdk_window_quartz_move_resize;
  iface->set_background = gdk_window_quartz_set_background;
  iface->set_back_pixmap = gdk_window_quartz_set_back_pixmap;
@@ -59,6 +59,8 @@ struct _GdkWindowImplQuartz

  /* Sorted by z-order */
  GList *sorted_children;
+
+  GdkRegion *needs_display_region;
 };
 
 struct _GdkWindowImplQuartzClass 
@@ -214,10 +214,10 @@ gdk_win32_set_colormap (GdkDrawable *drawable,
    return;
  
  if (impl->colormap)
-    gdk_colormap_unref (impl->colormap);
+    g_object_unref (impl->colormap);
  impl->colormap = colormap;
  if (impl->colormap)
-    gdk_colormap_ref (impl->colormap);
+    g_object_ref (impl->colormap);
 }

 /* Drawing
@@ -494,7 +494,7 @@ draw_tiles (GdkDrawable *drawable,

  gdk_win32_hdc_release (drawable, gc, mask);
  gdk_win32_hdc_release (tile, gc_copy, mask);
-  gdk_gc_unref (gc_copy);
+  g_object_unref (gc_copy);
 }

 static void
@@ -629,11 +629,11 @@ generic_draw (GdkDrawable    *drawable,
 	      gdk_draw_rectangle (tile_pixmap, tile_gc, TRUE,
 				  0, 0, width, height);
 	    }
-	  gdk_gc_unref (stipple_gc);
+	  g_object_unref (stipple_gc);
 	}

-      gdk_gc_unref (mask_gc);
-      gdk_gc_unref (tile_gc);
+      g_object_unref (mask_gc);
+      g_object_unref (tile_gc);

      mask_hdc = CreateCompatibleDC (hdc);

@@ -266,7 +266,7 @@ _gdk_win32_copy_to_image (GdkDrawable    *drawable,
    (FALSE,
     GDK_DRAWABLE_IMPL_WIN32 (GDK_PIXMAP_OBJECT (image->windowing_data)->impl),
     gc, drawable, src_x, src_y, dest_x, dest_y, width, height);
-  gdk_gc_unref (gc);
+  g_object_unref (gc);

  return image;
 }
@@ -392,7 +392,7 @@ gdk_win32_image_destroy (GdkImage *image)
  GDK_NOTE (IMAGE, g_print ("gdk_win32_image_destroy: %p\n",
 			    GDK_PIXMAP_HBITMAP (pixmap)));

-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
  image->windowing_data = NULL;
 }

@@ -108,12 +108,16 @@ GdkTimeCoord ** _gdk_device_allocate_history (GdkDevice *device,
 /* The following functions are provided by each implementation
 * (just wintab for now)
 */
-void             _gdk_input_configure_event  (GdkWindow         *window);
-void             _gdk_input_enter_event      (GdkWindow         *window);
+void             _gdk_input_configure_event  (GdkWindow        *window);
+void             _gdk_input_enter_event      (GdkWindow        *window);
 gboolean         _gdk_input_other_event      (GdkEvent         *event,
 					      MSG              *msg,
 					      GdkWindow        *window);

+void             _gdk_input_crossing_event   (GdkWindow        *window,
+					      gboolean          enter);
+
+
 /* These should be in gdkinternals.h */

 GdkInputWindow  *_gdk_input_window_find      (GdkWindow        *window);
@@ -310,6 +310,34 @@ _gdk_input_window_destroy (GdkWindow *window)
  g_free(input_window);
 }

+void
+_gdk_input_crossing_event (GdkWindow *window,
+			   gboolean enter)
+{
+  GdkWindowObject *priv = (GdkWindowObject *)window;
+  GdkInputWindow *input_window;
+  gint root_x, root_y;
+
+  if (enter)
+    {
+#if 0
+      /* No idea what to do... */
+#if 0
+      gdk_input_check_proximity(display);
+#endif
+      input_window = priv->input_window;
+      if (input_window != NULL)
+	{
+	  _gdk_input_get_root_relative_geometry (window, &root_x, &root_y);
+	  input_window->root_x = root_x;
+	  input_window->root_y = root_y;
+	}
+#endif
+    }
+  else
+    _gdk_input_ignore_core = FALSE;
+}
+
 void
 _gdk_input_exit (void)
 {
@@ -428,7 +428,7 @@ _gdk_pixmap_create_from_data (GdkDrawable    *drawable,
     GDK_DRAWABLE_IMPL_WIN32 (GDK_PIXMAP_OBJECT (result)->impl),
     gc, source, 0, 0, 0, 0, width, height);
  g_object_unref (source);
-  gdk_gc_unref (gc);
+  g_object_unref (gc);

  GDK_NOTE (PIXMAP, g_print ("gdk_pixmap_create_from_data: %dx%dx%d=%p\n",
 			     width, height, depth,
@@ -138,6 +138,8 @@ struct _GdkWin32SingleFont
  FONTSIGNATURE fs;
 };

+#ifndef GDK_DISABLE_DEPRECATED
+
 struct _GdkFontPrivateWin32
 {
  GdkFontPrivate base;
@@ -145,6 +147,8 @@ struct _GdkFontPrivateWin32
  GSList *names;
 };

+#endif /* GDK_DISABLE_DEPRECATED */
+
 struct _GdkVisualClass
 {
  GObjectClass parent_class;
@@ -2092,6 +2092,14 @@ gdk_win32_window_restack_under (GdkWindow *window,
 	// ### TODO
 }

+static void
+gdk_win32_window_restack_toplevel (GdkWindow *window,
+				   GdkWindow *sibling,
+				   gboolean   above)
+{
+	// ### TODO
+}
+
 void
 gdk_window_get_root_origin (GdkWindow *window,
 			    gint      *x,
@@ -2253,7 +2261,8 @@ GdkWindow*
 _gdk_windowing_window_at_pointer (GdkDisplay *display,
 				  gint       *win_x,
 				  gint       *win_y,
-				  GdkModifierType *mask)
+				  GdkModifierType *mask,
+				  gboolean    get_toplevel)
 {
  GdkWindow *window;
  POINT point, pointc;
@@ -2275,6 +2284,11 @@ _gdk_windowing_window_at_pointer (GdkDisplay *display,
  ScreenToClient (hwnd, &point);

  do {
+    if (get_toplevel &&
+	(window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd)) != NULL &&
+	GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+      break;
+
    hwndc = ChildWindowFromPoint (hwnd, point);
    ClientToScreen (hwnd, &point);
    ScreenToClient (hwndc, &point);
@@ -2353,8 +2367,6 @@ gdk_win32_window_shape_combine_mask (GdkWindow *window,
      GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p: none\n",
 			       GDK_WINDOW_HWND (window)));
      SetWindowRgn (GDK_WINDOW_HWND (window), NULL, TRUE);
-
-      private->shaped = FALSE;
    }
  else
    {
@@ -2368,8 +2380,6 @@ gdk_win32_window_shape_combine_mask (GdkWindow *window,
      hrgn = _gdk_win32_bitmap_to_hrgn (mask);

      do_shape_combine_region (window, hrgn, x, y);
-
-      private->shaped = TRUE;
    }
 }

@@ -3422,8 +3432,6 @@ gdk_win32_window_shape_combine_region (GdkWindow       *window,
      GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_region: %p: none\n",
 			       GDK_WINDOW_HWND (window)));
      SetWindowRgn (GDK_WINDOW_HWND (window), NULL, TRUE);
-
-      private->shaped = FALSE;
    }
  else
    {
@@ -3436,8 +3444,6 @@ gdk_win32_window_shape_combine_region (GdkWindow       *window,
 			       hrgn));

      do_shape_combine_region (window, hrgn, offset_x, offset_y);
-
-      private->shaped = TRUE;
    }
 }

@@ -3576,6 +3582,7 @@ _gdk_win32_window_queue_antiexpose (GdkWindow *window,
 */
 static void
 _gdk_win32_window_queue_translation (GdkWindow *window,
+				     GdkGC     *gc,
 				     GdkRegion *area,
 				     gint       dx,
 				     gint       dy)
@@ -3641,6 +3648,7 @@ gdk_window_impl_iface_init (GdkWindowImplIface *iface)
  iface->raise = gdk_win32_window_raise;
  iface->lower = gdk_win32_window_lower;
  iface->restack_under = gdk_win32_window_restack_under;
+  iface->restack_toplevel = gdk_win32_window_restack_toplevel;
  iface->move_resize = gdk_win32_window_move_resize;
  iface->set_background = gdk_win32_window_set_background;
  iface->set_back_pixmap = gdk_win32_window_set_back_pixmap;
@@ -3656,4 +3664,6 @@ gdk_window_impl_iface_init (GdkWindowImplIface *iface)
  iface->queue_antiexpose = _gdk_win32_window_queue_antiexpose;
  iface->queue_translation = _gdk_win32_window_queue_translation;
  iface->destroy = _gdk_win32_window_destroy;
+  iface->input_window_destroy = _gdk_input_window_destroy;
+  iface->input_window_crossing = _gdk_input_crossing_event;
 }
@@ -402,8 +402,7 @@ gdk_display_open (const gchar *display_name)
  _gdk_dnd_init (display);

  for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
-    gdk_display_request_selection_notification (display, 
-						GDK_SCREEN_X11 (display_x11->screens[i])->cm_selection_atom);
+    _gdk_x11_screen_setup (display_x11->screens[i]);

  g_signal_emit_by_name (gdk_display_manager_get(),
 			 "display_opened", display);
@@ -690,8 +689,8 @@ void
 gdk_display_beep (GdkDisplay *display)
 {
  g_return_if_fail (GDK_IS_DISPLAY (display));
-  
-  XBell (GDK_DISPLAY_XDISPLAY (display), 0);
+
+  XkbBell (GDK_DISPLAY_XDISPLAY (display), None, 0, None);
 }

 /**
@@ -956,6 +956,17 @@ gdk_x11_drawable_get_xid (GdkDrawable *drawable)
  return ((GdkDrawableImplX11 *)impl)->xid;
 }

+GdkDrawable *
+gdk_x11_window_get_drawable_impl (GdkWindow *window)
+{
+  return ((GdkWindowObject *)window)->impl;
+}
+GdkDrawable *
+gdk_x11_pixmap_get_drawable_impl (GdkPixmap *pixmap)
+{
+  return ((GdkPixmapObject *)pixmap)->impl;
+}
+
 /* Code for accelerated alpha compositing using the RENDER extension.
 * It's a bit long because there are lots of possibilities for
 * what's the fastest depending on the available picture formats,
@@ -92,6 +92,8 @@ void  _gdk_x11_convert_to_format      (guchar           *src_buf,
 /* Note that the following take GdkDrawableImplX11, not the wrapper drawable */
 void _gdk_x11_drawable_finish           (GdkDrawable  *drawable);
 void _gdk_x11_drawable_update_size      (GdkDrawable  *drawable);
+GdkDrawable *gdk_x11_window_get_drawable_impl (GdkWindow *window);
+GdkDrawable *gdk_x11_pixmap_get_drawable_impl (GdkPixmap *pixmap);

 G_END_DECLS

@@ -305,6 +305,8 @@ graphics_expose_predicate (Display  *display,
 *
 * Return value:  a #GdkEventExpose if a GraphicsExpose was received, or %NULL if a
 * NoExpose event was received.
+ *
+ * Deprecated:2.18
 **/
 GdkEvent*
 gdk_event_get_graphics_expose (GdkWindow *window)
@@ -1032,28 +1034,31 @@ gdk_event_translate (GdkDisplay *display,
 	    }
 	}
    }
-      
-  if (screen_x11 && screen_x11->wmspec_check_window != None &&
-      xwindow == screen_x11->wmspec_check_window)
-    {
-      if (xevent->type == DestroyNotify)
-        {
-          screen_x11->wmspec_check_window = None;
-          g_free (screen_x11->window_manager_name);
-          screen_x11->window_manager_name = g_strdup ("unknown");

-          /* careful, reentrancy */
-          _gdk_x11_screen_window_manager_changed (GDK_SCREEN (screen_x11));
+  if (xevent->type == DestroyNotify)
+    {
+      int i, n;
+
+      n = gdk_display_get_n_screens (display);
+      for (i = 0; i < n; i++)
+        {
+          screen = gdk_display_get_screen (display, i);
+          screen_x11 = GDK_SCREEN_X11 (screen);
+
+          if (screen_x11->wmspec_check_window == xwindow)
+            {
+              screen_x11->wmspec_check_window = None;
+              screen_x11->last_wmspec_check_time = 0;
+              g_free (screen_x11->window_manager_name);
+              screen_x11->window_manager_name = g_strdup ("unknown");
+
+              /* careful, reentrancy */
+              _gdk_x11_screen_window_manager_changed (screen);
+
+              return_val = FALSE;
+              goto done;
+            }
        }
-      
-      /* Eat events on this window unless someone had wrapped
-       * it as a foreign window
-       */
-      if (window == NULL)
-	{
-	  return_val = FALSE;
-	  goto done;
-	}
    }

  if (window &&
@@ -1595,13 +1600,13 @@ gdk_event_translate (GdkDisplay *display,
 			   xevent->xexpose.x, xevent->xexpose.y,
 			   xevent->xexpose.width, xevent->xexpose.height,
 			   event->any.send_event ? " (send)" : ""));
-      
+     
      if (window_private == NULL)
        {
          return_val = FALSE;
          break;
        }
-      
+
      {
 	GdkRectangle expose_rect;

@@ -1610,25 +1615,10 @@ gdk_event_translate (GdkDisplay *display,
 	expose_rect.width = xevent->xexpose.width;
 	expose_rect.height = xevent->xexpose.height;

-	if (return_exposes)
-	  {
-	    event->expose.type = GDK_EXPOSE;
-	    event->expose.area = expose_rect;
-	    event->expose.region = gdk_region_rectangle (&expose_rect);
-	    event->expose.window = window;
-	    event->expose.count = xevent->xexpose.count;
-
-	    return_val = TRUE;
-	  }
-	else
-	  {
-	    _gdk_window_process_expose (window, xevent->xexpose.serial, &expose_rect);
-	    return_val = FALSE;
-	  }
-	
-	return_val = FALSE;
+	_gdk_window_process_expose (window, xevent->xexpose.serial, &expose_rect);
+	 return_val = FALSE;
      }
-	
+
      break;
      
    case GraphicsExpose:
@@ -2629,23 +2619,24 @@ fetch_net_wm_check_window (GdkScreen *screen)
  guchar *data;
  Window *xwindow;
  GTimeVal tv;
-  
+  gint error;
+
  screen_x11 = GDK_SCREEN_X11 (screen);
  display = screen_x11->display;

  g_return_if_fail (GDK_DISPLAY_X11 (display)->trusted_client);
  
  g_get_current_time (&tv);
-      
+
  if (ABS  (tv.tv_sec - screen_x11->last_wmspec_check_time) < 15)
    return; /* we've checked recently */

  screen_x11->last_wmspec_check_time = tv.tv_sec;

  data = NULL;
-  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), screen_x11->xroot_window,
+  XGetWindowProperty (screen_x11->xdisplay, screen_x11->xroot_window,
 		      gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTING_WM_CHECK"),
-		      0, G_MAXLONG, False, XA_WINDOW, &type, &format, 
+		      0, G_MAXLONG, False, XA_WINDOW, &type, &format,
 		      &n_items, &bytes_after, &data);
  
  if (type != XA_WINDOW)
@@ -2664,22 +2655,28 @@ fetch_net_wm_check_window (GdkScreen *screen)
    }

  gdk_error_trap_push ();
-  
+
  /* Find out if this WM goes away, so we can reset everything. */
  XSelectInput (screen_x11->xdisplay, *xwindow, StructureNotifyMask);
  gdk_display_sync (display);

-  if (gdk_error_trap_pop () == Success)
+  error = gdk_error_trap_pop ();
+  if (!error)
    {
      screen_x11->wmspec_check_window = *xwindow;
      screen_x11->need_refetch_net_supported = TRUE;
      screen_x11->need_refetch_wm_name = TRUE;
-      
+
      /* Careful, reentrancy */
      _gdk_x11_screen_window_manager_changed (GDK_SCREEN (screen_x11));
    }
+  else if (error == BadWindow)
+    {
+      /* Leftover property, try again immediately, new wm may be starting up */
+      screen_x11->last_wmspec_check_time = 0;
+    }

-  XFree (xwindow);    
+  XFree (xwindow);
 }

 /**
@@ -60,26 +60,24 @@ _gdk_window_move_resize_child (GdkWindow *window,
 			       gint       width,
 			       gint       height)
 {
-  GdkWindowImplX11 *impl;
  GdkWindowObject *obj;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (GDK_IS_WINDOW (window)); 

-  impl = GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);
+  g_return_if_fail (window != NULL);
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
  obj = GDK_WINDOW_OBJECT (window);

  if (width > 65535 ||
      height > 65535)
    {
      g_warning ("Native children wider or taller than 65535 pixels are not supported");
-      
+
      if (width > 65535)
 	width = 65535;
      if (height > 65535)
 	height = 65535;
    }
-  
+
  obj->x = x;
  obj->y = y;
  obj->width = width;
@@ -89,7 +87,6 @@ _gdk_window_move_resize_child (GdkWindow *window,
     the window won't be visible anyway and thus it will be shaped
     to nothing */

-  
  _gdk_x11_window_tmp_unset_parent_bg (window);
  _gdk_x11_window_tmp_unset_bg (window, TRUE);
  XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
@@ -108,7 +105,7 @@ expose_serial_predicate (Display *xdisplay,
 {
  gulong *serial = (gulong *)arg;

-  if (xev->xany.type == Expose)
+  if (xev->xany.type == Expose || xev->xany.type == GraphicsExpose)
    *serial = MIN (*serial, xev->xany.serial);

  return False;
@@ -231,6 +228,7 @@ gdk_window_queue (GdkWindow          *window,

 void
 _gdk_x11_window_queue_translation (GdkWindow *window,
+				   GdkGC     *gc,
 				   GdkRegion *area,
 				   gint       dx,
 				   gint       dy)
@@ -241,6 +239,11 @@ _gdk_x11_window_queue_translation (GdkWindow *window,
  item->u.translate.dx = dx;
  item->u.translate.dy = dy;

+  /* Ensure that the gc is flushed so that we get the right
+     serial from NextRequest in gdk_window_queue, i.e. the
+     the serial for the XCopyArea, not the ones from flushing
+     the gc. */
+  _gdk_x11_gc_flush (gc);
  gdk_window_queue (window, item);
 }

@@ -262,20 +265,18 @@ _gdk_window_process_expose (GdkWindow    *window,
 			    gulong        serial,
 			    GdkRectangle *area)
 {
-  GdkWindowImplX11 *impl;
  GdkRegion *invalidate_region = gdk_region_rectangle (area);
  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
-  impl = GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);

  if (display_x11->translate_queue)
    {
      GList *tmp_list = display_x11->translate_queue->head;
-      
+
      while (tmp_list)
 	{
 	  GdkWindowQueueItem *item = tmp_list->data;
          GList *next = tmp_list->next;
-	  
+
 	  /* an overflow-safe (serial < item->serial) */
 	  if (serial - item->serial > (gulong) G_MAXLONG)
 	    {
@@ -286,7 +287,7 @@ _gdk_window_process_expose (GdkWindow    *window,
 		      if (item->u.translate.area)
 			{
 			  GdkRegion *intersection;
-			  
+
 			  intersection = gdk_region_copy (invalidate_region);
 			  gdk_region_intersect (intersection, item->u.translate.area);
 			  gdk_region_subtract (invalidate_region, intersection);
@@ -314,7 +315,7 @@ _gdk_window_process_expose (GdkWindow    *window,

  if (!gdk_region_empty (invalidate_region))
    _gdk_window_invalidate_for_expose (window, invalidate_region);
-  
+
  gdk_region_destroy (invalidate_region);
 }

@@ -44,6 +44,10 @@ static void              gdk_input_translate_coordinates (GdkDevicePrivate *gdkd
 							  gdouble          *axis_out,
 							  gdouble          *x_out,
 							  gdouble          *y_out);
+static void              gdk_input_update_axes           (GdkDevicePrivate *gdkdev,
+							  gint             axes_count,
+							  gint             first_axis,
+							  gint             *axis_data);
 static guint             gdk_input_translate_state       (guint             state,
 							  guint             device_state);

@@ -111,17 +115,15 @@ gdk_input_device_new (GdkDisplay  *display,

  tmp_name = g_ascii_strdown (gdkdev->info.name, -1);

-  if (!strcmp (tmp_name, "pointer"))
-    gdkdev->info.source = GDK_SOURCE_MOUSE;
-  else if (!strcmp (tmp_name, "wacom") ||
-	   !strcmp (tmp_name, "pen"))
-    gdkdev->info.source = GDK_SOURCE_PEN;
-  else if (!strcmp (tmp_name, "eraser"))
+  if (strstr (tmp_name, "eraser"))
    gdkdev->info.source = GDK_SOURCE_ERASER;
-  else if (!strcmp (tmp_name, "cursor"))
+  else if (strstr (tmp_name, "cursor"))
    gdkdev->info.source = GDK_SOURCE_CURSOR;
-  else
+  else if (strstr (tmp_name, "wacom") ||
+	   strstr (tmp_name, "pen"))
    gdkdev->info.source = GDK_SOURCE_PEN;
+  else
+    gdkdev->info.source = GDK_SOURCE_MOUSE;

  g_free(tmp_name);

@@ -137,7 +139,8 @@ gdk_input_device_new (GdkDisplay  *display,
  gdkdev->info.has_cursor = 0;
  gdkdev->needs_update = FALSE;
  gdkdev->claimed = FALSE;
-  gdkdev->button_state = 0;
+  memset(gdkdev->button_state, 0, sizeof (gdkdev->button_state));
+  gdkdev->button_count = 0;

  class = device->inputclassinfo;
  for (i=0;i<device->num_classes;i++)
@@ -176,6 +179,7 @@ gdk_input_device_new (GdkDisplay  *display,
 	  XValuatorInfo *xvi = (XValuatorInfo *)class;
 	  gdkdev->info.num_axes = xvi->num_axes;
 	  gdkdev->axes = g_new (GdkAxisInfo, xvi->num_axes);
+	  gdkdev->axis_data = g_new0 (gint, xvi->num_axes);
 	  gdkdev->info.axes = g_new0 (GdkDeviceAxis, xvi->num_axes);
 	  for (j=0;j<xvi->num_axes;j++)
 	    {
@@ -267,49 +271,14 @@ _gdk_input_common_find_events (GdkDevicePrivate *gdkdev,
      if (class != 0)
 	  classes[i++] = class;
    }
-  if (mask & GDK_POINTER_MOTION_MASK)
+  if (mask & (GDK_POINTER_MOTION_MASK |
+	      GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
+	      GDK_BUTTON3_MOTION_MASK | GDK_BUTTON_MOTION_MASK))
    {
-      DeviceMotionNotify  (gdkdev->xdevice, gdkdev->motionnotify_type, class);
+      DeviceMotionNotify (gdkdev->xdevice, gdkdev->motionnotify_type, class);
      if (class != 0)
 	  classes[i++] = class;
-    }
-  else
-    if (mask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
-		GDK_BUTTON3_MOTION_MASK | GDK_BUTTON_MOTION_MASK |
-		GDK_POINTER_MOTION_HINT_MASK))
-      {
-	/* Make sure gdkdev->motionnotify_type is set */
-	DeviceMotionNotify  (gdkdev->xdevice, gdkdev->motionnotify_type, class);
-      }
-  if (mask & GDK_BUTTON1_MOTION_MASK)
-    {
-      DeviceButton1Motion  (gdkdev->xdevice, 0, class);
-      if (class != 0)
-	  classes[i++] = class;
-    }
-  if (mask & GDK_BUTTON2_MOTION_MASK)
-    {
-      DeviceButton2Motion  (gdkdev->xdevice, 0, class);
-      if (class != 0)
-	  classes[i++] = class;
-    }
-  if (mask & GDK_BUTTON3_MOTION_MASK)
-    {
-      DeviceButton3Motion  (gdkdev->xdevice, 0, class);
-      if (class != 0)
-	  classes[i++] = class;
-    }
-  if (mask & GDK_BUTTON_MOTION_MASK)
-    {
-      DeviceButtonMotion  (gdkdev->xdevice, 0, class);
-      if (class != 0)
-	  classes[i++] = class;
-    }
-  if (mask & GDK_POINTER_MOTION_HINT_MASK)
-    {
-      /* We'll get into trouble if the macros change, but at least we'll
-	 know about it, and we avoid warnings now */
-      DevicePointerMotionHint (gdkdev->xdevice, 0, class);
+      DeviceStateNotify (gdkdev->xdevice, gdkdev->devicestatenotify_type, class);
      if (class != 0)
 	  classes[i++] = class;
    }
@@ -413,6 +382,19 @@ _gdk_input_common_init (GdkDisplay *display,
  return TRUE;
 }

+static void
+gdk_input_update_axes (GdkDevicePrivate *gdkdev,
+		       gint             axes_count,
+		       gint             first_axis,
+		       gint             *axis_data)
+{
+  int i;
+  g_return_if_fail (first_axis >= 0 && first_axis + axes_count <= gdkdev->info.num_axes);
+
+  for (i = 0; i < axes_count; i++)
+    gdkdev->axis_data[first_axis + i] = axis_data[i];
+}
+
 static void
 gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
 				 GdkWindow        *window,
@@ -427,7 +409,7 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
  int x_axis = 0;
  int y_axis = 0;

-  double device_width, device_height;
+  double device_width, device_height, x_min, y_min;
  double x_offset, y_offset, x_scale, y_scale;

  priv = (GdkWindowObject *) window;
@@ -449,15 +431,34 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
    }

  device_width = gdkdev->axes[x_axis].max_value - gdkdev->axes[x_axis].min_value;
+  if (device_width > 0)
+    {
+      x_min = gdkdev->axes[x_axis].min_value;
+    }
+  else
+    {
+      device_width = gdk_screen_get_width (gdk_drawable_get_screen (window));
+      x_min = 0;
+    }
+
  device_height = gdkdev->axes[y_axis].max_value - gdkdev->axes[y_axis].min_value;
+  if (device_height > 0)
+    {
+      y_min = gdkdev->axes[y_axis].min_value;
+    }
+  else
+    {
+      device_height = gdk_screen_get_height (gdk_drawable_get_screen (window));
+      y_min = 0;
+    }

  if (gdkdev->info.mode == GDK_MODE_SCREEN)
    {
      x_scale = gdk_screen_get_width (gdk_drawable_get_screen (window)) / device_width;
      y_scale = gdk_screen_get_height (gdk_drawable_get_screen (window)) / device_height;

-      x_offset = - impl_window->input_window->root_x;
-      y_offset = - impl_window->input_window->root_y;
+      x_offset = - impl_window->input_window->root_x - priv->abs_x;
+      y_offset = - impl_window->input_window->root_y - priv->abs_y;
    }
  else				/* GDK_MODE_WINDOW */
    {
@@ -506,14 +507,12 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
      switch (gdkdev->info.axes[i].use)
 	{
 	case GDK_AXIS_X:
-	  axis_out[i] = x_offset + x_scale * (axis_data[x_axis] -
-	    gdkdev->axes[x_axis].min_value);
+	  axis_out[i] = x_offset + x_scale * (axis_data[x_axis] - x_min);
 	  if (x_out)
 	    *x_out = axis_out[i];
 	  break;
 	case GDK_AXIS_Y:
-	  axis_out[i] = y_offset + y_scale * (axis_data[y_axis] -
-	    gdkdev->axes[y_axis].min_value);
+	  axis_out[i] = y_offset + y_scale * (axis_data[y_axis] - y_min);
 	  if (y_out)
 	    *y_out = axis_out[i];
 	  break;
@@ -558,22 +557,33 @@ _gdk_input_common_other_event (GdkEvent         *event,
    {
      XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *)(xevent);

+      g_return_val_if_fail (xdbe->button < 256, FALSE);
      if (xdbe->type == gdkdev->buttonpress_type)
 	{
 	  event->button.type = GDK_BUTTON_PRESS;
-	  gdkdev->button_state |= 1 << xdbe->button;
+	  if (!(gdkdev->button_state[xdbe->button/8] & 1 << (xdbe->button%8)))
+	    {
+	      gdkdev->button_state[xdbe->button/8] |= 1 << (xdbe->button%8);
+	      gdkdev->button_count++;
+	    }
 	}
      else
 	{
 	  event->button.type = GDK_BUTTON_RELEASE;
-	  gdkdev->button_state &= ~(1 << xdbe->button);
+	  if (gdkdev->button_state[xdbe->button/8] & 1 << (xdbe->button%8))
+	    {
+	      gdkdev->button_state[xdbe->button/8] &= ~(1 << (xdbe->button%8));
+	      gdkdev->button_count--;
+	    }
 	}
      event->button.device = &gdkdev->info;
      event->button.window = window;
      event->button.time = xdbe->time;

      event->button.axes = g_new (gdouble, gdkdev->info.num_axes);
-      gdk_input_translate_coordinates (gdkdev, window, xdbe->axis_data,
+      gdk_input_update_axes (gdkdev, xdbe->axes_count, xdbe->first_axis,
+			     xdbe->axis_data);
+      gdk_input_translate_coordinates (gdkdev, window, gdkdev->axis_data,
 				       event->button.axes,
 				       &event->button.x, &event->button.y);
      event->button.x_root = event->button.x + priv->abs_x + input_window->root_x;
@@ -675,7 +685,8 @@ _gdk_input_common_other_event (GdkEvent         *event,
      event->motion.device = &gdkdev->info;

      event->motion.axes = g_new (gdouble, gdkdev->info.num_axes);
-      gdk_input_translate_coordinates(gdkdev,window,xdme->axis_data,
+      gdk_input_update_axes (gdkdev, xdme->axes_count, xdme->first_axis, xdme->axis_data);
+      gdk_input_translate_coordinates(gdkdev, window, gdkdev->axis_data,
 				      event->motion.axes,
 				      &event->motion.x,&event->motion.y);
      event->motion.x_root = event->motion.x + priv->abs_x + input_window->root_x;
@@ -706,6 +717,26 @@ _gdk_input_common_other_event (GdkEvent         *event,
      return TRUE;
    }

+  if (xevent->type == gdkdev->devicestatenotify_type)
+    {
+      int i;
+      XDeviceStateNotifyEvent *xdse = (XDeviceStateNotifyEvent *)(xevent);
+      XInputClass *input_class = (XInputClass *)xdse->data;
+      for (i=0; i<xdse->num_classes; i++)
+	{
+	  if (input_class->class == ValuatorClass)
+	    gdk_input_update_axes (gdkdev, gdkdev->info.num_axes, 0,
+				   ((XValuatorState *)input_class)->valuators);
+	  input_class = (XInputClass *)(((char *)input_class)+input_class->length);
+	}
+
+      GDK_NOTE (EVENTS,
+	g_print ("device state notify:\t\twindow: %ld  device: %ld\n",
+		 xdse->window,
+		 xdse->deviceid));
+
+      return FALSE;
+    }
  if (xevent->type == gdkdev->proximityin_type ||
      xevent->type == gdkdev->proximityout_type)
    {
@@ -729,6 +760,55 @@ _gdk_input_common_other_event (GdkEvent         *event,
  return FALSE;			/* wasn't one of our event types */
 }

+gboolean
+_gdk_input_common_event_selected (GdkEvent         *event,
+				  GdkWindow        *window,
+				  GdkDevicePrivate *gdkdev)
+{
+  GdkWindowObject *priv = (GdkWindowObject *) window;
+
+  switch (event->type) {
+    case GDK_BUTTON_PRESS:
+      return priv->extension_events & GDK_BUTTON_PRESS_MASK;
+
+    case GDK_BUTTON_RELEASE:
+      return priv->extension_events & GDK_BUTTON_RELEASE_MASK;
+
+    case GDK_KEY_PRESS:
+      return priv->extension_events & GDK_KEY_PRESS_MASK;
+
+    case GDK_KEY_RELEASE:
+      return priv->extension_events & GDK_KEY_RELEASE_MASK;
+
+    case GDK_MOTION_NOTIFY:
+      if (priv->extension_events & GDK_POINTER_MOTION_MASK)
+	return TRUE;
+      if (gdkdev->button_count && (priv->extension_events & GDK_BUTTON_MOTION_MASK))
+	return TRUE;
+
+      if ((gdkdev->button_state[0] & 1 << 1) && (priv->extension_events & GDK_BUTTON1_MOTION_MASK))
+	return TRUE;
+      if ((gdkdev->button_state[0] & 1 << 2) && (priv->extension_events & GDK_BUTTON2_MOTION_MASK))
+	return TRUE;
+      if ((gdkdev->button_state[0] & 1 << 3) && (priv->extension_events & GDK_BUTTON3_MOTION_MASK))
+	return TRUE;
+
+      return FALSE;
+
+    case GDK_PROXIMITY_IN:
+	  return priv->extension_events & GDK_PROXIMITY_IN_MASK;
+
+    case GDK_PROXIMITY_OUT:
+	  return priv->extension_events & GDK_PROXIMITY_OUT_MASK;
+
+    default:
+      return FALSE;
+  }
+
+
+}
+
+
 gboolean
 _gdk_device_get_history (GdkDevice         *device,
 			 GdkWindow         *window,
@@ -237,7 +237,6 @@ _gdk_input_other_event (GdkEvent *event,
  GdkWindowObject *priv;
  GdkInputWindow *iw;
  GdkDevicePrivate *gdkdev;
-  gint return_val;
  GdkEventType event_type;
  int x, y;
  GdkDisplay *display = GDK_WINDOW_DISPLAY (event_window);
@@ -256,40 +255,43 @@ _gdk_input_other_event (GdkEvent *event,
  if (event_type == GDK_NOTHING)
    return FALSE;

-  window = _gdk_window_get_input_window_for_event (event_window,
-						   event_type,
-						   x, y,
-						   xevent->xany.serial);
  /* If we're not getting any event window its likely because we're outside the
     window and there is no grab. We should still report according to the
     implicit grab though. */
  iw = ((GdkWindowObject *)event_window)->input_window;
-  if (window == NULL)
-    window = iw->button_down_window;

+  if (iw->button_down_window)
+    window = iw->button_down_window;
+  else
+    window = _gdk_window_get_input_window_for_event (event_window,
+                                                     event_type,
+                                                     x, y,
+                                                     xevent->xany.serial);
  priv = (GdkWindowObject *)window;
  if (window == NULL)
    return FALSE;

  if (gdkdev->info.mode == GDK_MODE_DISABLED ||
+      priv->extension_events == 0 ||
      !(gdkdev->info.has_cursor || (priv->extension_events & GDK_ALL_DEVICES_MASK)))
    return FALSE;

  if (!display->ignore_core_events && priv->extension_events != 0)
    gdk_input_check_proximity (GDK_WINDOW_DISPLAY (window));

-  return_val = _gdk_input_common_other_event (event, xevent, window, gdkdev);
+  if (!_gdk_input_common_other_event (event, xevent, window, gdkdev))
+    return FALSE;

-  if (return_val && event->type == GDK_BUTTON_PRESS)
+  if (event->type == GDK_BUTTON_PRESS)
    iw->button_down_window = window;
-  if (return_val && event->type == GDK_BUTTON_RELEASE)
+  if (event->type == GDK_BUTTON_RELEASE && !gdkdev->button_count)
    iw->button_down_window = NULL;

-  if (return_val && event->type == GDK_PROXIMITY_OUT &&
+  if (event->type == GDK_PROXIMITY_OUT &&
      display->ignore_core_events)
    gdk_input_check_proximity (GDK_WINDOW_DISPLAY (window));

-  return return_val;
+  return _gdk_input_common_event_selected(event, window, gdkdev);
 }

 gint
@@ -367,10 +369,11 @@ _gdk_input_grab_pointer (GdkWindow      *window,
 	{
 	  gdkdev = (GdkDevicePrivate *)tmp_list->data;
 	  if (!GDK_IS_CORE (gdkdev) && gdkdev->xdevice &&
-	      ((gdkdev->button_state != 0) || need_ungrab))
+	      ((gdkdev->button_count != 0) || need_ungrab))
 	    {
 	      XUngrabDevice (display_impl->xdisplay, gdkdev->xdevice, time);
-	      gdkdev->button_state = 0;
+	      memset(gdkdev->button_state, 0, sizeof (gdkdev->button_state));
+	      gdkdev->button_count = 0;
 	    }

 	  tmp_list = tmp_list->next;
@@ -120,7 +120,9 @@ gdk_device_dispose (GObject *object)
 	  gdkdev->xdevice = NULL;
 	}
      g_free (gdkdev->axes);
+      g_free (gdkdev->axis_data);
      gdkdev->axes = NULL;
+      gdkdev->axis_data = NULL;
 #endif /* !XINPUT_NONE */

      g_free (gdkdev->info.name);
@@ -266,7 +268,6 @@ gdk_device_get_history  (GdkDevice         *device,
  GdkWindow *impl_window;
  gboolean result = FALSE;
  int tmp_n_events = 0;
-  int i, j;

  g_return_val_if_fail (GDK_WINDOW_IS_X11 (window), FALSE);

@@ -284,9 +285,12 @@ gdk_device_get_history  (GdkDevice         *device,
      if (xcoords)
 	{
 	  GdkWindowObject *priv = (GdkWindowObject *)window;
+          int i, j;
+
 	  coords = _gdk_device_allocate_history (device, tmp_n_events);
 	  j = 0;
-	  for (i=0; i<tmp_n_events; i++)
+
+	  for (i = 0; i < tmp_n_events; i++)
 	    {
 	      if (impl_coord_in_window (window, xcoords[i].x, xcoords[i].y))
 		{
@@ -299,16 +303,32 @@ gdk_device_get_history  (GdkDevice         *device,

 	  XFree (xcoords);

-	  result = TRUE;
+          /* free the events we allocated too much */
+          for (i = j; i < tmp_n_events; i++)
+            {
+              g_free (coords[i]);
+              coords[i] = NULL;
+            }
+
+          tmp_n_events = j;
+
+          if (tmp_n_events > 0)
+            {
+              result = TRUE;
+            }
+          else
+            {
+              gdk_device_free_history (coords, tmp_n_events);
+              coords = NULL;
+            }
 	}
-      else
-	result = FALSE;
    }
  else
    result = _gdk_device_get_history (device, window, start, stop, &coords, &tmp_n_events);

  if (n_events)
    *n_events = tmp_n_events;
+
  if (events)
    *events = coords;
  else if (coords)
@@ -73,6 +73,7 @@ struct _GdkDevicePrivate
 #ifndef XINPUT_NONE
  /* information about the axes */
  GdkAxisInfo *axes;
+  gint *axis_data;

  /* Information about XInput device */
  XDevice       *xdevice;
@@ -82,14 +83,15 @@ struct _GdkDevicePrivate

  int buttonpress_type, buttonrelease_type, keypress_type,
      keyrelease_type, motionnotify_type, proximityin_type, 
-      proximityout_type, changenotify_type;
+      proximityout_type, changenotify_type, devicestatenotify_type;

  /* true if we need to select a different set of events, but
     can't because this is the core pointer */
  gint needs_update;

  /* Mask of buttons (used for button grabs) */
-  gint button_state;
+  char button_state[32];
+  gint button_count;

  /* true if we've claimed the device as active. (used only for XINPUT_GXI) */
  gint claimed;
@@ -178,6 +180,9 @@ gint               _gdk_input_common_other_event        (GdkEvent         *event
 							 XEvent           *xevent,
 							 GdkWindow        *window,
 							 GdkDevicePrivate *gdkdev);
+gboolean	   _gdk_input_common_event_selected     (GdkEvent         *event,
+							 GdkWindow        *window,
+							 GdkDevicePrivate *gdkdev);

 #endif /* !XINPUT_NONE */

@@ -427,7 +427,7 @@ gdk_pixmap_foreign_new (GdkNativeWindow anid)
 * For example in the X backend, a native pixmap handle is an Xlib
 * <type>XID</type>.
 *
- * Return value: the #GdkWindow wrapper for the native window,
+ * Return value: the #GdkPixmap wrapper for the native pixmap,
 *    or %NULL if there is none.
 **/
 GdkPixmap*
@@ -130,6 +130,7 @@ void _gdk_window_process_expose    (GdkWindow     *window,
 gboolean _gdk_x11_window_queue_antiexpose  (GdkWindow *window,
 					    GdkRegion *area);
 void     _gdk_x11_window_queue_translation (GdkWindow *window,
+					    GdkGC     *gc,
 					    GdkRegion *area,
 					    gint       dx,
 					    gint       dy);
@@ -296,7 +296,9 @@ gdk_x11_xatom_to_atom_for_display (GdkDisplay *display,
  GdkAtom virtual_atom = GDK_NONE;
  
  g_return_val_if_fail (GDK_IS_DISPLAY (display), GDK_NONE);
-  g_return_val_if_fail (xatom != None, GDK_NONE);
+
+  if (xatom == None)
+    return GDK_NONE;

  if (display->closed)
    return GDK_NONE;
@@ -377,7 +377,7 @@ get_monitor (GdkScreen *screen,
 *
 * Gets the width in millimeters of the specified monitor, if available.
 *
- * Returns the width of the monitor, or -1 if not available
+ * Returns: the width of the monitor, or -1 if not available
 *
 * Since: 2.14
 */
@@ -989,8 +989,6 @@ _gdk_x11_screen_new (GdkDisplay *display,
  screen_x11->wmspec_check_window = None;
  /* we want this to be always non-null */
  screen_x11->window_manager_name = g_strdup ("unknown");
-  screen_x11->cm_selection_atom = make_cm_atom (screen_number);
-  screen_x11->is_composited = check_is_composited (display, screen_x11);
  
  init_multihead (screen);
  init_randr_support (screen);
@@ -1001,6 +999,22 @@ _gdk_x11_screen_new (GdkDisplay *display,
  return screen;
 }

+/*
+ * It is important that we first request the selection
+ * notification, and then setup the initial state of
+ * is_composited to avoid a race condition here.
+ */
+void
+_gdk_x11_screen_setup (GdkScreen *screen)
+{
+  GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
+
+  screen_x11->cm_selection_atom = make_cm_atom (screen_x11->screen_num);
+  gdk_display_request_selection_notification (screen_x11->display,
+					      screen_x11->cm_selection_atom);
+  screen_x11->is_composited = check_is_composited (screen_x11->display, screen_x11);
+}
+
 /**
 * gdk_screen_is_composited:
 * @screen: a #GdkScreen
@@ -122,6 +122,7 @@ GType       _gdk_screen_x11_get_type (void);
 GdkScreen * _gdk_x11_screen_new      (GdkDisplay *display,
 				      gint	  screen_number);

+void _gdk_x11_screen_setup                  (GdkScreen *screen);
 void _gdk_x11_screen_window_manager_changed (GdkScreen *screen);
 void _gdk_x11_screen_size_changed           (GdkScreen *screen,
 					     XEvent    *event);
@@ -419,7 +419,6 @@ void
 _gdk_windowing_window_init (GdkScreen * screen)
 {
  GdkWindowObject *private;
-  GdkWindowImplX11 *impl;
  GdkDrawableImplX11 *draw_impl;
  GdkScreenX11 *screen_x11;

@@ -436,7 +435,6 @@ _gdk_windowing_window_init (GdkScreen * screen)
  private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
  private->impl_window = private;

-  impl = GDK_WINDOW_IMPL_X11 (private->impl);
  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);
  
  draw_impl->screen = screen;
@@ -455,6 +453,10 @@ _gdk_windowing_window_init (GdkScreen * screen)
  private->width = WidthOfScreen (screen_x11->xscreen);
  private->height = HeightOfScreen (screen_x11->xscreen);
  private->viewable = TRUE;
+
+  /* see init_randr_support() in gdkscreen-x11.c */
+  private->event_mask = GDK_STRUCTURE_MASK;
+
  _gdk_window_update_size (screen_x11->root_window);
  
  _gdk_xid_table_insert (screen_x11->display,
@@ -1597,11 +1599,9 @@ gdk_window_x11_reparent (GdkWindow *window,
 {
  GdkWindowObject *window_private;
  GdkWindowObject *parent_private;
-  GdkWindowObject *old_parent_private;
  GdkWindowImplX11 *impl;

  window_private = (GdkWindowObject*) window;
-  old_parent_private = (GdkWindowObject*)window_private->parent;
  parent_private = (GdkWindowObject*) new_parent;
  impl = GDK_WINDOW_IMPL_X11 (window_private->impl);

@@ -1715,6 +1715,21 @@ gdk_window_x11_restack_under (GdkWindow *window,
  g_free (windows);
 }

+static void
+gdk_window_x11_restack_toplevel (GdkWindow *window,
+				 GdkWindow *sibling,
+				 gboolean   above)
+{
+  XWindowChanges changes;
+
+  changes.sibling = GDK_WINDOW_XID (sibling);
+  changes.stack_mode = above ? Above : Below;
+  XReconfigureWMWindow (GDK_WINDOW_XDISPLAY (window),
+			GDK_WINDOW_XID (window),
+			gdk_screen_get_number (GDK_WINDOW_SCREEN (window)),
+			CWStackMode | CWSibling, &changes);
+}
+
 static void
 gdk_window_x11_lower (GdkWindow *window)
 {
@@ -3200,7 +3215,8 @@ GdkWindow*
 _gdk_windowing_window_at_pointer (GdkDisplay *display,
                                  gint       *win_x,
 				  gint       *win_y,
-				  GdkModifierType *mask)
+				  GdkModifierType *mask,
+				  gboolean   get_toplevel)
 {
  GdkWindow *window;
  GdkScreen *screen;
@@ -3236,6 +3252,10 @@ _gdk_windowing_window_at_pointer (GdkDisplay *display,
      while (xwindow)
 	{
 	  xwindow_last = xwindow;
+	  if (get_toplevel &&
+	      (window = gdk_window_lookup_for_display (display, xwindow)) != NULL &&
+	      GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+	    break;
 	  XQueryPointer (xdisplay, xwindow,
 			 &root, &xwindow, &rootx, &rooty, &winx, &winy, &xmask);
 	}
@@ -3295,6 +3315,10 @@ _gdk_windowing_window_at_pointer (GdkDisplay *display,
      while (xwindow)
 	{
 	  xwindow_last = xwindow;
+	  if (get_toplevel &&
+	      (window = gdk_window_lookup_for_display (display, xwindow)) != NULL &&
+	      GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+	    break;
 	  gdk_error_trap_push ();
 	  XQueryPointer (xdisplay, xwindow,
 			 &root, &xwindow, &rootx, &rooty, &winx, &winy, &xmask);
@@ -3424,9 +3448,6 @@ do_shape_combine_region (GdkWindow       *window,
 	  ? gdk_display_supports_shapes (GDK_WINDOW_DISPLAY (window))
 	  : gdk_display_supports_input_shapes (GDK_WINDOW_DISPLAY (window)))
 	{
-	  if (shape == ShapeBounding)
-	    private->shaped = FALSE;
-	  
 	  if (shape == ShapeBounding)
 	    {
 	      _gdk_x11_window_tmp_unset_parent_bg (window);
@@ -3454,9 +3475,6 @@ do_shape_combine_region (GdkWindow       *window,
      gint n_rects = 0;
      XRectangle *xrects = NULL;

-      if (shape == ShapeBounding)
-	private->shaped = TRUE;
-
      _gdk_region_get_xrectangles (shape_region,
                                   0, 0,
                                   &xrects, &n_rects);
@@ -5513,7 +5531,6 @@ _gdk_windowing_window_set_composited (GdkWindow *window,
 {
 #if defined(HAVE_XCOMPOSITE) && defined(HAVE_XDAMAGE) && defined (HAVE_XFIXES)
  GdkWindowObject *private = (GdkWindowObject *) window;
-  GdkDisplayX11 *x11_display;
  GdkWindowImplX11 *impl;
  GdkDisplay *display;
  Display *dpy;
@@ -5522,7 +5539,6 @@ _gdk_windowing_window_set_composited (GdkWindow *window,
  impl = GDK_WINDOW_IMPL_X11 (private->impl);

  display = gdk_screen_get_display (GDK_DRAWABLE_IMPL_X11 (impl)->screen);
-  x11_display = GDK_DISPLAY_X11 (display);
  dpy = GDK_DISPLAY_XDISPLAY (display);
  xid = GDK_WINDOW_XWINDOW (private);

@@ -5568,6 +5584,7 @@ gdk_window_impl_iface_init (GdkWindowImplIface *iface)
  iface->raise = gdk_window_x11_raise;
  iface->lower = gdk_window_x11_lower;
  iface->restack_under = gdk_window_x11_restack_under;
+  iface->restack_toplevel = gdk_window_x11_restack_toplevel;
  iface->move_resize = gdk_window_x11_move_resize;
  iface->set_background = gdk_window_x11_set_background;
  iface->set_back_pixmap = gdk_window_x11_set_back_pixmap;
@@ -40,6 +40,8 @@ extern Display          *gdk_display;

 Display *gdk_x11_drawable_get_xdisplay    (GdkDrawable *drawable);
 XID      gdk_x11_drawable_get_xid         (GdkDrawable *drawable);
+GdkDrawable *gdk_x11_window_get_drawable_impl (GdkWindow *window);
+GdkDrawable *gdk_x11_pixmap_get_drawable_impl (GdkPixmap *pixmap);
 Display *gdk_x11_image_get_xdisplay       (GdkImage    *image);
 XImage  *gdk_x11_image_get_ximage         (GdkImage    *image);
 Display *gdk_x11_colormap_get_xdisplay    (GdkColormap *colormap);
@@ -105,10 +107,10 @@ gint     gdk_x11_get_default_screen       (void);

 #define GDK_DISPLAY_XDISPLAY(display) (gdk_x11_display_get_xdisplay (display))

-#define GDK_WINDOW_XDISPLAY(win)      (gdk_x11_drawable_get_xdisplay (((GdkWindowObject *)win)->impl))
+#define GDK_WINDOW_XDISPLAY(win)      (gdk_x11_drawable_get_xdisplay (gdk_x11_window_get_drawable_impl (win)))
 #define GDK_WINDOW_XID(win)           (gdk_x11_drawable_get_xid (win))
 #define GDK_WINDOW_XWINDOW(win)       (gdk_x11_drawable_get_xid (win))
-#define GDK_PIXMAP_XDISPLAY(win)      (gdk_x11_drawable_get_xdisplay (((GdkPixmapObject *)win)->impl))
+#define GDK_PIXMAP_XDISPLAY(win)      (gdk_x11_drawable_get_xdisplay (gdk_x11_pixmap_get_drawable_impl (win)))
 #define GDK_PIXMAP_XID(win)           (gdk_x11_drawable_get_xid (win))
 #define GDK_DRAWABLE_XDISPLAY(win)    (gdk_x11_drawable_get_xdisplay (win))
 #define GDK_DRAWABLE_XID(win)         (gdk_x11_drawable_get_xid (win))
@@ -77,14 +77,16 @@ _gdk_xid_table_remove (GdkDisplay *display,
    g_hash_table_remove (display_x11->xid_ht, &xid);
 }

-/** 
+/**
 * gdk_xid_table_lookup_for_display:
 * @display: the #GdkDisplay.
 * @xid: an X id.
 *
 * Returns the GDK object associated with the given X id.
 *
- * Returns: a GDK object associated with the given X id.
+ * Return value: the associated Gdk object, which may be a #GdkPixmap,
+ *     a #GdkWindow or a #GdkFont or %NULL if no object is associated
+ *     with the X id.
 *
 * Since: 2.2
 */
@@ -109,12 +111,14 @@ gdk_xid_table_lookup_for_display (GdkDisplay  *display,
 /**
 * gdk_xid_table_lookup:
 * @xid: an X id.
- * 
- * Returns the Gdk object associated with the given X id.
- * 
+ *
+ * Returns the Gdk object associated with the given X id for the default
+ * display.
+ *
 * Return value: the associated Gdk object, which may be a #GdkPixmap,
- * a #GdkWindow or a #GdkFont.
- **/
+ *     a #GdkWindow or a #GdkFont or %NULL if no object is associated
+ *     with the X id.
+ */
 gpointer
 gdk_xid_table_lookup (XID xid)
 {
@@ -3294,6 +3294,7 @@ gtk_radio_tool_button_set_group
 #if IN_FILE(__GTK_RANGE_C__)
 gtk_range_get_adjustment
 gtk_range_get_fill_level
+gtk_range_get_flippable
 gtk_range_get_inverted
 gtk_range_get_lower_stepper_sensitivity
 gtk_range_get_restrict_to_fill_level
@@ -3304,6 +3305,7 @@ gtk_range_get_upper_stepper_sensitivity
 gtk_range_get_value
 gtk_range_set_adjustment
 gtk_range_set_fill_level
+gtk_range_set_flippable
 gtk_range_set_increments
 gtk_range_set_inverted
 gtk_range_set_lower_stepper_sensitivity
@@ -4988,6 +4990,7 @@ gtk_widget_get_pango_context
 gtk_widget_get_parent
 gtk_widget_get_parent_window
 gtk_widget_get_pointer
+gtk_widget_get_receives_default
 gtk_widget_get_root_window
 gtk_widget_get_screen
 gtk_widget_get_sensitive
@@ -5016,6 +5019,8 @@ gtk_widget_intersect
 gtk_widget_is_ancestor
 gtk_widget_is_focus
 gtk_widget_is_sensitive
+gtk_widget_is_toplevel
+gtk_widget_is_drawable
 gtk_widget_keynav_failed
 gtk_widget_list_accel_closures
 gtk_widget_list_mnemonic_labels
@@ -5058,6 +5063,7 @@ gtk_widget_reset_rc_styles
 gtk_widget_reset_shapes
 gtk_widget_send_expose
 gtk_widget_set_accel_path
+gtk_widget_set_allocation
 gtk_widget_set_app_paintable
 gtk_widget_set_child_visible
 gtk_widget_set_colormap
@@ -5073,6 +5079,7 @@ gtk_widget_set_name
 gtk_widget_set_no_show_all
 gtk_widget_set_parent
 gtk_widget_set_parent_window
+gtk_widget_set_receives_default
 gtk_widget_set_redraw_on_allocate
 gtk_widget_set_scroll_adjustments
 gtk_widget_set_sensitive
@@ -5083,6 +5090,7 @@ gtk_widget_set_tooltip_markup
 gtk_widget_set_tooltip_text
 gtk_widget_set_tooltip_window
 gtk_widget_set_visible
+gtk_widget_set_window
 gtk_widget_shape_combine_mask
 gtk_widget_input_shape_combine_mask
 gtk_widget_show
@@ -380,7 +380,12 @@ parse_object (GMarkupParseContext  *context,
          data->inside_requested_object = TRUE;
        }
      else
-        return;
+        {
+          g_free (object_class);
+          g_free (object_id);
+          g_free (constructor);
+          return;
+        }
    }

  object_info = g_slice_new0 (ObjectInfo);
@@ -404,7 +409,8 @@ parse_object (GMarkupParseContext  *context,
      return;
    }

-  g_hash_table_insert (data->object_ids, object_id, GINT_TO_POINTER (line));
+
+  g_hash_table_insert (data->object_ids, g_strdup (object_id), GINT_TO_POINTER (line));
 }

 static void
@@ -1128,7 +1134,8 @@ _gtk_builder_parser_parse_buffer (GtkBuilder   *builder,
  data->builder = builder;
  data->filename = filename;
  data->domain = g_strdup (domain);
-  data->object_ids = g_hash_table_new (g_str_hash, g_str_equal);
+  data->object_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
+					    (GDestroyNotify)g_free, NULL);

  data->requested_objects = NULL;
  if (requested_objs)
@@ -887,10 +887,12 @@ gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
 *
 * Returns the cell renderer's visibility.
 *
+ * Returns: %TRUE if the cell renderer is visible
+ *
 * Since: 2.18
- **/
+ */
 gboolean
-gtk_cell_renderer_get_visible  (GtkCellRenderer *cell)
+gtk_cell_renderer_get_visible (GtkCellRenderer *cell)
 {
  g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);

@@ -925,10 +927,12 @@ gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
 *
 * Returns the cell renderer's sensitivity.
 *
+ * Returns: %TRUE if the cell renderer is sensitive
+ *
 * Since: 2.18
- **/
+ */
 gboolean
-gtk_cell_renderer_get_sensitive  (GtkCellRenderer *cell)
+gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell)
 {
  g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);

@@ -24,6 +24,7 @@
 #include "gtkcellrendereraccel.h"
 #include "gtklabel.h"
 #include "gtkeventbox.h"
+#include "gtkmain.h"
 #include "gtkprivate.h"
 #include "gdk/gdkkeysyms.h"
 #include "gtkalias.h"
@@ -470,6 +471,7 @@ grab_key_callback (GtkWidget            *widget,
  edited = TRUE;

 out:
+  gtk_grab_remove (accel->grab_widget);
  gdk_display_keyboard_ungrab (display, event->time);
  gdk_display_pointer_ungrab (display, event->time);

@@ -497,6 +499,7 @@ ungrab_stuff (GtkWidget            *widget,
 {
  GdkDisplay *display = gtk_widget_get_display (widget);

+  gtk_grab_remove (accel->grab_widget);
  gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
  gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);

@@ -606,6 +609,8 @@ gtk_cell_renderer_accel_start_editing (GtkCellRenderer      *cell,
  
  gtk_widget_show_all (accel->edit_widget);

+  gtk_grab_add (accel->grab_widget);
+
  g_signal_connect (G_OBJECT (accel->edit_widget), "unrealize",
                    G_CALLBACK (ungrab_stuff), accel);
  
@@ -271,6 +271,21 @@ gtk_cell_renderer_spin_key_press_event (GtkWidget   *widget,
  return FALSE;
 }

+static gboolean
+gtk_cell_renderer_spin_button_press_event (GtkWidget      *widget,
+                                           GdkEventButton *event,
+                                           gpointer        user_data)
+{
+  /* Block 2BUTTON and 3BUTTON here, so that they won't be eaten
+   * by tree view.
+   */
+  if (event->type == GDK_2BUTTON_PRESS
+      || event->type == GDK_3BUTTON_PRESS)
+    return TRUE;
+
+  return FALSE;
+}
+
 static GtkCellEditable *
 gtk_cell_renderer_spin_start_editing (GtkCellRenderer     *cell,
 				      GdkEvent            *event,
@@ -296,6 +311,10 @@ gtk_cell_renderer_spin_start_editing (GtkCellRenderer     *cell,
  spin = gtk_spin_button_new (priv->adjustment,
 			      priv->climb_rate, priv->digits);

+  g_signal_connect (spin, "button-press-event",
+                    G_CALLBACK (gtk_cell_renderer_spin_button_press_event),
+                    NULL);
+
  if (cell_text->text)
    gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin),
 			       g_ascii_strtod (cell_text->text, NULL));
@@ -349,7 +349,7 @@ gtk_cell_renderer_toggle_render (GtkCellRenderer      *cell,
  else
    shadow = celltoggle->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;

-  if (!cell->sensitive)
+  if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE || !cell->sensitive)
    {
      state = GTK_STATE_INSENSITIVE;
    }
@@ -438,6 +438,8 @@ gtk_cell_view_expose (GtkWidget      *widget,

  if (GTK_WIDGET_STATE (widget) == GTK_STATE_PRELIGHT)
    state = GTK_CELL_RENDERER_PRELIT;
+  else if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE)
+    state = GTK_CELL_RENDERER_INSENSITIVE;
  else
    state = 0;
      
@@ -5925,8 +5925,14 @@ draw_rows (GtkCList     *clist,
    }

  if (!area)
-    gdk_window_clear_area (clist->clist_window, 0,
-			   ROW_TOP_YPIXEL (clist, i), 0, 0);
+    {
+      int w, h, y;
+      gdk_drawable_get_size (GDK_DRAWABLE (clist->clist_window), &w, &h);
+      y = ROW_TOP_YPIXEL (clist, i);
+      gdk_window_clear_area (clist->clist_window,
+			     0, y,
+			     w, h - y);
+    }
 }

 static void                          
@@ -379,6 +379,8 @@ static gboolean gtk_combo_box_menu_button_press    (GtkWidget        *widget,
                                                    gpointer          user_data);
 static void     gtk_combo_box_menu_item_activate   (GtkWidget        *item,
                                                    gpointer          user_data);
+
+static void     gtk_combo_box_update_sensitivity   (GtkComboBox      *combo_box);
 static void     gtk_combo_box_menu_row_inserted    (GtkTreeModel     *model,
                                                    GtkTreePath      *path,
                                                    GtkTreeIter      *iter,
@@ -2862,6 +2864,7 @@ gtk_combo_box_menu_setup (GtkComboBox *combo_box,
  gtk_combo_box_sync_cells (combo_box, GTK_CELL_LAYOUT (priv->column));

  gtk_combo_box_update_title (combo_box);
+  gtk_combo_box_update_sensitivity (combo_box);
 }

 static void
@@ -3215,6 +3218,11 @@ gtk_combo_box_update_sensitivity (GtkComboBox *combo_box)
    }

  gtk_widget_set_sensitive (combo_box->priv->button, sensitive);
+
+  /* In list-mode, we also need to update sensitivity of the event box */
+  if (GTK_IS_TREE_VIEW (combo_box->priv->tree_view)
+      && combo_box->priv->cell_view)
+    gtk_widget_set_sensitive (combo_box->priv->box, sensitive);
 }

 static void
@@ -3755,6 +3763,8 @@ gtk_combo_box_list_setup (GtkComboBox *combo_box)
                    combo_box);

  gtk_widget_show (priv->tree_view);
+
+  gtk_combo_box_update_sensitivity (combo_box);
 }

 static void
@@ -368,9 +368,10 @@ void
 gtk_combo_box_entry_set_text_column (GtkComboBoxEntry *entry_box,
                                     gint              text_column)
 {
+  GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (entry_box));
+
  g_return_if_fail (text_column >= 0);
-  g_return_if_fail (text_column < gtk_tree_model_get_n_columns (gtk_combo_box_get_model (GTK_COMBO_BOX (entry_box))));
-  g_return_if_fail (entry_box->priv->text_column == -1);
+  g_return_if_fail (model == NULL || text_column < gtk_tree_model_get_n_columns (model));

  entry_box->priv->text_column = text_column;

@@ -375,14 +375,11 @@ _gtk_custom_paper_unix_dialog_new (GtkWindow   *parent,

  result = g_object_new (GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG,
                         "title", title,
+                         "transient-for", parent,
+                         "modal", parent != NULL,
+                         "destroy-with-parent", TRUE,
                         NULL);

-  if (parent)
-    {
-      gtk_window_set_modal (GTK_WINDOW (result), TRUE);
-      gtk_window_set_transient_for (GTK_WINDOW (result), parent);
-    }
-
  return result;
 }

@@ -63,6 +63,11 @@ static GtkDragDestInfo *gtk_drag_get_dest_info  (GdkDragContext   *context,
 						 gboolean          create);
 static void gtk_drag_source_site_destroy        (gpointer           data);

+static GtkDragSourceInfo *gtk_drag_get_source_info (GdkDragContext *context,
+						    gboolean        create);
+
+extern GdkDragContext *gdk_quartz_drag_source_context (); /* gdk/quartz/gdkdnd-quartz.c */
+
 struct _GtkDragSourceSite 
 {
  GdkModifierType    start_button_mask;
@@ -89,13 +94,16 @@ struct _GtkDragSourceSite

 struct _GtkDragSourceInfo 
 {
+  GtkWidget         *source_widget;
  GtkWidget         *widget;
  GtkTargetList     *target_list; /* Targets for drag data */
  GdkDragAction      possible_actions; /* Actions allowed by source */
  GdkDragContext    *context;	  /* drag context */
-
+  NSEvent           *nsevent;     /* what started it */
  gint hot_x, hot_y;		  /* Hot spot for drag */
  GdkPixbuf         *icon_pixbuf;
+  gboolean           success;
+  gboolean           delete;
 };

 struct _GtkDragDestSite 
@@ -233,19 +241,24 @@ gtk_drag_get_data (GtkWidget      *widget,
    }      
 }

-
-GtkWidget *
-gtk_drag_get_source_widget (GdkDragContext *context)
-{
-  return NULL;
-}
-
 void 
 gtk_drag_finish (GdkDragContext *context,
 		 gboolean        success,
 		 gboolean        del,
 		 guint32         time)
 {
+  GtkDragSourceInfo *info;
+  GdkDragContext* source_context = gdk_quartz_drag_source_context ();
+
+  if (source_context)
+    {
+      info = gtk_drag_get_source_info (source_context, FALSE);
+      if (info)
+        {
+          info->success = success;
+          info->delete = del;
+        }
+    }
 }

 static void
@@ -307,6 +320,22 @@ gtk_drag_clear_source_info (GdkDragContext *context)
  g_object_set_qdata (G_OBJECT (context), dest_info_quark, NULL);
 }

+GtkWidget *
+gtk_drag_get_source_widget (GdkDragContext *context)
+{
+  GtkDragSourceInfo *info;
+  GdkDragContext* real_source_context = gdk_quartz_drag_source_context();
+
+  if (!real_source_context)
+    return NULL;
+
+  info = gtk_drag_get_source_info (real_source_context, FALSE);
+  if (!info)
+     return NULL;
+
+  return info->source_widget;
+}
+
 /*************************************************************
 * gtk_drag_highlight_expose:
 *     Callback for expose_event for highlighted widgets.
@@ -1031,6 +1060,45 @@ gtk_drag_dest_find_target (GtkWidget      *widget,
  return GDK_NONE;
 }

+static gboolean
+gtk_drag_begin_idle (gpointer arg)
+{
+  GdkDragContext* context = (GdkDragContext*) arg;
+  GtkDragSourceInfo* info = gtk_drag_get_source_info (context, FALSE);
+  NSWindow *nswindow;
+  NSPasteboard *pasteboard;
+  GtkDragSourceOwner *owner;
+  NSPoint point;
+
+  g_assert (info != NULL);
+
+  pasteboard = [NSPasteboard pasteboardWithName:NSDragPboard];
+  owner = [[GtkDragSourceOwner alloc] initWithInfo:info];
+
+  [pasteboard declareTypes:_gtk_quartz_target_list_to_pasteboard_types (info->target_list) owner:owner];
+
+  if ((nswindow = get_toplevel_nswindow (info->source_widget)) == NULL)
+     return FALSE;
+  
+  /* Ref the context. It's unreffed when the drag has been aborted */
+  g_object_ref (info->context);
+
+  /* FIXME: If the event isn't a mouse event, use the global cursor position instead */
+  point = [info->nsevent locationInWindow];
+
+  [nswindow dragImage:_gtk_quartz_create_image_from_pixbuf (info->icon_pixbuf)
+                   at:point
+               offset:NSMakeSize(0, 0)
+                event:info->nsevent
+           pasteboard:pasteboard
+               source:nswindow
+            slideBack:YES];
+
+  [info->nsevent release];
+
+  return FALSE;
+}
+
 static GdkDragContext *
 gtk_drag_begin_internal (GtkWidget         *widget,
 			 GtkDragSourceSite *site,
@@ -1042,16 +1110,13 @@ gtk_drag_begin_internal (GtkWidget         *widget,
  GtkDragSourceInfo *info;
  GdkDragContext *context;
  NSWindow *nswindow;
-  NSPasteboard *pasteboard;
-  GtkDragSourceOwner *owner;
-  NSEvent *nsevent;
-  NSPoint point;

  context = gdk_drag_begin (NULL, NULL);
  context->is_source = TRUE;

  info = gtk_drag_get_source_info (context, TRUE);
  
+  info->source_widget = g_object_ref (widget);
  info->widget = g_object_ref (widget);
  info->target_list = target_list;
  gtk_target_list_ref (target_list);
@@ -1086,13 +1151,13 @@ gtk_drag_begin_internal (GtkWidget         *widget,
 		GdkPixbuf *pixbuf;

 		pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 1, 1);
-		gdk_pixbuf_fill (pixbuf, 0xffffff);
-	    
-		gtk_drag_set_icon_pixbuf (context,
-					  pixbuf,
+ 		gdk_pixbuf_fill (pixbuf, 0xffffff);
+
+ 		gtk_drag_set_icon_pixbuf (context,
+ 					  pixbuf,
 					  0, 0);

-		g_object_unref (pixbuf);
+ 		g_object_unref (pixbuf);
 	      }
 	    break;
 	  case GTK_IMAGE_PIXBUF:
@@ -1117,31 +1182,17 @@ gtk_drag_begin_internal (GtkWidget         *widget,
 	  }
    }

-  gdk_pointer_ungrab (0);
-  
-  pasteboard = [NSPasteboard pasteboardWithName:NSDragPboard];
-  owner = [[GtkDragSourceOwner alloc] initWithInfo:info];
-
-  [pasteboard declareTypes:_gtk_quartz_target_list_to_pasteboard_types (target_list) owner:owner];
-
-  /* Ref the context. It's unreffed when the drag has been aborted */
-  g_object_ref (info->context);
-
  nswindow = get_toplevel_nswindow (widget);
+  info->nsevent = [nswindow currentEvent];
+  [info->nsevent retain];

-  /* FIXME: If the event isn't a mouse event, use the global cursor position instead */
-  nsevent = [nswindow currentEvent];
-  point = [nsevent locationInWindow];
+  /* drag will begin in an idle handler to avoid nested run loops */

-  [nswindow dragImage:_gtk_quartz_create_image_from_pixbuf (info->icon_pixbuf)
-                   at:point
-               offset:NSMakeSize(0, 0)
-                event:nsevent
-           pasteboard:pasteboard
-               source:nswindow
-            slideBack:YES];
+  g_idle_add_full (G_PRIORITY_HIGH_IDLE, gtk_drag_begin_idle, context, NULL);

-  return info->context;
+  gdk_pointer_ungrab (0);
+
+  return context;
 }

 GdkDragContext *
@@ -1773,6 +1824,9 @@ gtk_drag_source_info_destroy (GtkDragSourceInfo *info)
  g_signal_emit_by_name (info->widget, "drag-end", 
 			 info->context);

+  if (info->source_widget)
+    g_object_unref (info->source_widget);
+
  if (info->widget)
    g_object_unref (info->widget);

@@ -1794,6 +1848,10 @@ drag_drop_finished_idle_cb (gpointer data)
 static void
 gtk_drag_drop_finished (GtkDragSourceInfo *info)
 {
+  if (info->success && info->delete)
+    g_signal_emit_by_name (info->source_widget, "drag-data-delete",
+                           info->context);
+
  /* Workaround for the fact that the NS API blocks until the drag is
   * over. This way the context is still valid when returning from
   * drag_begin, even if it will still be quite useless. See bug #501588.
--- a/Show More
+++ b/Show More