Get master's fixes for the file chooser

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>

NEWS

@@ -1,3 +1,445 @@
+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
+==============================================
+
+* Client-side windows: a number of regressions related to embedding
+  have been fixed
+
+* Printing: The file backend supports SVG output
+
+* Minor API additions:
+ - GtkIconView gained an icon-padding property that can be used to fine-tune
+   how much space each column needs
+ - GtkTreeViewColumn grew a sort-column-id property that can be used to set
+   up sort columns in GtkBuilder files
+ - GdkWindow gained a cursor property and associated getter
+ - GtkFileChooser has a create-folders property to allow disabling the
+   "New Folder" button
+ - gtk_print_operation_get_n_pages_to_print: returns the number of pages
+   that are being printed
+ - New getters and setters as part of the GSEAL effort:
+   gtk_widget_get_allocation, gtk_widget_get_visible, gtk_widget_set_visible
+
+* Bugs fixed:
+ 589336 Add GtkTreeViewColumn:sort-column-id property
+ 534462 Disable interactive search in the file chooser's shortcuts pane
+ 161489 n the file chooser, let the left/right arrow keys switch focus...
+ 514260 Better filtering for "Recently Used" files
+ 509650	ATK_STATE_SHOWING state is not set properly on menu items
+ 586374 code does not follow documentation (-> carshes when using...
+ 590442 csw broke gvim x11 embedding
+ 498010 gtk_tree_view_set_cursor fails if model!=NULL
+ 555109 Synthesized crossing events should have proper coordinates
+ 570516 Can't disable folder creation
+ 573321 additional check in gtk_tree_model_filter_convert_child_i...
+ 576601 Double clicking prints to the wrong printer
+ 586100 ITEM_PADDING breaks vertical icon views
+ 588438 awn uses 100% cpu with gtk+ 2.17.3 (csw)
+ 589732 behavior change of gdk_window_get_type_hint
+ 589745 Apply message in GtkAssistant
+ 590084 print to FILE with multiple pages per sheet has bad results
+ 590086 configure.in is broken on non-X platforms
+ 590309 Default cover pages for CUPS printers incorrectly set
+ 590448 [win32] build fails because gdk-pixbuf manges a path
+ 590959 Set child_has_focus flag properly
+ 591288 compat problem with draw_drawable being NULL
+ 539377 Unnecessary warnings when GtkTreeView is not realized.
+ 546005 priv->tree is not created for unrealized (I think) treeview
+ 564695 Pressing enter key in print to file "Name" box does not p...
+ 591218 Remove some unused variables
+ 357655 "Print to SVG file" for GtkPrintOperation
+ 591462 gdk_window_set_cursor doesn't work on the root window
+
+* Updated translations:
+ Basque
+ Brazilian Portuguese
+ Breton
+ Estonian
+ Galician
+ Hebrew
+ Norwegian bokmål
+ Spanish
+ Swedish
+
+
+Overview of Changes from GTK+ 2.17.5 to 2.17.6
+==============================================
+
+* Client-side windows:
+ - Several optimizations, such as client-side tracking of
+   viewable windows
+ - Clipping for drawing pixbufs on windows has been fixed
+ - Rendering to large subwindows has been fixed
+
+* Changes that are relevant for translators:
+ - Markup has been removed from several strings
+
+* Bugs fixed:
+ 588398 Leak with testgtk::preview_(color|gray) and more
+ 588943 set correct selection before emitting cursor-changed...
+ 588076 Gnumeric fonts stopped working on upgrading gtk+ 2.17.2 -...
+ 574674	GtkMenuItem gets Selected and Focused states when SelectC...
+ 582674 Menu item and menu accessibles retain "showing" state aft...
+ 588553 [csw] gdk_draw_pixbuf doesnt draw outside expose events s...
+ 588897 Strange include x11/gdkx.h
+ 588958 Typo in startup-id window property
+ 589035 Context needed for a propoer translation
+ 589275 [csw] Trying to destroy NULL regions
+ 588964 Remove markup from translatable string in gtkfilechooserd...
+ 587337 Suggest to use Glade instead gtk-builder-convert script
+
+* Updated translations:
+ Estonian
+ French
+ Spanish
+ Swedish
+ Thai
+
+
+Overview of Changes from GTK+ 2.17.4 to 2.17.5
+==============================================
+
+* Client-side windows:
+ - Quite a few fixes have happened for the win32 and directfb backends
+
+* GSEAL:
+ - Accessors have been added for sealed members in GtkCellRenderer and
+   GtkWidget
+
+* Changes that are relevant for distributors:
+ - The jpeg2000 pixbuf loader is now optional. Pass --with-libjasper
+   to configure to build it
+
+* Bugs fixed
+ 588373 Menus broken by client-side-windows
+ 588379 testgtk::panes does not change the cursor on mouse over
+ 588388 shape rendering is back
+ 588461 gtk_editable_get_chars() behaviour change in 2.17.4
+ 588666 Incorrect clamping of max_length
+ 588665 insert-text signal is not emitted
+ 588395 Crash when opening a GtkBuilder file
+ 524066 Mandatory jpeg2000?
+ 527583 GtkAssistant should set buttons as default widget
+ 588694 Missing % in C code
+ 588484 Iconview DnD fails when Destination is empty
+ 583522 Trivial error in GtkBuilder migration documentation
+ 150951 collapsed save dialog needs to indicate filesystem...
+
+* Updated translations:
+ Brazilian Portuguese
+ Norwegian bokmål
+ Spanish
+ Traditional Chinese
+
+
+Overview of Changes from GTK+ 2.17.3 to 2.17.4
+==============================================
+
+* GtkEntry now has model-view separation, with GtkEntryBuffer.
+  One intended use case for this is to support 'secure memory'
+  for password entries.
+
+* The print dialog can now optionally include the page setup
+  controls, avoiding the need for a separate page setup dialog
+  in many applications.
+
+* Coloring of visited links in GtkLabel can now be turned off, with
+  the ::track-visited-links property.
+
+* Support for clipmasks in gdk_draw_pixbuf now works, this will
+  introduce visual changes in code that uses clipmasks when drawing
+  pixbufs. However, since this never worked that is unlikely to happen.
+  Old code using gdk_pixbuf_render_threshold_alpha masks when rendering
+  pixbufs will now produce truncated results at the edges.
+
+* A number of regressions from the client-side window merge have
+  been fixed.
+
+* The directfb GDK backend has been fixed to build with csw.
+
+* Bugs fixed:
+ 569393 gtk calendar localization YM note is wrong
+ 587559 Popup closes immediately
+ 551409 Print dialog should include page size and orientation
+ 588115 gvim clipboard broken
+
+* Updated translations:
+ Dutch
+ Estonian
+ Spanish
+ Ukrainian
+ Vietnamese
+
+
 Overview of Changes from GTK+ 2.17.2 to 2.17.3
 ==============================================
 

README.in

@@ -34,6 +34,21 @@ Release notes for 2.18
   old custom_widget. Custom_widget does not get destroyed when the
   tooltip goes away.
 
+* 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
 ======================
@@ -427,8 +442,4 @@ report.
 Otherwise, enter a new bug report that describes the patch, and attach
 the patch to that bug report.
 
-Bug reports containing patches should include the PATCH keyword in their
-keyword fields. If the patch adds to or changes the GTK+ programming
-interface, the API keyword should also be included.
-  
-Patches should be in unified diff form. (The -u option to GNU diff.)
+Patches should be in unified diff form. (The -up option to GNU diff.)

README.win32

@@ -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>

autogen.sh

@@ -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

configure.in

@@ -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], [3])
-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
 
@@ -825,12 +831,13 @@ AC_ARG_WITH(libtiff,
             [AC_HELP_STRING([--without-libtiff],
                             [disable TIFF loader for gdk-pixbuf])])
 AC_ARG_WITH(libjasper,
-            [AC_HELP_STRING([--without-libjasper],
-                            [disable JPEG2000 loader for gdk-pixbuf])])
+            [AC_HELP_STRING([--with-libjasper],
+                            [enable JPEG2000 loader for gdk-pixbuf])])
 
 AC_ARG_ENABLE(gdiplus,
-            [AC_HELP_STRING([--disable-gdiplus],
-                            [disable GDI+ loaders for gdk-pixbuf])])
+            [AC_HELP_STRING([--enable-gdiplus],
+                            [enble GDI+ loaders for gdk-pixbuf (currently known to be broken)])],,
+	    [enable_gdiplus=no])
 
 AM_CONDITIONAL(BUILD_GDIPLUS_LOADERS, [ test x$os_win32 = xyes && test x$enable_gdiplus != xno ])
 
@@ -940,11 +947,11 @@ dnl Test for libpng
   fi
 
 dnl Test for libjasper
-  if test x$with_libjasper != xno && test -z "$LIBJASPER"; then
+  if test x$with_libjasper = xyes && test -z "$LIBJASPER"; then
     AC_CHECK_LIB(jasper, jas_init, LIBJASPER=-ljasper, [], -ljpeg)
   fi
 
-  if test x$with_libjasper != xno && test -z "$LIBJASPER"; then
+  if test x$with_libjasper = xyes && test -z "$LIBJASPER"; then
      AC_MSG_ERROR([
 *** Checks for JPEG2000 loader failed. You can build without it by passing 
 *** --without-libjasper to configure])
@@ -1317,7 +1324,6 @@ GDK_PIXBUF_XLIB_PACKAGES=
 GDK_PIXBUF_XLIB_EXTRA_CFLAGS=
 GDK_PIXBUF_XLIB_EXTRA_LIBS=
 	
-X_PACKAGES=fontconfig
 GDK_EXTRA_LIBS="$GDK_WLIBS"
 GDK_EXTRA_CFLAGS=
 	
@@ -1326,6 +1332,8 @@ GTK_DEP_PACKAGES_FOR_X=
 GTK_DEP_LIBS_FOR_X=
 
 if test "x$gdktarget" = "xx11"; then
+  X_PACKAGES=fontconfig
+
   #
   # We use fontconfig very peripherally when decoding the default
   # settings.
@@ -1626,6 +1634,8 @@ if test "x$gdktarget" = "xx11"; then
 
   AM_CONDITIONAL(USE_X11, true)
 else
+  XPACKAGES=
+
   AM_CONDITIONAL(XINPUT_XFREE, false)
   AM_CONDITIONAL(USE_X11, false)
   AM_CONDITIONAL(HAVE_X11R6, false)
@@ -1832,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`
 
@@ -1855,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+
@@ -1885,23 +1902,27 @@ 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"
-			  
+CPPFLAGS="$CPPFLAGS $GTK_DEP_CFLAGS $GDK_DEP_CFLAGS"
+
 AC_CHECK_HEADER(cairo-pdf.h,,AC_MSG_ERROR([
 *** Can't find cairo-pdf.h. You must build Cairo with the pdf
 *** backend enabled.]))

demos/gtk-demo/Makefile.am

@@ -17,6 +17,7 @@ demos =						\
 	dialog.c				\
 	drawingarea.c				\
 	editable_cells.c			\
+	entry_buffer.c				\
 	entry_completion.c			\
 	expander.c  				\
 	hypertext.c				\
@@ -27,6 +28,8 @@ demos =						\
 	links.c					\
 	list_store.c				\
 	menus.c					\
+	offscreen_window.c			\
+	offscreen_window2.c			\
 	panes.c					\
 	pickers.c				\
 	pixbufs.c				\

demos/gtk-demo/clipboard.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);
 

demos/gtk-demo/entry_buffer.c

@@ -0,0 +1,65 @@
+/* Entry/Entry Buffer
+ *
+ * GtkEntryBuffer provides the text content in a GtkEntry.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_entry_buffer (GtkWidget *do_widget)
+{
+  GtkWidget *vbox;
+  GtkWidget *label;
+  GtkWidget *entry;
+  GtkEntryBuffer *buffer;
+
+  if (!window)
+  {
+    window = gtk_dialog_new_with_buttons ("GtkEntryBuffer",
+					  GTK_WINDOW (do_widget),
+					  0,
+					  GTK_STOCK_CLOSE,
+					  GTK_RESPONSE_NONE,
+					  NULL);
+    gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+    g_signal_connect (window, "response",
+		      G_CALLBACK (gtk_widget_destroy), NULL);
+    g_signal_connect (window, "destroy",
+		      G_CALLBACK (gtk_widget_destroyed), &window);
+
+    vbox = gtk_vbox_new (FALSE, 5);
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+    label = gtk_label_new (NULL);
+    gtk_label_set_markup (GTK_LABEL (label), "Entries share a buffer. Typing in one is reflected in the other.");
+    gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+    /* Create a buffer */
+    buffer = gtk_entry_buffer_new (NULL, 0);
+
+    /* Create our first entry */
+    entry = gtk_entry_new_with_buffer (buffer);
+    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+    /* Create the second entry */
+    entry = gtk_entry_new_with_buffer (buffer);
+    gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
+    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+    g_object_unref (buffer);
+  }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}
+
+

demos/gtk-demo/links.c

@@ -43,11 +43,11 @@ activate_link (GtkWidget   *label,
   return FALSE;
 }
 
+static GtkWidget *window = NULL;
+
 GtkWidget *
 do_links (GtkWidget *do_widget)
 {
-  static GtkWidget *window = NULL;
-  GtkWidget *box;
   GtkWidget *label;
 
   if (!window)
@@ -55,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"

demos/gtk-demo/menus.c

@@ -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);

demos/gtk-demo/offscreen_window.c

@@ -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;
+}
+

demos/gtk-demo/offscreen_window2.c

@@ -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;
+}
+

demos/gtk-demo/printing.c

@@ -166,6 +166,7 @@ do_printing (GtkWidget *do_widget)
 
   gtk_print_operation_set_use_full_page (operation, FALSE);
   gtk_print_operation_set_unit (operation, GTK_UNIT_POINTS);
+  gtk_print_operation_set_embed_page_setup (operation, TRUE);
 
   settings = gtk_print_settings_new ();
   dir = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
@@ -173,6 +174,8 @@ do_printing (GtkWidget *do_widget)
     dir = g_get_home_dir ();
   if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "ps") == 0)
     ext = ".ps";
+  else if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "svg") == 0)
+    ext = ".svg";
   else
     ext = ".pdf";
 

docs/reference/gdk/gdk-sections.txt

@@ -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>

docs/reference/gdk/tmpl/cairo_interaction.sgml

@@ -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: 
+
+

docs/reference/gdk/tmpl/keys.sgml

@@ -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().

docs/reference/gdk/tmpl/windows.sgml

@@ -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>
@@ -221,6 +252,11 @@ these types.
 @arg3: 
 @arg4: 
 
+<!-- ##### ARG GdkWindow:cursor ##### -->
+<para>
+
+</para>
+
 <!-- ##### ENUM GdkWindowType ##### -->
 <para>
 Describes the kind of window.
@@ -232,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>
@@ -530,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>
 
@@ -718,6 +763,14 @@ Deprecated equivalent of g_object_unref()
 @dy: 
 
 
+<!-- ##### FUNCTION gdk_window_flush ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
 <!-- ##### FUNCTION gdk_window_ensure_native ##### -->
 <para>
 
@@ -806,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>
 
@@ -1242,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()

docs/reference/gtk/Makefile.am

@@ -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		\
@@ -168,6 +170,7 @@ expand_content_files = 				\
 	migrating-GtkColorButton.sgml		\
 	migrating-GtkAssistant.sgml		\
 	migrating-GtkRecentChooser.sgml 	\
+	migrating-GtkLabel-links.sgml		\
 	migrating-GtkLinkButton.sgml		\
 	migrating-GtkBuilder.sgml		\
 	migrating-GtkTooltip.sgml		\

docs/reference/gtk/gtk-docs.sgml

@@ -177,6 +177,7 @@ that is, GUI components such as #GtkButton or #GtkTextView.
     <chapter id="NumericEntry">
       <title>Numeric/Text Data Entry</title>
       <xi:include href="xml/gtkentry.xml" />
+      <xi:include href="xml/gtkentrybuffer.xml" />
       <xi:include href="xml/gtkentrycompletion.xml" />
       <xi:include href="xml/gtkhscale.xml" />
       <xi:include href="xml/gtkvscale.xml" />
@@ -434,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>

docs/reference/gtk/gtk-sections.txt

@@ -1268,7 +1268,10 @@ gtk_old_editable_get_type
 <TITLE>GtkEntry</TITLE>
 GtkEntry
 gtk_entry_new
+gtk_entry_new_with_buffer
 gtk_entry_new_with_max_length
+gtk_entry_get_buffer
+gtk_entry_set_buffer
 gtk_entry_set_text
 gtk_entry_append_text
 gtk_entry_prepend_text
@@ -1342,6 +1345,34 @@ GTK_ENTRY_GET_CLASS
 gtk_entry_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkentrybuffer</FILE>
+<TITLE>GtkEntryBuffer</TITLE>
+GtkEntryBuffer
+gtk_entry_buffer_new
+gtk_entry_buffer_get_text
+gtk_entry_buffer_set_text
+gtk_entry_buffer_get_bytes
+gtk_entry_buffer_get_length
+gtk_entry_buffer_get_max_length
+gtk_entry_buffer_set_max_length
+gtk_entry_buffer_insert_text
+gtk_entry_buffer_delete_text
+gtk_entry_buffer_emit_deleted_text
+gtk_entry_buffer_emit_inserted_text
+
+<SUBSECTION Standard>
+GTK_ENTRY_BUFFER
+GTK_IS_ENTRY_BUFFER
+GTK_TYPE_ENTRY_BUFFER
+GTK_ENTRY_BUFFER_CLASS
+GTK_IS_ENTRY_BUFFER_CLASS
+GTK_ENTRY_BUFFER_GET_CLASS
+GTK_ENTRY_BUFFER_MAX_SIZE
+<SUBSECTION Private>
+gtk_entry_buffer_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtkentrycompletion</FILE>
 <TITLE>GtkEntryCompletion</TITLE>
@@ -1452,6 +1483,8 @@ gtk_file_chooser_set_show_hidden
 gtk_file_chooser_get_show_hidden
 gtk_file_chooser_set_do_overwrite_confirmation
 gtk_file_chooser_get_do_overwrite_confirmation
+gtk_file_chooser_set_create_folders
+gtk_file_chooser_get_create_folders
 gtk_file_chooser_set_current_name
 gtk_file_chooser_get_filename
 gtk_file_chooser_set_filename
@@ -1939,6 +1972,8 @@ gtk_icon_view_set_column_spacing
 gtk_icon_view_get_column_spacing
 gtk_icon_view_set_margin
 gtk_icon_view_get_margin
+gtk_icon_view_set_item_padding
+gtk_icon_view_get_item_padding
 gtk_icon_view_select_path
 gtk_icon_view_unselect_path
 gtk_icon_view_path_is_selected
@@ -2275,6 +2310,8 @@ gtk_label_set_use_underline
 gtk_label_set_single_line_mode
 gtk_label_set_angle
 gtk_label_get_current_uri
+gtk_label_set_track_visited_links
+gtk_label_get_track_visited_links
 <SUBSECTION Standard>
 GTK_LABEL
 GTK_IS_LABEL
@@ -3037,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
@@ -4995,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
@@ -5100,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
@@ -5529,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
@@ -6554,6 +6628,7 @@ gtk_print_operation_set_print_settings
 gtk_print_operation_get_print_settings
 gtk_print_operation_set_job_name
 gtk_print_operation_set_n_pages
+gtk_print_operation_get_n_pages_to_print
 gtk_print_operation_set_current_page
 gtk_print_operation_set_use_full_page
 gtk_print_operation_set_unit
@@ -6572,6 +6647,8 @@ gtk_print_operation_set_support_selection
 gtk_print_operation_get_support_selection
 gtk_print_operation_set_has_selection
 gtk_print_operation_get_has_selection
+gtk_print_operation_set_embed_page_setup
+gtk_print_operation_get_embed_page_setup
 gtk_print_run_page_setup_dialog
 GtkPageSetupDoneFunc
 gtk_print_run_page_setup_dialog_async
@@ -6620,6 +6697,9 @@ gtk_print_unix_dialog_set_support_selection
 gtk_print_unix_dialog_get_support_selection
 gtk_print_unix_dialog_set_has_selection
 gtk_print_unix_dialog_get_has_selection
+gtk_print_unix_dialog_set_embed_page_setup
+gtk_print_unix_dialog_get_embed_page_setup
+gtk_print_unix_dialog_get_page_setup_set
 GtkPrintCapabilities
 gtk_print_unix_dialog_set_manual_capabilities
 gtk_print_unix_dialog_get_manual_capabilities

docs/reference/gtk/gtk.types

@@ -48,6 +48,7 @@ gtk_curve_get_type
 gtk_dialog_get_type
 gtk_drawing_area_get_type
 gtk_editable_get_type
+gtk_entry_buffer_get_type
 gtk_entry_completion_get_type
 gtk_entry_get_type
 gtk_event_box_get_type

docs/reference/gtk/migrating-ClientSideWindows.sgml

@@ -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>

docs/reference/gtk/migrating-GtkBuilder.sgml

@@ -13,21 +13,18 @@
   </para>
 
   <para>
-    A good way to start a migration from libglade to GtkBuilder is
-    to run the <link linkend="gtk-builder-convert">gtk-builder-convert</link>
-    utility on your glade file, and inspect the resulting output.
-    If your code uses the @root parameter of glade_xml_new(), you
-    may want to split your glade file into multiple GtkBuilder files
-    by using the <option>--root</option> option of
-    <application>gtk-builder-convert</application>. Alternatively, you
-    can use gtk_builder_add_objects_from_file() to construct only certain
+    A good way to start a migration from libglade to GtkBuilder is using
+    <application>glade3</application> to convert your .glade file.
+    If your code uses the @root parameter of glade_xml_new(),
+    you can use gtk_builder_add_objects_from_file() to construct only certain
     objects from a GtkBuilder file.
   </para>
 
   <para>
-    Alternatively, you can open the glade file with
-    <application>glade3</application> and then save it in GtkBuilder
-    format. This is supported by glade3 since version 3.6.
+    Alternatively, GTK+ also offers the
+    <link linkend="gtk-builder-convert">gtk-builder-convert</link> script you can use
+    to do the conversion; in which case you should be careful to inspect the output
+    and make sure you didn't lose any data.
   </para>
 
   <table pgwide="1" frame="topbot">
@@ -53,7 +50,7 @@ GError* error = NULL;
 GtkBuilder* builder = gtk_builder_new (<!-- -->);
 if (!gtk_builder_add_from_file (builder, FILE, &amp;error))
   {
-    g_warning ("Couldn't load builder file: %amp;s", error->message);
+    g_warning ("Couldn't load builder file: &percnt;s", error->message);
     g_error_free (error);
   }
 </screen>

docs/reference/gtk/migrating-GtkEntry-icons.sgml

@@ -7,10 +7,10 @@
   <title>Migrating from SexyIconEntry to GtkEntry</title>
 
   <para>
-    GTK+ 2.16 supports showing icons inside a #GtkEntry, similar to 
-    SexyIconEntry. Porting from SexyIconEntry to GtkEntry is relatively 
-    straightforward. The main difference between the two APIs is that 
-    SexyIconEntry uses #GtkImage widgets in a somewhat awkward way as 
+    GTK+ 2.16 supports showing icons inside a #GtkEntry, similar to
+    SexyIconEntry. Porting from SexyIconEntry to GtkEntry is relatively
+    straightforward. The main difference between the two APIs is that
+    SexyIconEntry uses #GtkImage widgets in a somewhat awkward way as
     storage vehicles for icons, while GtkEntry allows to specify icons
     via pixbufs, stock ids, icon names or #GIcons. So, if your code uses
     e.g.:
@@ -130,7 +130,7 @@ text_changed_cb (GtkEntry   *entry,
   gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
                                  GTK_ENTRY_ICON_SECONDARY,
                                  GTK_STOCK_CLEAR);
-  g_signal_connect (entry, "icon-pressed",
+  g_signal_connect (entry, "icon-press",
                     G_CALLBACK (icon_pressed_cb), NULL);
   g_signal_connect (entry, "notify::text",
                     G_CALLBACK (text_changed_cb), find_button);

docs/reference/gtk/migrating-GtkIconView.sgml

@@ -130,7 +130,7 @@
     <structname>GtkIconView</structname>:
     <itemizedlist> 
      <listitem><para>
-       <typename>GnomeIconListMode</typename> is replaced by the 
+       <type>GnomeIconListMode</type> is replaced by the 
        <link linkend="GtkIconView--orientation">orientation</link> 
        property of <structname>GtkIconView</structname>
      </para></listitem>

docs/reference/gtk/running.sgml

@@ -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>
 

docs/reference/gtk/tmpl/gtk-unused.sgml

@@ -1033,6 +1033,25 @@ You may not attach these to signals created with the
 </para>
 
 
+<!-- ##### STRUCT GtkEntryBufferClass ##### -->
+<para>
+
+</para>
+
+@parent_class: 
+@inserted_text: 
+@deleted_text: 
+@get_text: 
+@get_length: 
+@insert_text: 
+@delete_text: 
+@_gtk_reserved0: 
+@_gtk_reserved1: 
+@_gtk_reserved2: 
+@_gtk_reserved3: 
+@_gtk_reserved4: 
+@_gtk_reserved5: 
+
 <!-- ##### ARG GtkFileChooser:file-system ##### -->
 <para>
 
@@ -3866,14 +3885,6 @@ fundamental type.
 @group_cycling: 
 @Returns: 
 
-<!-- ##### FUNCTION gtk_widget_get_allocation ##### -->
-<para>
-
-</para>
-
-@widget: 
-@Returns: 
-
 <!-- ##### FUNCTION gtk_widget_get_usize ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkcellrenderer.sgml

@@ -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: 
+
+

docs/reference/gtk/tmpl/gtkcellrenderertoggle.sgml

@@ -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: 
+
+

docs/reference/gtk/tmpl/gtkentry.sgml

@@ -173,6 +173,11 @@ The #GtkEntry-struct struct contains only private data.
 
 </para>
 
+<!-- ##### ARG GtkEntry:buffer ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkEntry:caps-lock-warning ##### -->
 <para>
 
@@ -401,6 +406,15 @@ The #GtkEntry-struct struct contains only private data.
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_entry_new_with_buffer ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_entry_new_with_max_length ##### -->
 <para>
 </para>
@@ -409,6 +423,24 @@ The #GtkEntry-struct struct contains only private data.
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_entry_get_buffer ##### -->
+<para>
+
+</para>
+
+@entry: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_set_buffer ##### -->
+<para>
+
+</para>
+
+@entry: 
+@buffer: 
+
+
 <!-- ##### FUNCTION gtk_entry_set_text ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkentrybuffer.sgml

@@ -0,0 +1,168 @@
+<!-- ##### SECTION Title ##### -->
+GtkEntryBuffer
+
+<!-- ##### SECTION Short_Description ##### -->
+
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### STRUCT GtkEntryBuffer ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### SIGNAL GtkEntryBuffer::deleted-text ##### -->
+<para>
+
+</para>
+
+@entrybuffer: the object which received the signal.
+@arg1: 
+@arg2: 
+
+<!-- ##### SIGNAL GtkEntryBuffer::inserted-text ##### -->
+<para>
+
+</para>
+
+@entrybuffer: the object which received the signal.
+@arg1: 
+@arg2: 
+@arg3: 
+
+<!-- ##### ARG GtkEntryBuffer:length ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkEntryBuffer:max-length ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkEntryBuffer:text ##### -->
+<para>
+
+</para>
+
+<!-- ##### FUNCTION gtk_entry_buffer_new ##### -->
+<para>
+
+</para>
+
+@initial_chars: 
+@n_initial_chars: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_get_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_set_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@chars: 
+@n_chars: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_get_bytes ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_get_length ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_get_max_length ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_set_max_length ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@max_length: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_insert_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@position: 
+@chars: 
+@n_chars: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_delete_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@position: 
+@n_chars: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_emit_deleted_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@position: 
+@n_chars: 
+
+
+<!-- ##### FUNCTION gtk_entry_buffer_emit_inserted_text ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@position: 
+@chars: 
+@n_chars: 
+
+

docs/reference/gtk/tmpl/gtkfilechooser.sgml

@@ -677,6 +677,11 @@ gtk_widget_destroy (chooser);
 
 </para>
 
+<!-- ##### ARG GtkFileChooser:create-folders ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkFileChooser:do-overwrite-confirmation ##### -->
 <para>
 
@@ -875,6 +880,24 @@ gtk_widget_destroy (chooser);
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_file_chooser_set_create_folders ##### -->
+<para>
+
+</para>
+
+@chooser: 
+@create_folders: 
+
+
+<!-- ##### FUNCTION gtk_file_chooser_get_create_folders ##### -->
+<para>
+
+</para>
+
+@chooser: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_file_chooser_set_current_name ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkiconview.sgml

@@ -109,6 +109,11 @@ private fields and should not be directly accessed.
 
 </para>
 
+<!-- ##### ARG GtkIconView:item-padding ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkIconView:item-width ##### -->
 <para>
 
@@ -491,6 +496,24 @@ selected rows.  It will be called on every selected row in the view.
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_icon_view_set_item_padding ##### -->
+<para>
+
+</para>
+
+@icon_view: 
+@item_padding: 
+
+
+<!-- ##### FUNCTION gtk_icon_view_get_item_padding ##### -->
+<para>
+
+</para>
+
+@icon_view: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_icon_view_select_path ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkimage.sgml

@@ -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 ##### -->

docs/reference/gtk/tmpl/gtklabel.sgml

@@ -301,6 +301,11 @@ described below.
 
 </para>
 
+<!-- ##### ARG GtkLabel:track-visited-links ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkLabel:use-markup ##### -->
 <para>
 
@@ -746,3 +751,21 @@ Sets the text within the GtkLabel widget.
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_label_set_track_visited_links ##### -->
+<para>
+
+</para>
+
+@label: 
+@track_links: 
+
+
+<!-- ##### FUNCTION gtk_label_get_track_visited_links ##### -->
+<para>
+
+</para>
+
+@label: 
+@Returns: 
+
+

docs/reference/gtk/tmpl/gtkmenutoolbutton.sgml

@@ -19,19 +19,21 @@ A GtkToolItem containing a button with an additional dropdown menu
 
 <!-- ##### SECTION See_Also ##### -->
 <para>
-  <varlistentry>
-    <term>#GtkToolbar</term>
-    <listitem><para>The toolbar widget</para></listitem>
-    <term>#GtkToolButton</term>
-    <listitem>
-      <para>
-	The parent class of #GtkMenuToolButton. The properties
-	"label_widget", "label", "icon_widget", and "stock_id" on
-	#GtkToolButton determine the label and icon used on
-	#GtkMenuToolButton<!-- -->s.
-      </para>
-    </listitem>
-  </varlistentry>
+  <variablelist>
+    <varlistentry>
+      <term>#GtkToolbar</term>
+      <listitem><para>The toolbar widget</para></listitem>
+      <term>#GtkToolButton</term>
+      <listitem>
+        <para>
+          The parent class of #GtkMenuToolButton. The properties
+          "label_widget", "label", "icon_widget", and "stock_id" on
+          #GtkToolButton determine the label and icon used on
+          #GtkMenuToolButton<!-- -->s.
+        </para>
+      </listitem>
+    </varlistentry>
+  </variablelist>
 </para>
 
 <!-- ##### SECTION Stability_Level ##### -->

docs/reference/gtk/tmpl/gtkprintoperation.sgml

@@ -208,6 +208,11 @@ Printing support was added in GTK+ 2.10.
 
 </para>
 
+<!-- ##### ARG GtkPrintOperation:embed-page-setup ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkPrintOperation:export-filename ##### -->
 <para>
 
@@ -228,6 +233,11 @@ Printing support was added in GTK+ 2.10.
 
 </para>
 
+<!-- ##### ARG GtkPrintOperation:n-pages-to-print ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkPrintOperation:print-settings ##### -->
 <para>
 
@@ -414,6 +424,15 @@ The #GQuark used for #GtkPrintError errors.
 @n_pages: 
 
 
+<!-- ##### FUNCTION gtk_print_operation_get_n_pages_to_print ##### -->
+<para>
+
+</para>
+
+@op: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_print_operation_set_current_page ##### -->
 <para>
 
@@ -576,6 +595,24 @@ The #GQuark used for #GtkPrintError errors.
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_print_operation_set_embed_page_setup ##### -->
+<para>
+
+</para>
+
+@op: 
+@embed: 
+
+
+<!-- ##### FUNCTION gtk_print_operation_get_embed_page_setup ##### -->
+<para>
+
+</para>
+
+@op: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gtk_print_run_page_setup_dialog ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkprintunixdialog.sgml

@@ -90,6 +90,11 @@ The GtkPrintUnixDialog implementation of the GtkBuildable interface exposes its
 
 </para>
 
+<!-- ##### ARG GtkPrintUnixDialog:embed-page-setup ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkPrintUnixDialog:has-selection ##### -->
 <para>
 
@@ -239,6 +244,33 @@ The GtkPrintUnixDialog implementation of the GtkBuildable interface exposes its
 @Returns: 
 
 
+<!-- ##### FUNCTION gtk_print_unix_dialog_set_embed_page_setup ##### -->
+<para>
+
+</para>
+
+@dialog: 
+@embed: 
+
+
+<!-- ##### FUNCTION gtk_print_unix_dialog_get_embed_page_setup ##### -->
+<para>
+
+</para>
+
+@dialog: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_print_unix_dialog_get_page_setup_set ##### -->
+<para>
+
+</para>
+
+@dialog: 
+@Returns: 
+
+
 <!-- ##### ENUM GtkPrintCapabilities ##### -->
 <para>
 An enum for specifying which features the print dialog should offer.
@@ -256,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 

docs/reference/gtk/tmpl/gtkrange.sgml

@@ -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: 
+
+

docs/reference/gtk/tmpl/gtktoggletoolbutton.sgml

@@ -19,25 +19,27 @@ A GtkToolItem containing a toggle button
 <!-- ##### SECTION See_Also ##### -->
 
 <para>
-  <varlistentry>
-    <term>#GtkToolbar</term>
-    <listitem><para>The toolbar widget</para></listitem>
-    <term>#GtkToolButton</term>
-    <listitem>
-      <para>
-	The parent class of #GtkToggleToolButton. The properties
-	"label_widget", "label", "icon_widget", and "stock_id" on
-	#GtkToolButton determine the label and icon used on
-	#GtkToggleToolButton<!-- -->s.
-      </para>
-    </listitem>
-    <term>#GtkSeparatorToolItem</term>
-    <listitem>
-      <para>A subclass of #GtkToolItem that separates groups of
-	items on a toolbar.
-      </para>
-    </listitem>
-  </varlistentry>
+  <variablelist>
+    <varlistentry>
+      <term>#GtkToolbar</term>
+      <listitem><para>The toolbar widget</para></listitem>
+      <term>#GtkToolButton</term>
+      <listitem>
+        <para>
+          The parent class of #GtkToggleToolButton. The properties
+          "label_widget", "label", "icon_widget", and "stock_id" on
+          #GtkToolButton determine the label and icon used on
+          #GtkToggleToolButton<!-- -->s.
+        </para>
+      </listitem>
+      <term>#GtkSeparatorToolItem</term>
+      <listitem>
+        <para>A subclass of #GtkToolItem that separates groups of
+          items on a toolbar.
+        </para>
+      </listitem>
+    </varlistentry>
+  </variablelist>
 </para>
 
 <!-- ##### SECTION Stability_Level ##### -->

docs/reference/gtk/tmpl/gtktoolitem.sgml

@@ -12,23 +12,6 @@ GtkToolItem
 <!-- ##### SECTION See_Also ##### -->
 <para>
 
-<varlistentry>
-  <term>#GtkToolbar</term>
-  <listitem><para>The toolbar widget</para></listitem>
-</varlistentry>
-
-<varlistentry>
-  <term>#GtkToolButton</term>
-  <listitem><para>A subclass of #GtkToolItem that displays buttons on
-      the toolbar</para></listitem>
-</varlistentry>
-
-<varlistentry>
-  <term>#GtkSeparatorToolItem</term>
-  <listitem><para>A subclass of #GtkToolItem that separates groups of
-      items on a toolbar</para></listitem>
-</varlistentry>
-
 </para>
 
 <!-- ##### SECTION Stability_Level ##### -->

docs/reference/gtk/tmpl/gtktreeviewcolumn.sgml

@@ -112,6 +112,11 @@ calling gtk_tree_view_column_set_cell_data_func()
 
 </para>
 
+<!-- ##### ARG GtkTreeViewColumn:sort-column-id ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkTreeViewColumn:sort-indicator ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkwidget.sgml

@@ -693,6 +693,11 @@ internal child "accessible" of a <structname>GtkWidget</structname>.
 
 </para>
 
+<!-- ##### ARG GtkWidget:double-buffered ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkWidget:events ##### -->
 <para>
 
@@ -2636,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>
 

gdk-pixbuf/gdk-pixbuf-io.c

@@ -277,6 +277,13 @@ 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. */
+          return;
+	}
+
       /* This is an entry put there by gdk-pixbuf-query-loaders on the
        * packager's system. On Windows a prebuilt GTK+ package can be
        * installed in a random location. The gdk-pixbuf.loaders file
@@ -284,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);
     }

gdk-pixbuf/io-gdip-utils.c

@@ -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)

gdk-pixbuf/io-gif.c

@@ -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

gdk-pixbuf/io-jpeg.c

@@ -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);

gdk-pixbuf/io-xpm.c

@@ -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;
 

gdk-pixbuf/queryloaders.c

@@ -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);
 	}

gdk/directfb/gdkdirectfb.h

@@ -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);
 

gdk/directfb/gdkdisplay-directfb.c

@@ -377,16 +377,18 @@ gdk_directfb_pointer_ungrab (guint32  time,
   g_object_unref (old_grab_window);
 }
 
-gint
-gdk_display_pointer_is_grabbed (GdkDisplay *display)
-{
-  return _gdk_directfb_pointer_grab_window != NULL;
-}
-
 void
-gdk_display_pointer_ungrab (GdkDisplay *display,guint32 time)
+gdk_display_pointer_ungrab (GdkDisplay *display,
+                            guint32 time)
 {
-  gdk_directfb_pointer_ungrab (time, _gdk_directfb_pointer_implicit_grab);
+  GdkPointerGrabInfo *grab = _gdk_display_get_last_pointer_grab (display);
+
+  if (grab)
+    {
+      grab->serial_end = 0;
+    }
+
+  _gdk_display_pointer_grab_update (display, 0);
 }
 
 

gdk/directfb/gdkdrawable-directfb.c

@@ -1600,6 +1600,32 @@ gdk_directfb_cairo_surface_destroy (void *data)
   impl->cairo_surface = NULL;
 }
 
+void
+_gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
+                                       int width,
+                                       int height)
+{
+}
+
+cairo_surface_t *
+_gdk_windowing_create_cairo_surface (GdkDrawable *drawable,
+                                     int width,
+                                     int height)
+{
+  GdkDrawableImplDirectFB *impl;
+  IDirectFB *dfb;
+  cairo_surface_t *ret;
+
+  impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
+  dfb = GDK_DISPLAY_DFB (gdk_drawable_get_display (drawable))->directfb;
+
+  ret = cairo_directfb_surface_create (dfb, impl->surface);
+  cairo_surface_set_user_data (ret,
+                               &gdk_directfb_cairo_key, drawable,
+                               gdk_directfb_cairo_surface_destroy);
+
+  return ret;
+}
 
 static cairo_surface_t *
 gdk_directfb_ref_cairo_surface (GdkDrawable *drawable)

gdk/directfb/gdkgc-directfb.c

@@ -351,7 +351,8 @@ gc_unset_clip_mask (GdkGC *gc)
 
 void
 _gdk_windowing_gc_set_clip_region (GdkGC           *gc,
-                                   const GdkRegion *region)
+                                   const GdkRegion *region,
+                                   gboolean         reset_origin)
 {
   GdkGCDirectFB *data;
 
@@ -367,10 +368,13 @@ _gdk_windowing_gc_set_clip_region (GdkGC           *gc,
   else
     temp_region_reset (&data->clip_region);
 
-  gc->clip_x_origin = 0;
-  gc->clip_y_origin = 0;
-  data->values.clip_x_origin = 0;
-  data->values.clip_y_origin = 0;
+  if (reset_origin)
+    {
+      gc->clip_x_origin = 0;
+      gc->clip_y_origin = 0;
+      data->values.clip_x_origin = 0;
+      data->values.clip_y_origin = 0;
+    }
 
   gc_unset_clip_mask (gc);
 }

gdk/directfb/gdkinput-directfb.h

@@ -37,7 +37,6 @@ extern GdkModifierType _gdk_directfb_modifiers;
 extern int _gdk_directfb_mouse_x, _gdk_directfb_mouse_y;
 
 typedef struct _GdkAxisInfo      GdkAxisInfo;
-typedef struct _GdkInputWindow   GdkInputWindow;
 
 /* information about a device axis */
 struct _GdkAxisInfo

gdk/directfb/gdkmain-directfb.c

@@ -369,76 +369,15 @@ gdk_error_trap_pop (void)
   return 0;
 }
 
-
-/**
- * gdk_pointer_grab_info_libgtk_only:
- * @grab_window: location to store current grab window
- * @owner_events: location to store boolean indicating whether
- *   the @owner_events flag to gdk_pointer_grab() was %TRUE.
- *
- * Determines information about the current pointer grab.
- * This is not public API and must not be used by applications.
- *
- * Return value: %TRUE if this application currently has the
- *  pointer grabbed.
- **/
-gboolean
-gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,GdkWindow **grab_window,
-				   gboolean    *owner_events)
-{
-  if (_gdk_directfb_pointer_grab_window)
-    {
-      if (grab_window)
-        *grab_window = (GdkWindow *)_gdk_directfb_pointer_grab_window;
-      if (owner_events)
-        *owner_events = _gdk_directfb_pointer_grab_owner_events;
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-/**
- * gdk_keyboard_grab_info_libgtk_only:
- * @grab_window: location to store current grab window
- * @owner_events: location to store boolean indicating whether
- *   the @owner_events flag to gdk_keyboard_grab() was %TRUE.
- *
- * Determines information about the current keyboard grab.
- * This is not public API and must not be used by applications.
- *
- * Return value: %TRUE if this application currently has the
- *  keyboard grabbed.
- **/
-gboolean
-gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,GdkWindow **grab_window,
-				    gboolean    *owner_events)
-{
-  if (_gdk_directfb_keyboard_grab_window)
-    {
-      if (grab_window)
-        *grab_window = (GdkWindow *) _gdk_directfb_keyboard_grab_window;
-      if (owner_events)
-        *owner_events = _gdk_directfb_keyboard_grab_owner_events;
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-
 GdkGrabStatus
 gdk_keyboard_grab (GdkWindow *window,
                    gint       owner_events,
                    guint32    time) 
 {
-	return gdk_directfb_keyboard_grab(gdk_display_get_default(),
-			window,
-			owner_events,
-			time);
-
+  return gdk_directfb_keyboard_grab (gdk_display_get_default(),
+                                     window,
+                                     owner_events,
+                                     time);
 }
 
 /*
@@ -466,35 +405,25 @@ gdk_keyboard_grab (GdkWindow *window,
 
 
 GdkGrabStatus
-gdk_display_pointer_grab (GdkDisplay *display,GdkWindow    *window,
-                  gint          owner_events,
-                  GdkEventMask  event_mask,
-                  GdkWindow    *confine_to,
-                  GdkCursor    *cursor,
-                  guint32       time)
+_gdk_windowing_pointer_grab (GdkWindow    *window,
+                             GdkWindow    *native,
+                             gboolean      owner_events,
+                             GdkEventMask  event_mask,
+                             GdkWindow    *confine_to,
+                             GdkCursor    *cursor,
+                             guint32       time)
 {
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
   g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
 
-  return gdk_directfb_pointer_grab (window,
-                                    owner_events,
-                                    event_mask,
-                                    confine_to,
-                                    cursor,
-                                    time,
-                                    FALSE);
-}
-
-GdkGrabStatus
-gdk_pointer_grab (GdkWindow *     window,
-                  gint            owner_events,
-                  GdkEventMask    event_mask,
-                  GdkWindow *     confine_to,
-                  GdkCursor *     cursor,
-                  guint32         time)
-{
-	return gdk_directfb_pointer_grab(window, owner_events,event_mask,
-		confine_to,cursor,time,FALSE);	
+  _gdk_display_add_pointer_grab (_gdk_display,
+                                 window,
+                                 native,
+                                 owner_events,
+                                 event_mask,
+                                 confine_to,
+                                 cursor,
+                                 time);
 }
 
 #define __GDK_MAIN_X11_C__

gdk/directfb/gdkpixmap-directfb.c

@@ -114,10 +114,10 @@ gdk_pixmap_impl_directfb_finalize (GObject *object)
 }
 
 GdkPixmap*
-gdk_pixmap_new (GdkDrawable *drawable,
-                gint       width,
-                gint       height,
-                gint       depth)
+_gdk_pixmap_new (GdkDrawable *drawable,
+                 gint       width,
+                 gint       height,
+                 gint       depth)
 {
   DFBSurfacePixelFormat    format;
   IDirectFBSurface        *surface;
@@ -196,10 +196,10 @@ gdk_pixmap_new (GdkDrawable *drawable,
 }
 
 GdkPixmap *
-gdk_bitmap_create_from_data (GdkDrawable   *drawable,
-                             const gchar *data,
-                             gint         width,
-                             gint         height)
+_gdk_bitmap_create_from_data (GdkDrawable   *drawable,
+                              const gchar *data,
+                              gint         width,
+                              gint         height)
 {
   GdkPixmap *pixmap;
 
@@ -249,13 +249,13 @@ gdk_bitmap_create_from_data (GdkDrawable   *drawable,
 }
 
 GdkPixmap*
-gdk_pixmap_create_from_data (GdkDrawable   *drawable,
-                             const gchar *data,
-                             gint         width,
-                             gint         height,
-                             gint         depth,
-                             const GdkColor    *fg,
-                             const GdkColor    *bg)
+_gdk_pixmap_create_from_data (GdkDrawable   *drawable,
+                              const gchar *data,
+                              gint         width,
+                              gint         height,
+                              gint         depth,
+                              const GdkColor    *fg,
+                              const GdkColor    *bg)
 {
   GdkPixmap *pixmap;
 

gdk/gdk.c

@@ -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

gdk/gdk.symbols

@@ -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
@@ -658,6 +662,7 @@ gdk_window_move_region
 gdk_window_set_background
 gdk_window_set_back_pixmap
 gdk_window_set_cursor
+gdk_window_get_cursor
 gdk_window_get_geometry
 gdk_window_get_origin
 gdk_window_get_root_coords
@@ -682,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
@@ -698,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
@@ -1215,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__)

gdk/gdkcairo.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

gdk/gdkcairo.h

@@ -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);

gdk/gdkdisplay.c

@@ -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);
@@ -856,26 +860,26 @@ synthesize_crossing_events (GdkDisplay *display,
       gdk_window_get_pointer (dest_toplevel,
 			      &x, &y, &state);
       _gdk_synthesize_crossing_events (display,
-				      src_window,
-				      dest_window,
-				      crossing_mode,
-				      x, y, state,
-				      time,
-				      NULL,
-				      serial);
+				       src_window,
+				       dest_window,
+				       crossing_mode,
+				       x, y, state,
+				       time,
+				       NULL,
+				       serial, FALSE);
     }
   else if (dest_toplevel == NULL)
     {
       gdk_window_get_pointer (src_toplevel,
 			      &x, &y, &state);
       _gdk_synthesize_crossing_events (display,
-				      src_window,
-				      NULL,
-				      crossing_mode,
-				      x, y, state,
-				      time,
-				      NULL,
-				      serial);
+				       src_window,
+				       NULL,
+				       crossing_mode,
+				       x, y, state,
+				       time,
+				       NULL,
+				       serial, FALSE);
     }
   else
     {
@@ -883,26 +887,48 @@ synthesize_crossing_events (GdkDisplay *display,
       gdk_window_get_pointer (src_toplevel,
 			      &x, &y, &state);
       _gdk_synthesize_crossing_events (display,
-				      src_window,
-				      NULL,
-				      crossing_mode,
-				      x, y, state,
-				      time,
-				      NULL,
-				      serial);
+				       src_window,
+				       NULL,
+				       crossing_mode,
+				       x, y, state,
+				       time,
+				       NULL,
+				       serial, FALSE);
       gdk_window_get_pointer (dest_toplevel,
 			      &x, &y, &state);
       _gdk_synthesize_crossing_events (display,
-				      NULL,
-				      dest_window,
-				      crossing_mode,
-				      x, y, state,
-				      time,
-				      NULL,
-				      serial);
+				       NULL,
+				       dest_window,
+				       crossing_mode,
+				       x, y, state,
+				       time,
+				       NULL,
+				       serial, FALSE);
     }
 }
 
+static GdkWindow *
+get_current_toplevel (GdkDisplay *display,
+		      int *x_out, int *y_out,
+		      GdkModifierType *state_out)
+{
+  GdkWindow *pointer_window;
+  int x, y;
+  GdkModifierType 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;
+
+  *x_out = x;
+  *y_out = y;
+  *state_out = state;
+  return pointer_window;
+}
+
 static void
 switch_to_pointer_grab (GdkDisplay *display,
 			GdkPointerGrabInfo *grab,
@@ -910,8 +936,7 @@ switch_to_pointer_grab (GdkDisplay *display,
 			guint32 time,
 			gulong serial)
 {
-  GdkWindow *src_window, *pointer_window;
-  GdkWindowObject *w;
+  GdkWindow *src_window, *pointer_window, *new_toplevel;
   GList *old_grabs;
   GdkModifierType state;
   int x, y;
@@ -944,66 +969,61 @@ switch_to_pointer_grab (GdkDisplay *display,
 					  src_window, grab->window,
 					  GDK_CROSSING_GRAB, time, serial);
 	    }
-	  
+
 	  /* !owner_event Grabbing a window that we're not inside, current status is
 	     now NULL (i.e. outside grabbed window) */
 	  if (!grab->owner_events && display->pointer_info.window_under_pointer != grab->window)
 	    _gdk_display_set_window_under_pointer (display, NULL);
 	}
-  
+
       grab->activated = TRUE;
     }
-  else if (last_grab)
+
+  if (last_grab)
     {
-      pointer_window = _gdk_windowing_window_at_pointer (display,  &x, &y, &state);
-      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;
-      
-      /* We force checked what window we're in, so we need to
-       * update the toplevel_under_pointer info, as that won't get told of
-       * this change.
-       */
-      if (display->pointer_info.toplevel_under_pointer)
-	g_object_unref (display->pointer_info.toplevel_under_pointer);
-      display->pointer_info.toplevel_under_pointer = NULL;
-      
-      if (pointer_window)
+      new_toplevel = NULL;
+
+      if (grab == NULL /* ungrab */ ||
+	  (!last_grab->owner_events && grab->owner_events) /* switched to owner_events */ )
 	{
-	  /* Convert to toplevel */
-	  w = (GdkWindowObject *)pointer_window;
-	  while (/*w->parent != NULL && */
-		 w->parent->window_type != GDK_WINDOW_ROOT)
+	  /* We force check what window we're in, and update the toplevel_under_pointer info,
+	   * as that won't get told of this change with toplevel enter events.
+	   */
+	  if (display->pointer_info.toplevel_under_pointer)
+	    g_object_unref (display->pointer_info.toplevel_under_pointer);
+	  display->pointer_info.toplevel_under_pointer = NULL;
+
+	  new_toplevel = get_current_toplevel (display, &x, &y, &state);
+	  if (new_toplevel)
 	    {
-	      x += w->x;
-	      y += w->y;
-	      w = w->parent;
+	      /* w is now toplevel and x,y in toplevel coords */
+	      display->pointer_info.toplevel_under_pointer = g_object_ref (new_toplevel);
+	      display->pointer_info.toplevel_x = x;
+	      display->pointer_info.toplevel_y = y;
+	      display->pointer_info.state = state;
 	    }
-	  
-	  /* w is now toplevel and x,y in toplevel coords */
-	  display->pointer_info.toplevel_under_pointer = g_object_ref (w);
-	  
-	  /* Find (possibly virtual) child window */
-	  pointer_window =
-	    _gdk_window_find_descendant_at ((GdkWindow *)w,
-					    x, y,
-					    NULL, NULL);
 	}
 
-      if (pointer_window != last_grab->window)
-	synthesize_crossing_events (display,
-				    last_grab->window, pointer_window,
-				    GDK_CROSSING_UNGRAB, time, serial);
-      
-      /* 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);
+      if (grab == NULL) /* Ungrabbed, send events */
+	{
+	  pointer_window = NULL;
+	  if (new_toplevel)
+	    {
+	      /* Find (possibly virtual) child window */
+	      pointer_window =
+		_gdk_window_find_descendant_at (new_toplevel,
+						x, y,
+						NULL, NULL);
+	    }
+	  
+	  if (pointer_window != last_grab->window)
+	    synthesize_crossing_events (display,
+					last_grab->window, pointer_window,
+					GDK_CROSSING_UNGRAB, time, serial);
+	  
+	  /* We're now ungrabbed, update the window_under_pointer */
+	  _gdk_display_set_window_under_pointer (display, pointer_window);
+	}
     }
   
   display->pointer_grabs = old_grabs;
@@ -1026,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 */
@@ -1050,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,
@@ -1103,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,
@@ -1121,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;

gdk/gdkdraw.c

@@ -61,6 +61,15 @@ static void         gdk_drawable_real_draw_pixbuf            (GdkDrawable  *draw
 							      GdkRgbDither  dither,
 							      gint          x_dither,
 							      gint          y_dither);
+static void         gdk_drawable_real_draw_drawable          (GdkDrawable  *drawable,
+							      GdkGC	   *gc,
+							      GdkDrawable  *src,
+							      gint          xsrc,
+							      gint	    ysrc,
+							      gint	    xdest,
+							      gint	    ydest,
+							      gint	    width,
+							      gint	    height);
      
 
 G_DEFINE_ABSTRACT_TYPE (GdkDrawable, gdk_drawable, G_TYPE_OBJECT)
@@ -74,6 +83,7 @@ gdk_drawable_class_init (GdkDrawableClass *klass)
   klass->get_clip_region = gdk_drawable_real_get_visible_region;
   klass->get_visible_region = gdk_drawable_real_get_visible_region;
   klass->draw_pixbuf = gdk_drawable_real_draw_pixbuf;
+  klass->draw_drawable = gdk_drawable_real_draw_drawable;
 }
 
 static void
@@ -624,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;
 
@@ -653,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,
@@ -678,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,
@@ -752,9 +751,6 @@ gdk_draw_image (GdkDrawable *drawable,
  * On older X servers, rendering pixbufs with an alpha channel involves round 
  * trips to the X server, and may be somewhat slow.
  *
- * The clip mask of @gc is ignored, but clip rectangles and clip regions work
- * fine.
- *
  * If GDK is built with the Sun mediaLib library, the gdk_draw_pixbuf
  * function is accelerated using mediaLib, which provides hardware
  * acceleration on Intel, AMD, and Sparc chipsets.  If desired, mediaLib
@@ -1509,6 +1505,31 @@ composite_565 (guchar      *src_buf,
     }
 }
 
+/* Implementation of the old vfunc in terms of the new one
+   in case someone calls it directly (which they shouldn't!) */
+static void
+gdk_drawable_real_draw_drawable (GdkDrawable  *drawable,
+				 GdkGC	       *gc,
+				 GdkDrawable  *src,
+				 gint		xsrc,
+				 gint		ysrc,
+				 gint		xdest,
+				 gint		ydest,
+				 gint		width,
+				 gint		height)
+{
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable_with_src (drawable,
+							     gc,
+							     src,
+							     xsrc,
+							     ysrc,
+							     xdest,
+							     ydest,
+							     width,
+							     height,
+							     src);
+}
+
 static void
 gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
 			       GdkGC        *gc,
@@ -1528,6 +1549,7 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
   GdkRegion *clip;
   GdkRegion *drect;
   GdkRectangle tmp_rect;
+  GdkDrawable  *real_drawable;
 
   g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
   g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
@@ -1600,7 +1622,19 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
   /* Actually draw */
   if (!gc)
     gc = _gdk_drawable_get_scratch_gc (drawable, FALSE);
-  
+
+  /* Drawable is a wrapper here, but at this time we
+     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. 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 = GDK_PIXMAP_OBJECT (drawable)->impl;
+
   if (pixbuf->has_alpha)
     {
       GdkVisual *visual = gdk_drawable_get_visual (drawable);
@@ -1670,7 +1704,7 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
 				     image->bpl,
 				     visual->byte_order,
 				     width1, height1);
-		  gdk_draw_image (drawable, gc, image,
+		  gdk_draw_image (real_drawable, gc, image,
 				  xs0, ys0,
 				  dest_x + x0, dest_y + y0,
 				  width1, height1);
@@ -1711,7 +1745,7 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
     {
       guchar *buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 4;
 
-      gdk_draw_rgb_32_image_dithalign (drawable, gc,
+      gdk_draw_rgb_32_image_dithalign (real_drawable, gc,
 				       dest_x, dest_y,
 				       width, height,
 				       dither,
@@ -1722,7 +1756,7 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable  *drawable,
     {
       guchar *buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3;
 
-      gdk_draw_rgb_image_dithalign (drawable, gc,
+      gdk_draw_rgb_image_dithalign (real_drawable, gc,
 				    dest_x, dest_y,
 				    width, height,
 				    dither,

gdk/gdkevents.c

@@ -1266,6 +1266,9 @@ gdk_synthesize_window_state (GdkWindow     *window,
   
   ((GdkWindowObject*) window)->state = temp_event.window_state.new_window_state;
 
+  if (temp_event.window_state.changed_mask & GDK_WINDOW_STATE_WITHDRAWN)
+    _gdk_window_update_viewable (window);
+
   /* We only really send the event to toplevels, since
    * all the window states don't apply to non-toplevels.
    * Non-toplevels do use the GDK_WINDOW_STATE_WITHDRAWN flag

gdk/gdkevents.h

@@ -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);

gdk/gdkgc.c

@@ -646,24 +646,57 @@ _gdk_gc_add_drawable_clip (GdkGC     *gc,
       GdkPixmap *new_mask;
       GdkGC *tmp_gc;
       GdkColor black = {0, 0, 0, 0};
-      
-      priv->old_clip_mask = g_object_ref (priv->clip_mask);
-      gdk_drawable_get_size (priv->old_clip_mask, &w, &h);
+      GdkRectangle r;
+      GdkOverlapType overlap;
 
-      new_mask = gdk_pixmap_new	(priv->old_clip_mask, w, h, -1);
-      tmp_gc = _gdk_drawable_get_scratch_gc ((GdkDrawable *)new_mask, FALSE);
+      gdk_drawable_get_size (priv->clip_mask, &w, &h);
 
-      gdk_gc_set_foreground (tmp_gc, &black);
-      gdk_draw_rectangle (new_mask, tmp_gc, TRUE, 0, 0, -1, -1);
-      _gdk_gc_set_clip_region_internal (tmp_gc, region, TRUE); /* Takes ownership of region */
-      gdk_draw_drawable  (new_mask,
-			  tmp_gc,
-			  priv->old_clip_mask,
-			  0, 0,
-			  0, 0,
-			  -1, -1);
-      gdk_gc_set_clip_region (tmp_gc, NULL);
-      gdk_gc_set_clip_mask (gc, new_mask);
+      r.x = 0;
+      r.y = 0;
+      r.width = w;
+      r.height = h;
+
+      /* 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)
+	{
+	   /* The region and the mask intersect, create a new clip mask that
+	      includes both areas */
+	  priv->old_clip_mask = g_object_ref (priv->clip_mask);
+	  new_mask = gdk_pixmap_new (priv->old_clip_mask, w, h, -1);
+	  tmp_gc = _gdk_drawable_get_scratch_gc ((GdkDrawable *)new_mask, FALSE);
+
+	  gdk_gc_set_foreground (tmp_gc, &black);
+	  gdk_draw_rectangle (new_mask, tmp_gc, TRUE, 0, 0, -1, -1);
+	  _gdk_gc_set_clip_region_internal (tmp_gc, region, TRUE); /* Takes ownership of region */
+	  gdk_draw_drawable  (new_mask,
+			      tmp_gc,
+			      priv->old_clip_mask,
+			      0, 0,
+			      0, 0,
+			      -1, -1);
+	  gdk_gc_set_clip_region (tmp_gc, NULL);
+	  gdk_gc_set_clip_mask (gc, new_mask);
+	}
+      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);
+	}
+      else
+	{
+	  /* Completely inside region, don't set unnecessary clip */
+	  gdk_region_destroy (region);
+	  return;
+	}
     }
   else
     {
@@ -671,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);
     }
 
@@ -693,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
 	{
@@ -774,6 +813,24 @@ _gdk_gc_get_clip_region (GdkGC *gc)
   return GDK_GC_GET_PRIVATE (gc)->clip_region;
 }
 
+/**
+ * _gdk_gc_get_clip_mask:
+ * @gc: a #GdkGC
+ *
+ * Gets the current clip mask for @gc, if any.
+ *
+ * Return value: the clip mask for the GC, or %NULL.
+ *   (if a clip region is set, the return will be %NULL)
+ *   This value is owned by the GC and must not be freed.
+ **/
+GdkBitmap *
+_gdk_gc_get_clip_mask (GdkGC *gc)
+{
+  g_return_val_if_fail (GDK_IS_GC (gc), NULL);
+
+  return GDK_GC_GET_PRIVATE (gc)->clip_mask;
+}
+
 /**
  * _gdk_gc_get_fill:
  * @gc: a #GdkGC
@@ -1339,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;
@@ -1429,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);
@@ -1444,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);
 }
 
 

gdk/gdkglobals.c

@@ -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;
 

gdk/gdkinternals.h

@@ -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;
@@ -260,6 +260,8 @@ struct _GdkWindowObject
   guint effective_visibility : 2;
   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;
@@ -273,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;
@@ -385,6 +389,7 @@ void       _gdk_window_destroy           (GdkWindow      *window,
                                           gboolean        foreign_destroy);
 void       _gdk_window_clear_update_area (GdkWindow      *window);
 void       _gdk_window_update_size       (GdkWindow      *window);
+gboolean   _gdk_window_update_viewable   (GdkWindow      *window);
 
 void       _gdk_window_process_updates_recurse (GdkWindow *window,
                                                 GdkRegion *expose_region);
@@ -399,6 +404,7 @@ void _gdk_gc_init (GdkGC           *gc,
 		   GdkGCValuesMask  values_mask);
 
 GdkRegion *_gdk_gc_get_clip_region (GdkGC *gc);
+GdkBitmap *_gdk_gc_get_clip_mask   (GdkGC *gc);
 gboolean   _gdk_gc_get_exposures   (GdkGC *gc);
 GdkFill    _gdk_gc_get_fill        (GdkGC *gc);
 GdkPixmap *_gdk_gc_get_tile        (GdkGC *gc);
@@ -454,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,
@@ -602,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,
@@ -625,17 +632,20 @@ 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,
-				     GdkWindow                  *dest,
-				     GdkCrossingMode             mode,
-				     gint                        toplevel_x,
-				     gint                        toplevel_y,
-				     GdkModifierType             mask,
-				     guint32                     time_,
-				     GdkEvent                   *event_in_queue,
-				     gulong                      serial);
+				      GdkWindow                  *src,
+				      GdkWindow                  *dest,
+				      GdkCrossingMode             mode,
+				      gint                        toplevel_x,
+				      gint                        toplevel_y,
+				      GdkModifierType             mask,
+				      guint32                     time_,
+				      GdkEvent                   *event_in_queue,
+				      gulong                      serial,
+				      gboolean                    non_linear);
 void _gdk_display_set_window_under_pointer (GdkDisplay *display,
 					    GdkWindow *window);
 

gdk/gdkkeysyms-update.pl

@@ -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;

gdk/gdkoffscreenwindow.c

@@ -94,7 +94,7 @@ gdk_offscreen_window_finalize (GObject *object)
 
   offscreen->cursor = NULL;
 
-  gdk_pixmap_unref (offscreen->pixmap);
+  g_object_unref (offscreen->pixmap);
 
   G_OBJECT_CLASS (gdk_offscreen_window_parent_class)->finalize (object);
 }
@@ -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

gdk/gdkpixmap.c

@@ -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

gdk/gdkprivate.h

@@ -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...

gdk/gdkselection.h

@@ -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);

gdk/gdkwindow.h

@@ -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);
@@ -517,6 +526,7 @@ void	      gdk_window_set_back_pixmap (GdkWindow	  *window,
 					  gboolean	   parent_relative);
 void	      gdk_window_set_cursor	 (GdkWindow	  *window,
 					  GdkCursor	  *cursor);
+GdkCursor    *gdk_window_get_cursor      (GdkWindow       *window);
 void	      gdk_window_get_user_data	 (GdkWindow	  *window,
 					  gpointer	  *data);
 void	      gdk_window_get_geometry	 (GdkWindow	  *window,
@@ -537,7 +547,7 @@ void	      gdk_window_get_root_coords (GdkWindow	  *window,
 					  gint		  *root_x,
 					  gint		  *root_y);
 
-#if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION)
+#if !defined (GDK_DISABLE_DEPRECATED) || defined (GTK_COMPILATION) || defined (GDK_COMPILATION)
 /* Used by gtk_handle_box_button_changed () */
 gboolean      gdk_window_get_deskrelative_origin (GdkWindow	  *window,
 					  gint		  *x,

gdk/gdkwindowimpl.h

@@ -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);

gdk/makefile.msc

@@ -18,22 +18,6 @@ WTKIT = $(TOP)\wtkit126
 ###############################################################
 
 # Nothing much configurable below
-
-!IFNDEF DEBUG
-# Full optimization:
-OPTIMIZE = -Ox -MD -Zi
-LINKDEBUG = /nodefaultlib:libc.lib
-!ELSE
-# Debugging:
-OPTIMIZE = -Zi -MDd
-LINKDEBUG = /nodefaultlib:libcd.lib /nodefaultlib:libc.lib /debug
-!ENDIF
-
-# cl -? describes the options
-CC = cl -G5 -GF $(OPTIMIZE) -W3 -nologo
-
-LDFLAGS = /link $(LINKDEBUG)
-
 # overwrite version?
 GTK_VER=2.0
 GDK_PIXBUF_VER=$(GTK_VER)
@@ -42,11 +26,15 @@ GDK_PIXBUF_VER=$(GTK_VER)
 PERL = perl
 !ENDIF
 
-CFLAGS = -FImsvc_recommended_pragmas.h -I . -I .. \
+INCLUDES = -FImsvc_recommended_pragmas.h \
+	-I . -I .. \
 	$(GLIB_CFLAGS) $(PANGO_CFLAGS) $(CAIRO_CFLAGS) -I ../gdk-pixbuf \
-	$(G_DEBUGGING) -DHAVE_CONFIG_H -DGDK_ENABLE_BROKEN \
+
+DEFINES = \
+	-DHAVE_CONFIG_H -DGDK_ENABLE_BROKEN \
 	-DGDK_VERSION=\"$(GTK_VER)\" \
-	-DG_LOG_DOMAIN=\"Gdk\"
+	-DG_LOG_DOMAIN=\"Gdk\" \
+	-DGDK_COMPILATION -DG_LOG_DOMAIN=\"Gdk\"
 
 EXTRALIBS = \
 	$(WTKIT)\lib\i386\wntab32x.lib \
@@ -137,10 +125,10 @@ gdk_public_h_sources = \
 
 # private marshalers
 gdkmarshalers.h : gdkmarshalers.list
-	$(GLIB)\gobject\glib-genmarshal --prefix=gdk_marshal gdkmarshalers.list --header >>gdkmarshalers.h
+	$(GLIB)\gobject\glib-genmarshal --prefix=_gdk_marshal gdkmarshalers.list --header >>gdkmarshalers.h
 
 gdkmarshalers.c : gdkmarshalers.list
-	$(GLIB)\gobject\glib-genmarshal --prefix=gdk_marshal gdkmarshalers.list --body >gdkmarshalers.c
+	$(GLIB)\gobject\glib-genmarshal --prefix=_gdk_marshal gdkmarshalers.list --body >gdkmarshalers.c
 
 gdkenumtypes.h: $(gdk_public_h_sources) gdkenumtypes.h.template
 	$(PERL) $(GLIB)\gobject\glib-mkenums --template gdkenumtypes.h.template \
@@ -184,9 +172,6 @@ gdk-x11-$(GTK_VER).dll : $(gdk_OBJECTS) gdk.def x11\gdk-x11.lib
 testgdk.exe : libgdk-win32-$(GTK_VER)-0.dll testgdk.obj
 	$(CC) -Fetestgdk.exe testgdk.obj gdk-win32-$(GTK_VER).lib $(EXTRALIBS) $(LDFLAGS)
 
-.c.obj :
-	$(CC) $(CFLAGS) -GD -c -DGDK_COMPILATION -DG_LOG_DOMAIN=\"Gdk\" $<
-
 clean::
 	cd win32
 	nmake -f makefile.msc clean

gdk/quartz/GdkQuartzView.c

@@ -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

gdk/quartz/GdkQuartzWindow.c

@@ -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;

gdk/quartz/gdkcursor-quartz.c

@@ -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));
     }

gdk/quartz/gdkdnd-quartz.c

@@ -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)

gdk/quartz/gdkevents-quartz.c

@@ -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;
               }

gdk/quartz/gdkgeometry-quartz.c

@@ -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

gdk/quartz/gdkprivate-quartz.h

@@ -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);

gdk/quartz/gdkscreen-quartz.c

@@ -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);

gdk/quartz/gdkwindow-quartz.c

@@ -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,20 +1039,25 @@ _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;
   private->depth = 24;
+  private->viewable = TRUE;
 
   drawable_impl = GDK_DRAWABLE_IMPL_QUARTZ (private->impl);
   
@@ -1289,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);
             }
@@ -1540,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)
@@ -1846,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;
@@ -1884,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;
 }
 
@@ -2001,7 +2114,7 @@ gdk_window_set_title (GdkWindow   *window,
   g_return_if_fail (title != NULL);
 
   if (GDK_WINDOW_DESTROYED (window) ||
-      WINDOW_IS_TOPLEVEL (window))
+      !WINDOW_IS_TOPLEVEL (window))
     return;
 
   impl = GDK_WINDOW_IMPL_QUARTZ (((GdkWindowObject *)window)->impl);
@@ -2032,8 +2145,8 @@ gdk_window_set_transient_for (GdkWindow *window,
   GdkWindowImplQuartz *window_impl;
   GdkWindowImplQuartz *parent_impl;
 
-  if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (parent) &&
-      WINDOW_IS_TOPLEVEL (window))
+  if (GDK_WINDOW_DESTROYED (window)  || GDK_WINDOW_DESTROYED (parent) ||
+      !WINDOW_IS_TOPLEVEL (window))
     return;
 
   window_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
@@ -2875,6 +2988,27 @@ _gdk_windowing_window_set_composited (GdkWindow *window, gboolean composited)
 {
 }
 
+GdkRegion *
+_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
+{
+  /* FIXME: implement */
+  return NULL;
+}
+
+GdkRegion *
+_gdk_windowing_window_get_shape (GdkWindow *window)
+{
+  /* FIXME: implement */
+  return NULL;
+}
+
+GdkRegion *
+_gdk_windowing_window_get_input_shape (GdkWindow *window)
+{
+  /* FIXME: implement */
+  return NULL;
+}
+
 static void
 gdk_window_impl_iface_init (GdkWindowImplIface *iface)
 {
@@ -2885,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;

gdk/quartz/gdkwindow-quartz.h

@@ -59,6 +59,8 @@ struct _GdkWindowImplQuartz
 
   /* Sorted by z-order */
   GList *sorted_children;
+
+  GdkRegion *needs_display_region;
 };
  
 struct _GdkWindowImplQuartzClass 

gdk/testgdk.c

@@ -340,7 +340,7 @@ test_gcs (void)
 
   pixmap = gdk_pixmap_new (NULL, 1, 1, 1);
   black_bitmap_gc = gdk_gc_new (pixmap);
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
 }
 
 /* Create pixmaps, check that properties are as expected.
@@ -370,7 +370,7 @@ test_pixmaps (gint depth)
 	QTEST (image->height == height);
 	QTEST (image->depth == depth);
 	gdk_image_destroy (image);
-	gdk_pixmap_unref (pixmap);
+	g_object_unref (pixmap);
       }
   TEST (retval);
 }
@@ -569,7 +569,7 @@ test_points (void)
 	  gdk_gc_set_function (gcs[j], GDK_COPY);
 	}
   
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
   
   pixmap = gdk_pixmap_new (w, width, height, 1);
   test_one_point_on_drawable (pixmap, black_bitmap_gc, 1);
@@ -579,7 +579,7 @@ test_points (void)
       test_one_point_on_drawable (pixmap, black_bitmap_gc, 1);
     }
 
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
 }
 
 static void
@@ -684,7 +684,7 @@ test_lines (void)
 	    gdk_gc_set_function (gcs[j], GDK_COPY);
 	  }
 
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
 }
 
 static void
@@ -789,7 +789,7 @@ test_rectangles (void)
 	    gdk_gc_set_function (gcs[j], GDK_COPY);
 	  }
   
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
 }
 
 static void
@@ -880,7 +880,7 @@ test_arcs (void)
 	    gdk_gc_set_function (gcs[j], GDK_COPY);
 	  }
 
-  gdk_pixmap_unref (pixmap);
+  g_object_unref (pixmap);
 }
 
 /* Test region operations.

gdk/win32/gdkdrawable-win32.c

@@ -115,6 +115,18 @@ static void gdk_win32_draw_image     (GdkDrawable     *drawable,
 				      gint             ydest,
 				      gint             width,
 				      gint             height);
+static void gdk_win32_draw_pixbuf     (GdkDrawable     *drawable,
+				      GdkGC           *gc,
+				      GdkPixbuf       *pixbuf,
+				      gint             src_x,
+				      gint             src_y,
+				      gint             dest_x,
+				      gint             dest_y,
+				      gint             width,
+				      gint             height,
+				      GdkRgbDither     dither,
+				      gint             x_dither,
+				      gint             y_dither);
 
 static cairo_surface_t *gdk_win32_ref_cairo_surface (GdkDrawable *drawable);
      
@@ -129,49 +141,19 @@ static GdkScreen *  gdk_win32_get_screen     (GdkDrawable    *drawable);
 
 static GdkVisual*   gdk_win32_get_visual     (GdkDrawable    *drawable);
 
-static void gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass);
-
 static void gdk_drawable_impl_win32_finalize   (GObject *object);
 
-static gpointer parent_class = NULL;
 static const cairo_user_data_key_t gdk_win32_cairo_key;
 
-GType
-gdk_drawable_impl_win32_get_type (void)
-{
-  static GType object_type = 0;
+G_DEFINE_TYPE (GdkDrawableImplWin32,  _gdk_drawable_impl_win32, GDK_TYPE_DRAWABLE)
 
-  if (!object_type)
-    {
-      static const GTypeInfo object_info =
-      {
-        sizeof (GdkDrawableImplWin32Class),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) gdk_drawable_impl_win32_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (GdkDrawableImplWin32),
-        0,              /* n_preallocs */
-        (GInstanceInitFunc) NULL,
-      };
-      
-      object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
-                                            "GdkDrawableImplWin32",
-                                            &object_info, 0);
-    }
-  
-  return object_type;
-}
 
 static void
-gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
+_gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
 {
   GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  parent_class = g_type_class_peek_parent (klass);
-
   object_class->finalize = gdk_drawable_impl_win32_finalize;
 
   drawable_class->create_gc = _gdk_win32_gc_new;
@@ -185,6 +167,7 @@ gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
   drawable_class->draw_segments = gdk_win32_draw_segments;
   drawable_class->draw_lines = gdk_win32_draw_lines;
   drawable_class->draw_image = gdk_win32_draw_image;
+  drawable_class->draw_pixbuf = gdk_win32_draw_pixbuf;
   
   drawable_class->ref_cairo_surface = gdk_win32_ref_cairo_surface;
   
@@ -198,12 +181,17 @@ gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
   drawable_class->_copy_to_image = _gdk_win32_copy_to_image;
 }
 
+static void
+_gdk_drawable_impl_win32_init (GdkDrawableImplWin32 *impl)
+{
+}
+
 static void
 gdk_drawable_impl_win32_finalize (GObject *object)
 {
   gdk_drawable_set_colormap (GDK_DRAWABLE (object), NULL);
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (_gdk_drawable_impl_win32_parent_class)->finalize (object);
 }
 
 /*****************************************************
@@ -226,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
@@ -506,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
@@ -641,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);
 
@@ -1784,6 +1772,27 @@ gdk_win32_draw_image (GdkDrawable     *drawable,
 		   xsrc, ysrc, xdest, ydest, width, height);
 }
 
+static void
+gdk_win32_draw_pixbuf (GdkDrawable     *drawable,
+			GdkGC           *gc,
+			GdkPixbuf       *pixbuf,
+			gint             src_x,
+			gint             src_y,
+			gint             dest_x,
+			gint             dest_y,
+			gint             width,
+			gint             height,
+			GdkRgbDither     dither,
+			gint             x_dither,
+			gint             y_dither)
+{
+  GdkDrawable *wrapper = GDK_DRAWABLE_IMPL_WIN32 (drawable)->wrapper;
+  GDK_DRAWABLE_CLASS (_gdk_drawable_impl_win32_parent_class)->draw_pixbuf (wrapper, gc, pixbuf,
+									     src_x, src_y, dest_x, dest_y,
+									     width, height,
+									     dither, x_dither, y_dither);
+}
+
 /**
  * _gdk_win32_drawable_acquire_dc
  * @drawable: a Win32 #GdkDrawable implementation
@@ -1883,10 +1892,8 @@ _gdk_windowing_create_cairo_surface (GdkDrawable *drawable,
 				     gint width,
 				     gint height)
 {
-  HDC hdc = _gdk_win32_drawable_acquire_dc (drawable);
-  if (!hdc)
-    return NULL;
-  return cairo_win32_surface_create (hdc);
+  /* width and height are determined from the DC */
+  return gdk_win32_ref_cairo_surface (drawable);
 }
 
 static void
@@ -1909,16 +1916,17 @@ gdk_win32_ref_cairo_surface (GdkDrawable *drawable)
 
   if (!impl->cairo_surface)
     {
-      // On Win32 cairo surface, width and height are determined from the DC
-      impl->cairo_surface = _gdk_windowing_create_cairo_surface (drawable, 0, 0);
+      HDC hdc = _gdk_win32_drawable_acquire_dc (drawable);
+      if (!hdc)
+	return NULL;
+
+      impl->cairo_surface = cairo_win32_surface_create (hdc);
 
       cairo_surface_set_user_data (impl->cairo_surface, &gdk_win32_cairo_key,
 				   drawable, gdk_win32_cairo_surface_destroy);
     }
   else
-    {
-      cairo_surface_reference (impl->cairo_surface);
-    }
+    cairo_surface_reference (impl->cairo_surface);
 
   return impl->cairo_surface;
 }
@@ -1977,6 +1985,6 @@ _gdk_win32_drawable_finish (GdkDrawable *drawable)
       cairo_surface_set_user_data (impl->cairo_surface, &gdk_win32_cairo_key, NULL, NULL);
     }
 
-  //TODO_CSW: g_assert (impl->hdc_count == 0);
+  g_assert (impl->hdc_count == 0);
 }
 

gdk/win32/gdkdrawable-win32.h

@@ -38,7 +38,7 @@ G_BEGIN_DECLS
 typedef struct _GdkDrawableImplWin32 GdkDrawableImplWin32;
 typedef struct _GdkDrawableImplWin32Class GdkDrawableImplWin32Class;
 
-#define GDK_TYPE_DRAWABLE_IMPL_WIN32              (gdk_drawable_impl_win32_get_type ())
+#define GDK_TYPE_DRAWABLE_IMPL_WIN32              (_gdk_drawable_impl_win32_get_type ())
 #define GDK_DRAWABLE_IMPL_WIN32(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE_IMPL_WIN32, GdkDrawableImplWin32))
 #define GDK_DRAWABLE_IMPL_WIN32_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWABLE_IMPL_WIN32, GdkDrawableImplWin32Class))
 #define GDK_IS_DRAWABLE_IMPL_WIN32(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE_IMPL_WIN32))
@@ -63,7 +63,7 @@ struct _GdkDrawableImplWin32Class
   GdkDrawableClass parent_class;
 };
 
-GType gdk_drawable_impl_win32_get_type (void);
+GType _gdk_drawable_impl_win32_get_type (void);
 
 HDC  _gdk_win32_drawable_acquire_dc (GdkDrawable *drawable);
 void _gdk_win32_drawable_release_dc (GdkDrawable *drawable);

gdk/win32/gdkevents-win32.c

@@ -1,6 +1,7 @@
 /* GDK - The GIMP Drawing Kit
  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  * Copyright (C) 1998-2002 Tor Lillqvist
+ * Copyright (C) 2001,2009 Hans Breuer
  * Copyright (C) 2007-2009 Cody Russell
  *
  * This library is free software; you can redistribute it and/or
@@ -99,18 +100,6 @@ static gboolean is_modally_blocked (GdkWindow   *window);
 /* Private variable declarations
  */
 
-#if 0
-static GdkWindow *p_grab_window = NULL; /* Window that currently holds
-					 * the pointer grab
-					 */
-
-static GdkWindow *p_grab_confine_to = NULL;
-
-static GdkWindow *k_grab_window = NULL; /* Window the holds the
-					 * keyboard grab
-					 */
-#endif
-
 static GList *client_filters;	/* Filters for client messages */
 
 static gboolean p_grab_automatic;
@@ -273,7 +262,7 @@ inner_window_procedure (HWND   hwnd,
   else
     {
       /* Otherwise call DefWindowProcW(). */
-      GDK_NOTE (EVENTS, g_print (" DefWindowProcW"));
+      GDK_NOTE (EVENTLOOP, g_print (" DefWindowProcW"));
       return DefWindowProcW (hwnd, message, wparam, lparam);
     }
 }
@@ -485,9 +474,52 @@ _gdk_windowing_pointer_grab (GdkWindow    *window,
 			     GdkCursor    *cursor,
 			     guint32	time)
 {
-  SetCapture (GDK_WINDOW_HWND (native_window));
-  /* TODO_CSW: grab brokens, confine window, cursor, input_grab */
-  return GDK_GRAB_SUCCESS;
+  HCURSOR hcursor;
+  GdkCursorPrivate *cursor_private;
+  gint return_val;
+
+  g_return_val_if_fail (window != NULL, 0);
+  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
+  g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
+  
+  cursor_private = (GdkCursorPrivate*) cursor;
+  
+  if (!cursor)
+    hcursor = NULL;
+  else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)
+    WIN32_API_FAILED ("CopyCursor");
+
+  return_val = _gdk_input_grab_pointer (native_window,
+					owner_events,
+					event_mask,
+					confine_to,
+					time);
+
+  if (return_val == GDK_GRAB_SUCCESS)
+    {
+      GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) native_window)->impl);
+
+      SetCapture (GDK_WINDOW_HWND (native_window));
+      /* TODO_CSW: grab brokens, confine window, input_grab */
+      if (p_grab_cursor != NULL)
+	{
+	  if (GetCursor () == p_grab_cursor)
+	    SetCursor (NULL);
+	  DestroyCursor (p_grab_cursor);
+	}
+
+      p_grab_cursor = hcursor;
+
+      if (p_grab_cursor != NULL)
+	SetCursor (p_grab_cursor);
+      else if (impl->hcursor != NULL)
+	SetCursor (impl->hcursor);
+      else
+	SetCursor (LoadCursor (NULL, IDC_ARROW));
+
+    }
+
+  return return_val;
 }
 
 void
@@ -507,6 +539,52 @@ gdk_display_pointer_ungrab (GdkDisplay *display,
   _gdk_display_pointer_grab_update (display, 0);
 }
 
+
+static GdkWindow *
+find_window_for_mouse_event (GdkWindow* reported_window,
+			     MSG*       msg)
+{
+  HWND hwnd;
+  POINTS points;
+  POINT pt;
+  GdkWindow* other_window = NULL;
+
+  if (!_gdk_display_get_last_pointer_grab (_gdk_display))
+    return reported_window;
+
+  points = MAKEPOINTS (msg->lParam);
+  pt.x = points.x;
+  pt.y = points.y;
+  ClientToScreen (msg->hwnd, &pt);
+
+  hwnd = WindowFromPoint (pt);
+
+  if (hwnd != NULL)
+    {
+      RECT rect;
+
+      GetClientRect (hwnd, &rect);
+      ScreenToClient (hwnd, &pt);
+      if (!PtInRect (&rect, pt))
+	return _gdk_root;
+
+      other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
+    }
+
+  if (other_window == NULL)
+    return _gdk_root;
+
+  /* need to also adjust the coordinates to the new window */
+  pt.x = points.x;
+  pt.y = points.y;
+  ClientToScreen (msg->hwnd, &pt);
+  ScreenToClient (GDK_WINDOW_HWND (other_window), &pt);
+  /* ATTENTION: need to update client coords */
+  msg->lParam = MAKELPARAM (pt.x, pt.y);
+
+  return other_window;
+}
+
 GdkGrabStatus
 gdk_keyboard_grab (GdkWindow *window,
 		   gboolean   owner_events,
@@ -696,7 +774,7 @@ print_event_state (guint state)
 }
 
 static void
-print_event (GdkEvent *event)
+print_event (const GdkEvent *event)
 {
   gchar *escaped, *kvname;
   gchar *selection_name, *target_name, *property_name;
@@ -910,9 +988,14 @@ append_event (GdkEvent *event)
   GList *link;
   
   fixup_event (event);
+#if 1
   link = _gdk_event_queue_append (_gdk_display, event);
+  /* event morphing, the passed in may not be valid afterwards */
   _gdk_windowing_got_event (_gdk_display, link, event, 0);
+#else
+  _gdk_event_queue_append (_gdk_display, event);
   GDK_NOTE (EVENTS, print_event (event));
+#endif
 }
 
 static void
@@ -2209,9 +2292,12 @@ gdk_event_translate (MSG  *msg,
 		g_print (" (%d,%d)",
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
 
+      assign_object (&window, find_window_for_mouse_event (window, msg));
+      /* TODO_CSW?: there used to some synthesize and propagate */
       if (GDK_WINDOW_DESTROYED (window))
 	break;
 
+      /* TODO_CSW? Emulate X11's automatic active grab */
       generate_button_event (GDK_BUTTON_PRESS, button,
 			     window, msg);
 
@@ -2241,6 +2327,7 @@ gdk_event_translate (MSG  *msg,
 		g_print (" (%d,%d)",
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
 
+      assign_object (&window, find_window_for_mouse_event (window, msg));
 #if 0
       if (((GdkWindowObject *) window)->extension_events != 0 &&
 	  _gdk_input_ignore_core)
@@ -2262,9 +2349,13 @@ gdk_event_translate (MSG  *msg,
 			 (gpointer) msg->wParam,
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
 
+      assign_object (&window, find_window_for_mouse_event (window, msg));
       toplevel = gdk_window_get_toplevel (window);
       if (current_toplevel != toplevel)
 	{
+	  GDK_NOTE (EVENTS, g_print (" toplevel %p -> %p", 
+	      current_toplevel ? GDK_WINDOW_HWND (current_toplevel) : NULL, 
+	      toplevel ? GDK_WINDOW_HWND (toplevel) : NULL));
 	  if (current_toplevel)
 	    synthesize_enter_or_leave_event (current_toplevel, msg, 
 					     GDK_LEAVE_NOTIFY, GDK_CROSSING_NORMAL, GDK_NOTIFY_ANCESTOR);
@@ -2273,7 +2364,7 @@ gdk_event_translate (MSG  *msg,
 	  assign_object (&current_toplevel, toplevel);
 	  track_mouse_event (TME_LEAVE, GDK_WINDOW_HWND (toplevel));
 	}
-      
+
       /* If we haven't moved, don't create any GDK event. Windows
        * sends WM_MOUSEMOVE messages after a new window is shows under
        * the mouse, even if the mouse hasn't moved. This disturbs gtk.
@@ -2306,7 +2397,14 @@ gdk_event_translate (MSG  *msg,
       GDK_NOTE (EVENTS,
 		g_print (" (%d,%d)",
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
-
+#if 0 /* TODO_CSW? */
+      if (current_toplevel != NULL &&
+	  (((GdkWindowObject *) current_toplevel)->event_mask & GDK_LEAVE_NOTIFY_MASK))
+	{
+	  synthesize_enter_or_leave_event (current_toplevel, msg,
+	                                   GDK_LEAVE_NOTIFY, GDK_CROSSING_NORMAL, GDK_NOTIFY_ANCESTOR);
+	}
+#endif
       break;
 
     case WM_MOUSELEAVE:
@@ -2510,7 +2608,6 @@ gdk_event_translate (MSG  *msg,
       GDK_NOTE (EVENTS, g_print (" %#x %#x",
 				 LOWORD (msg->lParam), HIWORD (msg->lParam)));
 
-#ifdef TODO_CSW
       grab = _gdk_display_get_last_pointer_grab (_gdk_display);
       if (grab != NULL)
 	{
@@ -2534,8 +2631,6 @@ gdk_event_translate (MSG  *msg,
 	  return_val = TRUE;
 	  *ret_valp = TRUE;
 	}
-#endif
-      
       break;
 
     case WM_SHOWWINDOW:

gdk/win32/gdkimage-win32.c

@@ -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;
 }
 

gdk/win32/gdkinput-win32.h

@@ -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);

gdk/win32/gdkinput.c

@@ -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)
 {

gdk/win32/gdkpixmap-win32.c

@@ -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,

gdk/win32/gdkprivate-win32.h

@@ -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;

gdk/win32/gdkwindow-win32.c

@@ -1,7 +1,7 @@
 /* GDK - The GIMP Drawing Kit
  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  * Copyright (C) 1998-2004 Tor Lillqvist
- * Copyright (C) 2001-2004 Hans Breuer
+ * Copyright (C) 2001-2009 Hans Breuer
  * Copyright (C) 2007-2009 Cody Russell
  *
  * This library is free software; you can redistribute it and/or
@@ -236,20 +236,16 @@ void
 _gdk_root_window_size_init (void)
 {
   GdkWindowObject *window_object;
-  //GdkWindowImplWin32 *impl;
   GdkRectangle rect;
   int i;
 
   window_object = GDK_WINDOW_OBJECT (_gdk_root);
-  //impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) _gdk_root)->impl);
   rect = _gdk_monitors[0].rect;
   for (i = 1; i < _gdk_num_monitors; i++)
     gdk_rectangle_union (&rect, &_gdk_monitors[i].rect, &rect);
 
   window_object->width = rect.width;
   window_object->height = rect.height;
-  //impl->width = rect.width;
-  //impl->height = rect.height;
 }
 
 void
@@ -283,6 +279,7 @@ _gdk_windowing_window_init (GdkScreen *screen)
   private->abs_y = 0;
   private->width = GetSystemMetrics (SM_CXSCREEN);
   private->height = GetSystemMetrics (SM_CYSCREEN);
+  private->viewable = TRUE;
 
   gdk_win32_handle_table_insert ((HANDLE *) &draw_impl->handle, _gdk_root);
 
@@ -597,8 +594,6 @@ _gdk_window_impl_new (GdkWindow     *window,
       g_assert_not_reached ();
     }
 
-  //_gdk_window_init_position (GDK_WINDOW (private));
-
   if (private->window_type != GDK_WINDOW_CHILD)
     {
       rect.left = rect.top = 0;
@@ -641,17 +636,17 @@ _gdk_window_impl_new (GdkWindow     *window,
   wtitle = g_utf8_to_utf16 (title, -1, NULL, NULL, NULL);
   
   hwndNew = CreateWindowExW (dwExStyle,
-							 MAKEINTRESOURCEW (klass),
-							 wtitle,
-							 dwStyle,
-							 ((attributes_mask & GDK_WA_X) ?
-							  private->x - offset_x : CW_USEDEFAULT),
-							 private->y - offset_y, 
-							 window_width, window_height,
-							 hparent,
-							 NULL,
-							 _gdk_app_hmodule,
-							 window);
+			     MAKEINTRESOURCEW (klass),
+			     wtitle,
+			     dwStyle,
+			     ((attributes_mask & GDK_WA_X) ?
+			       private->x - offset_x : CW_USEDEFAULT),
+			     private->y - offset_y,
+			     window_width, window_height,
+			     hparent,
+			     NULL,
+			     _gdk_app_hmodule,
+			     window);
   if (GDK_WINDOW_HWND (window) != hwndNew)
     {
       g_warning ("gdk_window_new: gdk_event_translate::WM_CREATE (%p, %p) HWND mismatch.",
@@ -758,11 +753,10 @@ gdk_window_foreign_new_for_display (GdkDisplay      *display,
   else
     private->state &= (~GDK_WINDOW_STATE_ABOVE);
   private->state &= (~GDK_WINDOW_STATE_BELOW);
+  private->viewable = TRUE;
 
   private->depth = gdk_visual_get_system ()->depth;
 
-  //_gdk_window_init_position (GDK_WINDOW (private));
-
   g_object_ref (window);
   gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
 
@@ -781,9 +775,9 @@ gdk_window_lookup (GdkNativeWindow hwnd)
 }
 
 void
-_gdk_windowing_window_destroy (GdkWindow *window,
-			       gboolean   recursing,
-			       gboolean   foreign_destroy)
+_gdk_win32_window_destroy (GdkWindow *window,
+			   gboolean   recursing,
+			   gboolean   foreign_destroy)
 {
   GdkWindowObject *private = (GdkWindowObject *)window;
   GdkWindowImplWin32 *window_impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
@@ -882,9 +876,9 @@ get_outer_rect (GdkWindow *window,
 
 static void
 adjust_for_gravity_hints (GdkWindow *window,
-						  RECT      *outer_rect,
-						  gint		*x,
-						  gint		*y)
+			  RECT      *outer_rect,
+			  gint		*x,
+			  gint		*y)
 {
 	GdkWindowObject *obj;
 	GdkWindowImplWin32 *impl;
@@ -1031,10 +1025,10 @@ show_window_internal (GdkWindow *window,
     {
       UINT flags = SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE | SWP_NOSIZE;
 
-	  if (!raise)
-		flags |= SWP_NOZORDER;
+      if (!raise)
+	flags |= SWP_NOZORDER;
       if (!raise || GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP || !focus_on_map)
-		flags |= SWP_NOACTIVATE;
+	flags |= SWP_NOACTIVATE;
 
       SetWindowPos (GDK_WINDOW_HWND (window), top, 0, 0, 0, 0, flags);
 
@@ -1425,7 +1419,6 @@ gdk_win32_window_reparent (GdkWindow *window,
       g_list_remove (old_parent_private->children, window);
 
   parent_private->children = g_list_prepend (parent_private->children, window);
-  //_gdk_window_init_position (GDK_WINDOW (window_private));
 
   return FALSE;
 }
@@ -1866,7 +1859,6 @@ static void
 gdk_win32_window_set_background (GdkWindow      *window,
 				 const GdkColor *color)
 {
-#if 0
   GdkWindowObject *private = (GdkWindowObject *)window;
   
   GDK_NOTE (MISC, g_print ("gdk_window_set_background: %p: %s\n",
@@ -1874,15 +1866,6 @@ gdk_win32_window_set_background (GdkWindow      *window,
 			   _gdk_win32_color_to_string (color)));
 
   private->bg_color = *color;
-
-  if (private->bg_pixmap &&
-      private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
-      private->bg_pixmap != GDK_NO_BG)
-    {
-      g_object_unref (private->bg_pixmap);
-      private->bg_pixmap = NULL;
-    }
-#endif
 }
 
 static void
@@ -1891,15 +1874,7 @@ gdk_win32_window_set_back_pixmap (GdkWindow *window,
 {
   GdkWindowObject *private = (GdkWindowObject *)window;
 
-  if (private->bg_pixmap &&
-      private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
-      private->bg_pixmap != GDK_NO_BG)
-    g_object_unref (private->bg_pixmap);
-
-  if (pixmap == GDK_PARENT_RELATIVE_BG || pixmap == GDK_NO_BG)
-    {
-      private->bg_pixmap = pixmap;
-    }
+  /* TODO_CSW? but win32 has no XSetWindowBackgroundPixmap */
 }
 
 static void
@@ -1953,7 +1928,8 @@ gdk_win32_window_set_cursor (GdkWindow *window,
     {
       /* If the pointer is over our window, set new cursor */
       GdkWindow *curr_window = gdk_window_get_pointer (window, NULL, NULL, NULL);
-      if (curr_window == window)
+      if (curr_window == window ||
+	  (curr_window && window == gdk_window_get_toplevel (curr_window)))
         SetCursor (impl->hcursor);
       else
 	{
@@ -2116,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,
@@ -2277,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;
@@ -2299,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);
@@ -2377,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
     {
@@ -2392,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;
     }
 }
 
@@ -2906,30 +2892,6 @@ gdk_win32_window_merge_child_shapes (GdkWindow *window)
   gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE);
 }
 
-#if 0
-void 
-gdk_window_set_child_input_shapes (GdkWindow *window)
-{
-  g_return_if_fail (GDK_IS_WINDOW (window));
-  
-  /* Not yet implemented. See comment in
-   * gdk_window_input_shape_combine_mask().
-   */
-}
-#endif
-
-#if 0
-void 
-gdk_window_merge_child_input_shapes (GdkWindow *window)
-{
-  g_return_if_fail (GDK_IS_WINDOW (window));
-  
-  /* Not yet implemented. See comment in
-   * gdk_window_input_shape_combine_mask().
-   */
-}
-#endif
-
 static gboolean 
 gdk_win32_window_set_static_gravities (GdkWindow *window,
 				 gboolean   use_static)
@@ -3395,6 +3357,7 @@ gdk_window_set_skip_taskbar_hint (GdkWindow *window,
 #if 0 /* Should we also turn off the minimize and maximize buttons? */
       SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE,
 		     GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE) & ~(WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_SYSMENU));
+     
       SetWindowPos (GDK_WINDOW_HWND (window), NULL,
 		    0, 0, 0, 0,
 		    SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE |
@@ -3469,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
     {
@@ -3483,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;
     }
 }
 
@@ -3556,8 +3515,13 @@ gdk_window_set_opacity (GdkWindow *window,
 GdkRegion *
 _gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
 {
-	// XXX: TODO
-	return NULL;
+  GdkRegion *region;
+  HRGN hrgn = _gdk_win32_bitmap_to_hrgn (mask);
+
+  region = _gdk_win32_hrgn_to_region (hrgn);
+  DeleteObject (hrgn);
+
+  return region;
 }
 
 void
@@ -3568,20 +3532,25 @@ _gdk_windowing_window_set_composited (GdkWindow *window, gboolean composited)
 GdkRegion *
 _gdk_windowing_window_get_shape (GdkWindow *window)
 {
-	return NULL;
+  HRGN hrgn = CreateRectRgn (0, 0, 0, 0);
+  int  type = GetWindowRgn (GDK_WINDOW_HWND (window), hrgn);
+
+  if (type == SIMPLEREGION || type == COMPLEXREGION)
+    {
+      GdkRegion *region = _gdk_win32_hrgn_to_region (hrgn);
+
+      DeleteObject (hrgn);
+      return region;
+    }
+
+  return NULL;
 }
 
 GdkRegion *
 _gdk_windowing_window_get_input_shape (GdkWindow *window)
 {
-	return NULL;
-}
-
-static void
-_gdk_win32_window_destroy (GdkWindow *window,
-			   gboolean   recursing,
-			   gboolean   foreign_destroy)
-{
+  /* CHECK: are these really supposed to be the same? */
+  return _gdk_windowing_window_get_shape (window);
 }
 
 static gboolean
@@ -3601,14 +3570,42 @@ _gdk_win32_window_queue_antiexpose (GdkWindow *window,
   return FALSE;
 }
 
+/*
+ * queue_translation is meant to only move any outstanding invalid area
+ * in the given area by dx,dy. A typical example of when its needed is an
+ * app with two toplevels where one (A) overlaps the other (B). If the
+ * app first moves A so that B is invalidated and then scrolls B before
+ * handling the expose. The scroll operation will copy the invalid area
+ * to a new position, but when the invalid area is then exposed it only
+ * redraws the old areas not the place where the invalid data was copied
+ * by the scroll.
+ */
 static void
 _gdk_win32_window_queue_translation (GdkWindow *window,
+				     GdkGC     *gc,
 				     GdkRegion *area,
 				     gint       dx,
 				     gint       dy)
 {
-  /* TODO: Get current updateregion, move any part of it that intersects area by dx,dy */
-  g_print ("queue_translation\n");
+  HRGN hrgn = CreateRectRgn (0, 0, 0, 0);
+  int ret = GetUpdateRgn (GDK_WINDOW_HWND (window), hrgn, FALSE);
+  if (ret == ERROR)
+    WIN32_API_FAILED ("GetUpdateRgn");
+  else if (ret != NULLREGION)
+    {
+      /* Get current updateregion, move any part of it that intersects area by dx,dy */
+      HRGN update = _gdk_win32_gdkregion_to_hrgn (area, 0, 0);
+      ret = CombineRgn (update, hrgn, update, RGN_AND);
+      if (ret == ERROR)
+        WIN32_API_FAILED ("CombineRgn");
+      else if (ret != NULLREGION)
+	{
+	  OffsetRgn (update, dx, dy);
+          API_CALL (InvalidateRgn, (GDK_WINDOW_HWND (window), update, TRUE));
+	}
+      DeleteObject (update);
+    }
+  DeleteObject (hrgn);
 }
 
 static void
@@ -3617,6 +3614,10 @@ gdk_win32_input_shape_combine_region (GdkWindow *window,
 				      gint offset_x,
 				      gint offset_y)
 {
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+  /* CHECK: are these really supposed to be the same? */
+  gdk_win32_window_shape_combine_region (window, shape_region, offset_x, offset_y);
 }
 
 void
@@ -3647,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;
@@ -3662,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;
 }

gdk/win32/makefile.msc

@@ -16,10 +16,13 @@ WTKIT = $(TOP)\wtkit126
 
 GTK_VER=2.0
 
-CFLAGS = -FImsvc_recommended_pragmas.h \
+DEFINES = \
+	-DHAVE_CONFIG_H -DINSIDE_GDK_WIN32 -DGDK_VERSION=\"$(GTK_VER)\" \
+	-DGDK_COMPILATION -DG_LOG_DOMAIN=\"Gdk\"
+
+INCLUDES = -FImsvc_recommended_pragmas.h \
 	-I. -I.. -I..\.. $(GLIB_CFLAGS) $(PANGO_CFLAGS) $(CAIRO_CFLAGS) \
 	-I$(WTKIT)\include -I$(GLIB) \
-	$(G_DEBUGGING) -DHAVE_CONFIG_H -DINSIDE_GDK_WIN32 -DGDK_VERSION=\"$(GTK_VER)\"
 
 all: \
 	..\..\config.h	\
@@ -68,9 +71,6 @@ gdk.res : rc\gdk.rc
 gdk-win32.lib : $(gdk_win32_OBJECTS)
 	lib -out:gdk-win32.lib $(gdk_win32_OBJECTS)
 
-.c.obj :
-	$(CC) $(CFLAGS) -GD -c -DGDK_COMPILATION -DG_LOG_DOMAIN=\"Gdk\" $<
-
 clean::
 	del *.obj
 	del *.lib

gdk/x11/gdkdisplay-x11.c

@@ -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);
 }
 
 /**