Fix --enable-webview_xxx options names in configure.

[wxWidgets.git] / src / gtk / window.cpp
diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp

index b54478de790100008ed244194669aaaa28a41c7e..2a60441507f5ebf7b763ee03fe49e3930ea8b28a 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -32,41 +32,34 @@
  #include "wx/caret.h"
  #include "wx/fontutil.h"
  #include "wx/sysopt.h"
  #include "wx/caret.h"
  #include "wx/fontutil.h"
  #include "wx/sysopt.h"
+#ifdef __WXGTK3__
+    #include "wx/gtk/dc.h"
+#endif
  
  #include <ctype.h>
  
  
  #include <ctype.h>
  
+#include <gtk/gtk.h>
  #include "wx/gtk/private.h"
  #include "wx/gtk/private.h"
+#include "wx/gtk/private/gtk2-compat.h"
+#include "wx/gtk/private/event.h"
  #include "wx/gtk/private/win_gtk.h"
  #include "wx/gtk/private/win_gtk.h"
+using namespace wxGTKImpl;
  
  
+#ifdef GDK_WINDOWING_X11
  #include <gdk/gdkx.h>
  #include <gdk/gdkx.h>
+#include "wx/x11/private/wrapxkb.h"
+#else
+typedef guint KeySym;
+#endif
  
  #include <gdk/gdkkeysyms.h>
  
  #include <gdk/gdkkeysyms.h>
-#if GTK_CHECK_VERSION(3,0,0)
+#ifdef __WXGTK3__
  #include <gdk/gdkkeysyms-compat.h>
  #endif
  
  #include <gdk/gdkkeysyms-compat.h>
  #endif
  
-#if !GTK_CHECK_VERSION(2,10,0)
-    // GTK+ can reliably detect Meta key state only since 2.10 when
-    // GDK_META_MASK was introduced -- there wasn't any way to detect it
-    // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but
-    // GDK_MOD2_MASK is documented as:
-    //
-    //     the fifth modifier key (it depends on the modifier mapping of the X
-    //     server which key is interpreted as this modifier)
-    //
-    // In other words, it isn't guaranteed to map to Meta. This is a real
-    // problem: it is common to map NumLock to it (in fact, it's an exception
-    // if the X server _doesn't_ use it for NumLock).  So the old code caused
-    // wxKeyEvent::MetaDown() to always return true as long as NumLock was on
-    // on many systems, which broke all applications using
-    // wxKeyEvent::GetModifiers() to check modifiers state (see e.g.  here:
-    // http://tinyurl.com/56lsk2).
-    //
-    // Because of this, it's better to not detect Meta key state at all than
-    // to detect it incorrectly. Hence the following #define, which causes
-    // m_metaDown to be always set to false.
-    #define GDK_META_MASK 0
-#endif
+// gdk_window_set_composited() is only supported since 2.12
+#define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
+#define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
  
  //-----------------------------------------------------------------------------
  // documentation on internals
  
  //-----------------------------------------------------------------------------
  // documentation on internals
@@ -234,86 +227,54 @@ int          g_lastButtonNumber = 0;
  #define TRACE_FOCUS wxT("focus")
  
  //-----------------------------------------------------------------------------
  #define TRACE_FOCUS wxT("focus")
  
  //-----------------------------------------------------------------------------
-// missing gdk functions
-//-----------------------------------------------------------------------------
-
-void
-gdk_window_warp_pointer (GdkWindow      *window,
-                         gint            x,
-                         gint            y)
-{
-  if (!window)
-    window = gdk_get_default_root_window();
-
-  if (!GDK_WINDOW_DESTROYED(window))
-  {
-      XWarpPointer (GDK_WINDOW_XDISPLAY(window),
-                    None,              /* not source window -> move from anywhere */
-                    GDK_WINDOW_XID(window),  /* dest window */
-                    0, 0, 0, 0,        /* not source window -> move from anywhere */
-                    x, y );
-  }
-}
-
-
-//-----------------------------------------------------------------------------
-// "size_request" of m_widget
+// "expose_event"/"draw" from m_wxwindow
  //-----------------------------------------------------------------------------
  
  extern "C" {
  //-----------------------------------------------------------------------------
  
  extern "C" {
-static void
-wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget),
-                                   GtkRequisition *requisition,
-                                   wxWindow * win)
+#ifdef __WXGTK3__
+static gboolean draw(GtkWidget*, cairo_t* cr, wxWindow* win)
  {
  {
-    int w, h;
-    win->GetSize( &w, &h );
-    if (w < 2)
-        w = 2;
-    if (h < 2)
-        h = 2;
+    if (gtk_cairo_should_draw_window(cr, win->GTKGetDrawingWindow()))
+        win->GTKSendPaintEvents(cr);
  
  
-    requisition->height = h;
-    requisition->width = w;
-}
+    return false;
  }
  }
-
-//-----------------------------------------------------------------------------
-// "expose_event" of m_wxwindow
-//-----------------------------------------------------------------------------
-
-extern "C" {
-static gboolean
-gtk_window_expose_callback( GtkWidget*,
-                            GdkEventExpose *gdk_event,
-                            wxWindow *win )
+#else // !__WXGTK3__
+static gboolean expose_event(GtkWidget*, GdkEventExpose* gdk_event, wxWindow* win)
  {
      if (gdk_event->window == win->GTKGetDrawingWindow())
  {
      if (gdk_event->window == win->GTKGetDrawingWindow())
-    {
-        win->GetUpdateRegion() = wxRegion( gdk_event->region );
-        win->GtkSendPaintEvents();
-    }
-    // Let parent window draw window-less widgets
-    return FALSE;
+        win->GTKSendPaintEvents(gdk_event->region);
+
+    return false;
  }
  }
+#endif // !__WXGTK3__
  }
  
  #ifndef __WXUNIVERSAL__
  //-----------------------------------------------------------------------------
  }
  
  #ifndef __WXUNIVERSAL__
  //-----------------------------------------------------------------------------
-// "expose_event" from m_wxwindow->parent, for drawing border
+// "expose_event"/"draw" from m_wxwindow->parent, for drawing border
  //-----------------------------------------------------------------------------
  
  extern "C" {
  static gboolean
  //-----------------------------------------------------------------------------
  
  extern "C" {
  static gboolean
-expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+#ifdef __WXGTK3__
+draw_border(GtkWidget*, cairo_t* cr, wxWindow* win)
+#else
+draw_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+#endif
  {
  {
+#ifdef __WXGTK3__
+    if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_parent_window(win->m_wxwindow)))
+#else
      if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))
      if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))
+#endif
          return false;
  
      if (!win->IsShown())
          return false;
  
          return false;
  
      if (!win->IsShown())
          return false;
  
-    const GtkAllocation& alloc = win->m_wxwindow->allocation;
+    GtkAllocation alloc;
+    gtk_widget_get_allocation(win->m_wxwindow, &alloc);
      const int x = alloc.x;
      const int y = alloc.y;
      const int w = alloc.width;
      const int x = alloc.x;
      const int y = alloc.y;
      const int w = alloc.width;
@@ -324,27 +285,55 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
  
      if (win->HasFlag(wxBORDER_SIMPLE))
      {
  
      if (win->HasFlag(wxBORDER_SIMPLE))
      {
+#ifdef __WXGTK3__
+        GtkStyleContext* sc = gtk_widget_get_style_context(win->m_wxwindow);
+        GdkRGBA c;
+        gtk_style_context_get_border_color(sc, GTK_STATE_FLAG_NORMAL, &c);
+        gdk_cairo_set_source_rgba(cr, &c);
+        cairo_set_line_width(cr, 1);
+        cairo_rectangle(cr, x + 0.5, y + 0.5, w - 1, h - 1);
+        cairo_stroke(cr);
+#else
          gdk_draw_rectangle(gdk_event->window,
          gdk_draw_rectangle(gdk_event->window,
-            widget->style->black_gc, false, x, y, w - 1, h - 1);
+            gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1);
+#endif
      }
      }
-    else
+    else if (win->HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))
      {
      {
+#ifdef __WXGTK3__
+        //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN
+        GtkStyleContext* sc;
+        if (win->HasFlag(wxHSCROLL | wxVSCROLL))
+            sc = gtk_widget_get_style_context(wxGTKPrivate::GetTreeWidget());
+        else
+            sc = gtk_widget_get_style_context(wxGTKPrivate::GetEntryWidget());
+
+        gtk_render_frame(sc, cr, x, y, w, h);
+#else // !__WXGTK3__
          GtkShadowType shadow = GTK_SHADOW_IN;
          if (win->HasFlag(wxBORDER_RAISED))
              shadow = GTK_SHADOW_OUT;
  
          GtkShadowType shadow = GTK_SHADOW_IN;
          if (win->HasFlag(wxBORDER_RAISED))
              shadow = GTK_SHADOW_OUT;
  
-        // Style detail to use
+        GtkStyle* style;
          const char* detail;
          const char* detail;
-        if (win->m_widget == win->m_wxwindow)
-            // for non-scrollable wxWindows
-            detail = "entry";
-        else
-            // for scrollable ones
+        if (win->HasFlag(wxHSCROLL | wxVSCROLL))
+        {
+            style = gtk_widget_get_style(wxGTKPrivate::GetTreeWidget());
              detail = "viewport";
              detail = "viewport";
+        }
+        else
+        {
+            style = gtk_widget_get_style(wxGTKPrivate::GetEntryWidget());
+            detail = "entry";
+        }
  
  
+        // clip rect is required to avoid painting background
+        // over upper left (w,h) of parent window
+        GdkRectangle clipRect = { x, y, w, h };
          gtk_paint_shadow(
          gtk_paint_shadow(
-           win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
-           shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
+           style, gdk_event->window, GTK_STATE_NORMAL,
+           shadow, &clipRect, widget, detail, x, y, w, h);
+#endif // !__WXGTK3__
      }
      return false;
  }
      }
      return false;
  }
@@ -356,17 +345,21 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
  
  extern "C" {
  static void
  
  extern "C" {
  static void
-parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
+parent_set(GtkWidget* widget, GtkWidget* old_parent, wxWindow* win)
  {
      if (old_parent)
      {
          g_signal_handlers_disconnect_by_func(
  {
      if (old_parent)
      {
          g_signal_handlers_disconnect_by_func(
-            old_parent, (void*)expose_event_border, win);
+            old_parent, (void*)draw_border, win);
      }
      }
-    if (widget->parent)
+    GtkWidget* parent = gtk_widget_get_parent(widget);
+    if (parent)
      {
      {
-        g_signal_connect_after(widget->parent, "expose_event",
-            G_CALLBACK(expose_event_border), win);
+#ifdef __WXGTK3__
+        g_signal_connect_after(parent, "draw", G_CALLBACK(draw_border), win);
+#else
+        g_signal_connect_after(parent, "expose_event", G_CALLBACK(draw_border), win);
+#endif
      }
  }
  }
      }
  }
  }
@@ -376,18 +369,6 @@ parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
  // "key_press_event" from any window
  //-----------------------------------------------------------------------------
  
  // "key_press_event" from any window
  //-----------------------------------------------------------------------------
  
-// These are used when transforming Ctrl-alpha to ascii values 1-26
-inline bool wxIsLowerChar(int code)
-{
-    return (code >= 'a' && code <= 'z' );
-}
-
-inline bool wxIsUpperChar(int code)
-{
-    return (code >= 'A' && code <= 'Z' );
-}
-
-
  // set WXTRACE to this to see the key event codes on the console
  #define TRACE_KEYS  wxT("keyevent")
  
  // set WXTRACE to this to see the key event codes on the console
  #define TRACE_KEYS  wxT("keyevent")
  
@@ -677,12 +658,6 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event,
                                        wxWindowGTK *win,
                                        GdkEventKey *gdk_event)
  {
                                        wxWindowGTK *win,
                                        GdkEventKey *gdk_event)
  {
-    int x = 0;
-    int y = 0;
-    GdkModifierType state;
-    if (gdk_event->window)
-        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
-
      event.SetTimestamp( gdk_event->time );
      event.SetId(win->GetId());
  
      event.SetTimestamp( gdk_event->time );
      event.SetId(win->GetId());
  
@@ -736,10 +711,8 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event,
      event.m_rawCode = (wxUint32) gdk_event->keyval;
      event.m_rawFlags = gdk_event->hardware_keycode;
  
      event.m_rawCode = (wxUint32) gdk_event->keyval;
      event.m_rawFlags = gdk_event->hardware_keycode;
  
-    wxGetMousePosition( &x, &y );
-    win->ScreenToClient( &x, &y );
-    event.m_x = x;
-    event.m_y = y;
+    wxGetMousePosition(&event.m_x, &event.m_y);
+    win->ScreenToClient(&event.m_x, &event.m_y);
      event.SetEventObject( win );
  }
  
      event.SetEventObject( win );
  }
  
@@ -782,6 +755,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
                  keysym = (KeySym)gdk_event->string[0];
              }
  
                  keysym = (KeySym)gdk_event->string[0];
              }
  
+#ifdef GDK_WINDOWING_X11
              // we want to always get the same key code when the same key is
              // pressed regardless of the state of the modifiers, i.e. on a
              // standard US keyboard pressing '5' or '%' ('5' key with
              // we want to always get the same key code when the same key is
              // pressed regardless of the state of the modifiers, i.e. on a
              // standard US keyboard pressing '5' or '%' ('5' key with
@@ -795,11 +769,18 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
  
              wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
  
  
              wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
  
+#ifdef HAVE_X11_XKBLIB_H
+            KeySym keysymNormalized = XkbKeycodeToKeysym(dpy, keycode, 0, 0);
+#else
              KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
              KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
+#endif
  
              // use the normalized, i.e. lower register, keysym if we've
              // got one
              key_code = keysymNormalized ? keysymNormalized : keysym;
  
              // use the normalized, i.e. lower register, keysym if we've
              // got one
              key_code = keysymNormalized ? keysymNormalized : keysym;
+#else
+            key_code = keysym;
+#endif
  
              // as explained above, we want to have lower register key codes
              // normally but for the letter keys we want to have the upper ones
  
              // as explained above, we want to have lower register key codes
              // normally but for the letter keys we want to have the upper ones
@@ -877,38 +858,73 @@ struct wxGtkIMData
  namespace
  {
  
  namespace
  {
  
-// Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
-// processed, send wxEVT_CHAR to the window itself. Return true if either of
-// them was handled.
-bool
-SendCharHookAndCharEvents(const wxKeyEvent& event, wxWindow *win)
+// Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
+// if it was processed (and not skipped).
+bool SendCharHookEvent(const wxKeyEvent& event, wxWindow *win)
  {
  {
-    // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
+    // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
+    // which typically closes when Esc key is pressed in any of its controls)
      // to handle key events in all of its children unless the mouse is captured
      // in which case we consider that the keyboard should be "captured" too.
      if ( !g_captureWindow )
      {
      // to handle key events in all of its children unless the mouse is captured
      // in which case we consider that the keyboard should be "captured" too.
      if ( !g_captureWindow )
      {
-        wxWindow * const parent = wxGetTopLevelParent(win);
-        if ( parent )
-        {
-            // We need to make a copy of the event object because it is
-            // modified while it's handled, notably its WasProcessed() flag
-            // is set after it had been processed once.
-            wxKeyEvent eventCharHook(event);
-            eventCharHook.SetEventType(wxEVT_CHAR_HOOK);
-            if ( parent->HandleWindowEvent(eventCharHook) )
-                return true;
-        }
+        wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
+        if ( win->HandleWindowEvent(eventCharHook)
+                && !event.IsNextEventAllowed() )
+            return true;
      }
  
      }
  
-    // As above, make a copy of the event first.
-    wxKeyEvent eventChar(event);
-    eventChar.SetEventType(wxEVT_CHAR);
-    return win->HandleWindowEvent(eventChar);
+    return false;
+}
+
+// Adjust wxEVT_CHAR event key code fields. This function takes care of two
+// conventions:
+// (a) Ctrl-letter key presses generate key codes in range 1..26
+// (b) Unicode key codes are same as key codes for the codes in 1..255 range
+void AdjustCharEventKeyCodes(wxKeyEvent& event)
+{
+    const int code = event.m_keyCode;
+
+    // Check for (a) above.
+    if ( event.ControlDown() )
+    {
+        // We intentionally don't use isupper/lower() here, we really need
+        // ASCII letters only as it doesn't make sense to translate any other
+        // ones into this range which has only 26 slots.
+        if ( code >= 'a' && code <= 'z' )
+            event.m_keyCode = code - 'a' + 1;
+        else if ( code >= 'A' && code <= 'Z' )
+            event.m_keyCode = code - 'A' + 1;
+
+#if wxUSE_UNICODE
+        // Adjust the Unicode equivalent in the same way too.
+        if ( event.m_keyCode != code )
+            event.m_uniChar = event.m_keyCode;
+#endif // wxUSE_UNICODE
+    }
+
+#if wxUSE_UNICODE
+    // Check for (b) from above.
+    //
+    // FIXME: Should we do it for key codes up to 255?
+    if ( !event.m_uniChar && code < WXK_DELETE )
+        event.m_uniChar = code;
+#endif // wxUSE_UNICODE
  }
  
  } // anonymous namespace
  
  }
  
  } // anonymous namespace
  
+// If a widget does not handle a key or mouse event, GTK+ sends it up the
+// parent chain until it is handled. These events are not supposed to propagate
+// in wxWidgets, so this code avoids handling them in any parent wxWindow,
+// while still allowing the event to propagate so things like native keyboard
+// navigation will work.
+#define wxPROCESS_EVENT_ONCE(EventType, event) \
+    static EventType eventPrev; \
+    if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
+        return false; \
+    eventPrev = *event
+
  extern "C" {
  static gboolean
  gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
  extern "C" {
  static gboolean
  gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
@@ -920,44 +936,23 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
      if (g_blockEventsOnDrag)
          return FALSE;
  
      if (g_blockEventsOnDrag)
          return FALSE;
  
+    wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event);
+
      wxKeyEvent event( wxEVT_KEY_DOWN );
      bool ret = false;
      bool return_after_IM = false;
  
      if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
      wxKeyEvent event( wxEVT_KEY_DOWN );
      bool ret = false;
      bool return_after_IM = false;
  
      if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
-        // Emit KEY_DOWN event
-        ret = win->HandleWindowEvent( event );
-    }
-    else
-    {
-        // Return after IM processing as we cannot do
-        // anything with it anyhow.
-        return_after_IM = true;
-    }
-
-    if (!ret && win->m_imData)
-    {
-        win->m_imData->lastKeyEvent = gdk_event;
-
-        // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
-        // docs, if IM filter returns true, no further processing should be done.
-        // we should send the key_down event anyway.
-        bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
-        win->m_imData->lastKeyEvent = NULL;
-        if (intercepted_by_IM)
+        // Send the CHAR_HOOK event first
+        if ( SendCharHookEvent(event, win) )
          {
          {
-            wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
+            // Don't do anything at all with this event any more.
              return TRUE;
          }
              return TRUE;
          }
-    }
-
-    if (return_after_IM)
-        return FALSE;
  
  
+        // Next check for accelerators.
  #if wxUSE_ACCEL
  #if wxUSE_ACCEL
-    if (!ret)
-    {
          wxWindowGTK *ancestor = win;
          while (ancestor)
          {
          wxWindowGTK *ancestor = win;
          while (ancestor)
          {
@@ -982,9 +977,39 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
                  break;
              ancestor = ancestor->GetParent();
          }
                  break;
              ancestor = ancestor->GetParent();
          }
-    }
  #endif // wxUSE_ACCEL
  
  #endif // wxUSE_ACCEL
  
+        // If not an accelerator, then emit KEY_DOWN event
+        if ( !ret )
+            ret = win->HandleWindowEvent( event );
+    }
+    else
+    {
+        // Return after IM processing as we cannot do
+        // anything with it anyhow.
+        return_after_IM = true;
+    }
+
+    if (!ret && win->m_imData)
+    {
+        win->m_imData->lastKeyEvent = gdk_event;
+
+        // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
+        // docs, if IM filter returns true, no further processing should be done.
+        // we should send the key_down event anyway.
+        bool intercepted_by_IM =
+            gtk_im_context_filter_keypress(win->m_imData->context, gdk_event) != 0;
+        win->m_imData->lastKeyEvent = NULL;
+        if (intercepted_by_IM)
+        {
+            wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
+            return TRUE;
+        }
+    }
+
+    if (return_after_IM)
+        return FALSE;
+
      // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
      // will only be sent if it is not in an accelerator table.
      if (!ret)
      // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
      // will only be sent if it is not in an accelerator table.
      if (!ret)
@@ -1009,25 +1034,15 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
  
          if ( key_code )
          {
  
          if ( key_code )
          {
+            wxKeyEvent eventChar(wxEVT_CHAR, event);
+
              wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
  
              wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
  
-            event.m_keyCode = key_code;
+            eventChar.m_keyCode = key_code;
  
  
-            // To conform to the docs we need to translate Ctrl-alpha
-            // characters to values in the range 1-26.
-            if ( event.ControlDown() &&
-                 ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
-            {
-                if ( wxIsLowerChar(key_code) )
-                    event.m_keyCode = key_code - 'a' + 1;
-                if ( wxIsUpperChar(key_code) )
-                    event.m_keyCode = key_code - 'A' + 1;
-#if wxUSE_UNICODE
-                event.m_uniChar = event.m_keyCode;
-#endif
-            }
+            AdjustCharEventKeyCodes(eventChar);
  
  
-            ret = SendCharHookAndCharEvents(event, win);
+            ret = win->HandleWindowEvent(eventChar);
          }
      }
  
          }
      }
  
@@ -1041,7 +1056,7 @@ gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
                          const gchar  *str,
                          wxWindow     *window)
  {
                          const gchar  *str,
                          wxWindow     *window)
  {
-    wxKeyEvent event( wxEVT_KEY_DOWN );
+    wxKeyEvent event( wxEVT_CHAR );
  
      // take modifiers, cursor position, timestamp etc. from the last
      // key_press_event that was fed into Input Method:
  
      // take modifiers, cursor position, timestamp etc. from the last
      // key_press_event that was fed into Input Method:
@@ -1070,23 +1085,9 @@ gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
          event.m_keyCode = (char)*pstr;
  #endif  // wxUSE_UNICODE
  
          event.m_keyCode = (char)*pstr;
  #endif  // wxUSE_UNICODE
  
-        // To conform to the docs we need to translate Ctrl-alpha
-        // characters to values in the range 1-26.
-        if ( event.ControlDown() &&
-             ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) ))
-        {
-            if ( wxIsLowerChar(*pstr) )
-                event.m_keyCode = *pstr - 'a' + 1;
-            if ( wxIsUpperChar(*pstr) )
-                event.m_keyCode = *pstr - 'A' + 1;
-
-            event.m_keyCode = *pstr - 'a' + 1;
-#if wxUSE_UNICODE
-            event.m_uniChar = event.m_keyCode;
-#endif
-        }
+        AdjustCharEventKeyCodes(event);
  
  
-        SendCharHookAndCharEvents(event, window);
+        window->HandleWindowEvent(event);
      }
  }
  }
      }
  }
  }
@@ -1108,6 +1109,8 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
      if (g_blockEventsOnDrag)
          return FALSE;
  
      if (g_blockEventsOnDrag)
          return FALSE;
  
+    wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event);
+
      wxKeyEvent event( wxEVT_KEY_UP );
      if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
      wxKeyEvent event( wxEVT_KEY_UP );
      if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
@@ -1127,38 +1130,6 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
  // mouse event processing helpers
  // ----------------------------------------------------------------------------
  
  // mouse event processing helpers
  // ----------------------------------------------------------------------------
  
-// init wxMouseEvent with the info from GdkEventXXX struct
-template<typename T> void InitMouseEvent(wxWindowGTK *win,
-                                         wxMouseEvent& event,
-                                         T *gdk_event)
-{
-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
-    event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0;
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0;
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0;
-    event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0;
-    event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0;
-
-    wxPoint pt = win->GetClientAreaOrigin();
-    event.m_x = (wxCoord)gdk_event->x - pt.x;
-    event.m_y = (wxCoord)gdk_event->y - pt.y;
-
-    if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
-    {
-        // origin in the upper right corner
-        int window_width = win->m_wxwindow->allocation.width;
-        event.m_x = window_width - event.m_x;
-    }
-
-    event.SetEventObject( win );
-    event.SetId( win->GetId() );
-    event.SetTimestamp( gdk_event->time );
-}
-
  static void AdjustEventButtonState(wxMouseEvent& event)
  {
      // GDK reports the old state of the button for a button press event, but
  static void AdjustEventButtonState(wxMouseEvent& event)
  {
      // GDK reports the old state of the button for a button press event, but
@@ -1189,9 +1160,23 @@ static void AdjustEventButtonState(wxMouseEvent& event)
          event.m_rightDown = !event.m_rightDown;
          return;
      }
          event.m_rightDown = !event.m_rightDown;
          return;
      }
+
+    if ((event.GetEventType() == wxEVT_AUX1_DOWN) ||
+        (event.GetEventType() == wxEVT_AUX1_DCLICK))
+    {
+        event.m_aux1Down = true;
+        return;
+    }
+
+    if ((event.GetEventType() == wxEVT_AUX2_DOWN) ||
+        (event.GetEventType() == wxEVT_AUX2_DCLICK))
+    {
+        event.m_aux2Down = true;
+        return;
+    }
  }
  
  }
  
-// find the window to send the mouse event too
+// find the window to send the mouse event to
  static
  wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
  {
  static
  wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
  {
@@ -1208,7 +1193,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
      wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
      while (node)
      {
      wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
      while (node)
      {
-        wxWindowGTK *child = node->GetData();
+        wxWindow* child = static_cast<wxWindow*>(node->GetData());
  
          node = node->GetNext();
          if (!child->IsShown())
  
          node = node->GetNext();
          if (!child->IsShown())
@@ -1241,6 +1226,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
          else
          {
              if ((child->m_wxwindow == NULL) &&
          else
          {
              if ((child->m_wxwindow == NULL) &&
+                win->IsClientAreaChild(child) &&
                  (child->m_x <= xx) &&
                  (child->m_y <= yy) &&
                  (child->m_x+child->m_width  >= xx) &&
                  (child->m_x <= xx) &&
                  (child->m_y <= yy) &&
                  (child->m_x+child->m_width  >= xx) &&
@@ -1316,112 +1302,89 @@ extern "C"
  //-----------------------------------------------------------------------------
  
  static gboolean
  //-----------------------------------------------------------------------------
  
  static gboolean
-gtk_window_button_press_callback( GtkWidget *widget,
+gtk_window_button_press_callback( GtkWidget* WXUNUSED_IN_GTK3(widget),
                                    GdkEventButton *gdk_event,
                                    wxWindowGTK *win )
  {
                                    GdkEventButton *gdk_event,
                                    wxWindowGTK *win )
  {
+    wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event);
+
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      g_lastButtonNumber = gdk_event->button;
  
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      g_lastButtonNumber = gdk_event->button;
  
-    // GDK sends surplus button down events
-    // before a double click event. We
-    // need to filter these out.
-    if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
+    wxEventType event_type;
+    wxEventType down;
+    wxEventType dclick;
+    switch (gdk_event->button)
      {
      {
-        GdkEvent *peek_event = gdk_event_peek();
-        if (peek_event)
-        {
-            if ((peek_event->type == GDK_2BUTTON_PRESS) ||
-                (peek_event->type == GDK_3BUTTON_PRESS))
+        case 1:
+            down = wxEVT_LEFT_DOWN;
+            dclick = wxEVT_LEFT_DCLICK;
+            break;
+        case 2:
+            down = wxEVT_MIDDLE_DOWN;
+            dclick = wxEVT_MIDDLE_DCLICK;
+            break;
+        case 3:
+            down = wxEVT_RIGHT_DOWN;
+            dclick = wxEVT_RIGHT_DCLICK;
+            break;
+        case 8:
+            down = wxEVT_AUX1_DOWN;
+            dclick = wxEVT_AUX1_DCLICK;
+            break;
+        case 9:
+            down = wxEVT_AUX2_DOWN;
+            dclick = wxEVT_AUX2_DCLICK;
+            break;
+        default:
+            return false;
+    }
+    switch (gdk_event->type)
+    {
+        case GDK_BUTTON_PRESS:
+            event_type = down;
+            // GDK sends surplus button down events
+            // before a double click event. We
+            // need to filter these out.
+            if (win->m_wxwindow)
              {
              {
-                gdk_event_free( peek_event );
-                return TRUE;
+                GdkEvent* peek_event = gdk_event_peek();
+                if (peek_event)
+                {
+                    const GdkEventType peek_event_type = peek_event->type;
+                    gdk_event_free(peek_event);
+                    if (peek_event_type == GDK_2BUTTON_PRESS ||
+                        peek_event_type == GDK_3BUTTON_PRESS)
+                    {
+                        return true;
+                    }
+                }
              }
              }
-            else
+            break;
+        case GDK_2BUTTON_PRESS:
+            event_type = dclick;
+#ifndef __WXGTK3__
+            if (gdk_event->button >= 1 && gdk_event->button <= 3)
              {
              {
-                gdk_event_free( peek_event );
+                // Reset GDK internal timestamp variables in order to disable GDK
+                // triple click events. GDK will then next time believe no button has
+                // been clicked just before, and send a normal button click event.
+                GdkDisplay* display = gtk_widget_get_display(widget);
+                display->button_click_time[1] = 0;
+                display->button_click_time[0] = 0;
              }
              }
-        }
-    }
-
-    wxEventType event_type = wxEVT_NULL;
-
-    if ( gdk_event->type == GDK_2BUTTON_PRESS &&
-            gdk_event->button >= 1 && gdk_event->button <= 3 )
-    {
-        // Reset GDK internal timestamp variables in order to disable GDK
-        // triple click events. GDK will then next time believe no button has
-        // been clicked just before, and send a normal button click event.
-        GdkDisplay* display = gtk_widget_get_display (widget);
-        display->button_click_time[1] = 0;
-        display->button_click_time[0] = 0;
-    }
-
-    if (gdk_event->button == 1)
-    {
-        // note that GDK generates triple click events which are not supported
-        // by wxWidgets but still have to be passed to the app as otherwise
-        // clicks would simply go missing
-        switch (gdk_event->type)
-        {
-            // we shouldn't get triple clicks at all for GTK2 because we
-            // suppress them artificially using the code above but we still
-            // should map them to something for GTK1 and not just ignore them
-            // as this would lose clicks
-            case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_LEFT_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_LEFT_DCLICK;
-                break;
-
-            default:
-                // just to silence gcc warnings
-                ;
-        }
-    }
-    else if (gdk_event->button == 2)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_MIDDLE_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_MIDDLE_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-    else if (gdk_event->button == 3)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_RIGHT_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_RIGHT_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-
-    if ( event_type == wxEVT_NULL )
-    {
-        // unknown mouse button or click type
-        return FALSE;
+#endif // !__WXGTK3__
+            break;
+        // we shouldn't get triple clicks at all for GTK2 because we
+        // suppress them artificially using the code above but we still
+        // should map them to something for GTK3 and not just ignore them
+        // as this would lose clicks
+        case GDK_3BUTTON_PRESS:
+            event_type = down;
+            break;
+        default:
+            return false;
      }
  
      g_lastMouseEvent = (GdkEvent*) gdk_event;
      }
  
      g_lastMouseEvent = (GdkEvent*) gdk_event;
@@ -1481,6 +1444,8 @@ gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
                                      GdkEventButton *gdk_event,
                                      wxWindowGTK *win )
  {
                                      GdkEventButton *gdk_event,
                                      wxWindowGTK *win )
  {
+    wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event);
+
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      g_lastButtonNumber = 0;
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      g_lastButtonNumber = 0;
@@ -1501,6 +1466,14 @@ gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
              event_type = wxEVT_RIGHT_UP;
              break;
  
              event_type = wxEVT_RIGHT_UP;
              break;
  
+        case 8:
+            event_type = wxEVT_AUX1_UP;
+            break;
+
+        case 9:
+            event_type = wxEVT_AUX2_UP;
+            break;
+
          default:
              // unknown button, don't process
              return FALSE;
          default:
              // unknown button, don't process
              return FALSE;
@@ -1536,6 +1509,8 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
                                     GdkEventMotion *gdk_event,
                                     wxWindowGTK *win )
  {
                                     GdkEventMotion *gdk_event,
                                     wxWindowGTK *win )
  {
+    wxPROCESS_EVENT_ONCE(GdkEventMotion, gdk_event);
+
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      if (gdk_event->is_hint)
      wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      if (gdk_event->is_hint)
@@ -1612,22 +1587,16 @@ window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow*
          return false;
      }
  
          return false;
      }
  
-    wxMouseEvent event(wxEVT_MOUSEWHEEL);
-    InitMouseEvent(win, event, gdk_event);
-
      GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
      GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
-    if (!range) return FALSE;
  
      if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
      {
  
      if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
      {
-        GtkAdjustment *adj = range->adjustment;
-        gdouble delta = adj->step_increment * 3;
+        GtkAdjustment* adj = gtk_range_get_adjustment(range);
+        double delta = gtk_adjustment_get_step_increment(adj) * 3;
          if (gdk_event->direction == GDK_SCROLL_LEFT)
              delta = -delta;
  
          if (gdk_event->direction == GDK_SCROLL_LEFT)
              delta = -delta;
  
-        gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
-
-        gtk_adjustment_set_value (adj, new_value);
+        gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
  
          return TRUE;
      }
  
          return TRUE;
      }
@@ -1638,39 +1607,57 @@ window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow*
  static gboolean
  window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
  {
  static gboolean
  window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
  {
-    if (gdk_event->direction != GDK_SCROLL_UP &&
-        gdk_event->direction != GDK_SCROLL_DOWN)
-    {
-        return false;
-    }
-
      wxMouseEvent event(wxEVT_MOUSEWHEEL);
      InitMouseEvent(win, event, gdk_event);
  
      // FIXME: Get these values from GTK or GDK
      event.m_linesPerAction = 3;
      event.m_wheelDelta = 120;
      wxMouseEvent event(wxEVT_MOUSEWHEEL);
      InitMouseEvent(win, event, gdk_event);
  
      // FIXME: Get these values from GTK or GDK
      event.m_linesPerAction = 3;
      event.m_wheelDelta = 120;
-    if (gdk_event->direction == GDK_SCROLL_UP)
-        event.m_wheelRotation = 120;
-    else
-        event.m_wheelRotation = -120;
+
+    // Determine the scroll direction.
+    switch (gdk_event->direction)
+    {
+        case GDK_SCROLL_UP:
+        case GDK_SCROLL_RIGHT:
+            event.m_wheelRotation = 120;
+            break;
+
+        case GDK_SCROLL_DOWN:
+        case GDK_SCROLL_LEFT:
+            event.m_wheelRotation = -120;
+            break;
+
+        default:
+            return false;  // Unknown/unhandled direction
+    }
+
+    // And the scroll axis.
+    switch (gdk_event->direction)
+    {
+        case GDK_SCROLL_UP:
+        case GDK_SCROLL_DOWN:
+            event.m_wheelAxis = wxMOUSE_WHEEL_VERTICAL;
+            break;
+
+        case GDK_SCROLL_LEFT:
+        case GDK_SCROLL_RIGHT:
+            event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL;
+            break;
+    }
  
      if (win->GTKProcessEvent(event))
        return TRUE;
  
      GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
  
      if (win->GTKProcessEvent(event))
        return TRUE;
  
      GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
-    if (!range) return FALSE;
  
      if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
      {
  
      if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
      {
-        GtkAdjustment *adj = range->adjustment;
-        gdouble delta = adj->step_increment * 3;
+        GtkAdjustment* adj = gtk_range_get_adjustment(range);
+        double delta = gtk_adjustment_get_step_increment(adj) * 3;
          if (gdk_event->direction == GDK_SCROLL_UP)
          if (gdk_event->direction == GDK_SCROLL_UP)
-          delta = -delta;
-
-        gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
+            delta = -delta;
  
  
-        gtk_adjustment_set_value (adj, new_value);
+        gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
  
          return TRUE;
      }
  
          return TRUE;
      }
@@ -1753,7 +1740,7 @@ gtk_window_enter_callback( GtkWidget *widget,
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
  
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
  
-    gdk_window_get_pointer( widget->window, &x, &y, &state );
+    gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
  
      wxMouseEvent event( wxEVT_ENTER_WINDOW );
      InitMouseEvent(win, event, gdk_event);
  
      wxMouseEvent event( wxEVT_ENTER_WINDOW );
      InitMouseEvent(win, event, gdk_event);
@@ -1793,7 +1780,7 @@ gtk_window_leave_callback( GtkWidget *widget,
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
  
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
  
-    gdk_window_get_pointer( widget->window, &x, &y, &state );
+    gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
  
      InitMouseEvent(win, event, gdk_event);
  
  
      InitMouseEvent(win, event, gdk_event);
  
@@ -1885,29 +1872,9 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w
  //-----------------------------------------------------------------------------
  
  static void
  //-----------------------------------------------------------------------------
  
  static void
-gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
+gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win)
  {
  {
-    if (win->m_imData)
-    {
-        gtk_im_context_set_client_window( win->m_imData->context,
-            win->m_wxwindow ? win->GTKGetDrawingWindow() : widget->window);
-    }
-
-    // We cannot set colours and fonts before the widget
-    // been realized, so we do this directly after realization
-    // or otherwise in idle time
-
-    if (win->m_needsStyleChange)
-    {
-        win->SetBackgroundStyle(win->GetBackgroundStyle());
-        win->m_needsStyleChange = false;
-    }
-
-    wxWindowCreateEvent event( win );
-    event.SetEventObject( win );
-    win->GTKProcessEvent( event );
-
-    win->GTKUpdateCursor(true, false);
+    win->GTKHandleRealized();
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
@@ -1921,10 +1888,10 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
      int h = alloc->height;
      if (win->m_wxwindow)
      {
      int h = alloc->height;
      if (win->m_wxwindow)
      {
-        int border_x, border_y;
-        WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
-        w -= 2 * border_x;
-        h -= 2 * border_y;
+        GtkBorder border;
+        WX_PIZZA(win->m_wxwindow)->get_border(border);
+        w -= border.left + border.right;
+        h -= border.top + border.bottom;
          if (w < 0) w = 0;
          if (h < 0) h = 0;
      }
          if (w < 0) w = 0;
          if (h < 0) h = 0;
      }
@@ -1934,8 +1901,10 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
          win->m_oldClientHeight = h;
          // this callback can be connected to m_wxwindow,
          // so always get size from m_widget->allocation
          win->m_oldClientHeight = h;
          // this callback can be connected to m_wxwindow,
          // so always get size from m_widget->allocation
-        win->m_width  = win->m_widget->allocation.width;
-        win->m_height = win->m_widget->allocation.height;
+        GtkAllocation a;
+        gtk_widget_get_allocation(win->m_widget, &a);
+        win->m_width  = a.width;
+        win->m_height = a.height;
          if (!win->m_nativeSizeEvent)
          {
              wxSizeEvent event(win->GetSize(), win->GetId());
          if (!win->m_nativeSizeEvent)
          {
              wxSizeEvent event(win->GetSize(), win->GetId());
@@ -1958,34 +1927,117 @@ gtk_window_grab_broken( GtkWidget*,
      // Mouse capture has been lost involuntarily, notify the application
      if(!event->keyboard && wxWindow::GetCapture() == win)
      {
      // Mouse capture has been lost involuntarily, notify the application
      if(!event->keyboard && wxWindow::GetCapture() == win)
      {
-        wxMouseCaptureLostEvent evt( win->GetId() );
-        evt.SetEventObject( win );
-        win->HandleWindowEvent( evt );
+        wxMouseCaptureLostEvent evt( win->GetId() );
+        evt.SetEventObject( win );
+        win->HandleWindowEvent( evt );
+    }
+    return false;
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// "style_set"/"style_updated"
+//-----------------------------------------------------------------------------
+
+#ifdef __WXGTK3__
+static void style_updated(GtkWidget*, wxWindow* win)
+#else
+static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win)
+#endif
+{
+    if (win->IsTopLevel())
+    {
+        wxSysColourChangedEvent event;
+        event.SetEventObject(win);
+        win->GTKProcessEvent(event);
+    }
+    else
+    {
+        // Border width could change, which will change client size.
+        // Make sure size event occurs for this
+        win->m_oldClientWidth = 0;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// "unrealize" from m_wxwindow
+//-----------------------------------------------------------------------------
+
+static void unrealize(GtkWidget*, wxWindow* win)
+{
+    if (win->m_imData)
+        gtk_im_context_set_client_window(win->m_imData->context, NULL);
+
+    g_signal_handlers_disconnect_by_func(
+        win->m_wxwindow, (void*)style_updated, win);
+}
+
+} // extern "C"
+
+void wxWindowGTK::GTKHandleRealized()
+{
+    if (m_imData)
+    {
+        gtk_im_context_set_client_window
+        (
+            m_imData->context,
+            m_wxwindow ? GTKGetDrawingWindow()
+                       : gtk_widget_get_window(m_widget)
+        );
+    }
+
+    // Use composited window if background is transparent, if supported.
+    if (m_backgroundStyle == wxBG_STYLE_TRANSPARENT)
+    {
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+        if (IsTransparentBackgroundSupported())
+        {
+            GdkWindow* const window = GTKGetDrawingWindow();
+            if (window)
+                gdk_window_set_composited(window, true);
+        }
+        else
+#endif // wxGTK_HAS_COMPOSITING_SUPPORT
+        {
+            // We revert to erase mode if transparency is not supported
+            m_backgroundStyle = wxBG_STYLE_ERASE;
+        }
+    }
+
+
+    // We cannot set colours and fonts before the widget
+    // been realized, so we do this directly after realization
+    // or otherwise in idle time
+
+    if (m_needsStyleChange)
+    {
+        SetBackgroundStyle(GetBackgroundStyle());
+        m_needsStyleChange = false;
      }
      }
-    return false;
-}
-#endif
  
  
-//-----------------------------------------------------------------------------
-// "style_set"
-//-----------------------------------------------------------------------------
+    wxWindowCreateEvent event(static_cast<wxWindow*>(this));
+    event.SetEventObject( this );
+    GTKProcessEvent( event );
  
  
-static
-void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
-                               GtkStyle *previous_style,
-                               wxWindow* win )
-{
-    if (win && previous_style)
-    {
-        wxSysColourChangedEvent event;
-        event.SetEventObject(win);
+    GTKUpdateCursor(true, false);
  
  
-        win->GTKProcessEvent( event );
+    if (m_wxwindow &&
+        (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)))
+    {
+        // attaching to style changed signal after realization avoids initial
+        // changes we don't care about
+        const gchar *detailed_signal =
+#ifdef __WXGTK3__
+            "style_updated";
+#else
+            "style_set";
+#endif
+        g_signal_connect(m_wxwindow,
+            detailed_signal,
+            G_CALLBACK(style_updated), this);
      }
  }
  
      }
  }
  
-} // extern "C"
-
  // ----------------------------------------------------------------------------
  // this wxWindowBase function is implemented here (in platform-specific file)
  // because it is static and so couldn't be made virtual
  // ----------------------------------------------------------------------------
  // this wxWindowBase function is implemented here (in platform-specific file)
  // because it is static and so couldn't be made virtual
@@ -1993,6 +2045,13 @@ void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
  
  wxWindow *wxWindowBase::DoFindFocus()
  {
  
  wxWindow *wxWindowBase::DoFindFocus()
  {
+    // For compatibility with wxMSW, pretend that showing a popup menu doesn't
+    // change the focus and that it remains on the window showing it, even
+    // though the real focus does change in GTK.
+    extern wxMenu *wxCurrentPopupMenu;
+    if ( wxCurrentPopupMenu )
+        return wxCurrentPopupMenu->GetInvokingWindow();
+
      wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
      // the cast is necessary when we compile in wxUniversal mode
      return static_cast<wxWindow*>(focus);
      wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
      // the cast is necessary when we compile in wxUniversal mode
      return static_cast<wxWindow*>(focus);
@@ -2008,9 +2067,8 @@ void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
      child->m_x += pizza->m_scroll_x;
      child->m_y += pizza->m_scroll_y;
  
      child->m_x += pizza->m_scroll_x;
      child->m_y += pizza->m_scroll_y;
  
-    gtk_widget_set_size_request(
-        child->m_widget, child->m_width, child->m_height);
-    pizza->put(child->m_widget, child->m_x, child->m_y);
+    pizza->put(child->m_widget,
+        child->m_x, child->m_y, child->m_width, child->m_height);
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
@@ -2023,6 +2081,29 @@ wxWindow *wxGetActiveWindow()
  }
  
  
  }
  
  
+// Under Unix this is implemented using X11 functions in utilsx11.cpp but we
+// need to have this function under Windows too, so provide at least a stub.
+#ifndef GDK_WINDOWING_X11
+bool wxGetKeyState(wxKeyCode WXUNUSED(key))
+{
+    wxFAIL_MSG(wxS("Not implemented under Windows"));
+    return false;
+}
+#endif // __WINDOWS__
+
+static void GetMouseState(int& x, int& y, GdkModifierType& mask)
+{
+    wxWindow* tlw = NULL;
+    if (!wxTopLevelWindows.empty())
+        tlw = wxTopLevelWindows.front();
+    GdkDisplay* display;
+    if (tlw && tlw->m_widget)
+        display = gtk_widget_get_display(tlw->m_widget);
+    else
+        display = gdk_display_get_default();
+    gdk_display_get_pointer(display, NULL, &x, &y, &mask);
+}
+
  wxMouseState wxGetMouseState()
  {
      wxMouseState ms;
  wxMouseState wxGetMouseState()
  {
      wxMouseState ms;
@@ -2031,13 +2112,14 @@ wxMouseState wxGetMouseState()
      gint y;
      GdkModifierType mask;
  
      gint y;
      GdkModifierType mask;
  
-    gdk_window_get_pointer(NULL, &x, &y, &mask);
+    GetMouseState(x, y, mask);
  
      ms.SetX(x);
      ms.SetY(y);
      ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
      ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
      ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
  
      ms.SetX(x);
      ms.SetY(y);
      ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
      ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
      ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
+    // see the comment in InitMouseEvent()
      ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
      ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
  
      ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
      ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
  
@@ -2078,6 +2160,9 @@ void wxWindowGTK::Init()
  
      m_noExpose = false;
      m_nativeSizeEvent = false;
  
      m_noExpose = false;
      m_nativeSizeEvent = false;
+#ifdef __WXGTK3__
+    m_paintContext = NULL;
+#endif
  
      m_isScrolling = false;
      m_mouseButtonDown = false;
  
      m_isScrolling = false;
      m_mouseButtonDown = false;
@@ -2182,17 +2267,14 @@ bool wxWindowGTK::Create( wxWindow *parent,
          if (HasFlag(wxALWAYS_SHOW_SB))
          {
              gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
          if (HasFlag(wxALWAYS_SHOW_SB))
          {
              gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
-
-            scrolledWindow->hscrollbar_visible = TRUE;
-            scrolledWindow->vscrollbar_visible = TRUE;
          }
          else
          {
              gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
          }
  
          }
          else
          {
              gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
          }
  
-        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
-        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
+        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
          if (GetLayoutDirection() == wxLayout_RightToLeft)
              gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
  
          if (GetLayoutDirection() == wxLayout_RightToLeft)
              gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
  
@@ -2268,6 +2350,7 @@ wxWindowGTK::~wxWindowGTK()
  
      // delete before the widgets to avoid a crash on solaris
      delete m_imData;
  
      // delete before the widgets to avoid a crash on solaris
      delete m_imData;
+    m_imData = NULL;
  
      // avoid problem with GTK+ 2.18 where a frozen window causes the whole
      // TLW to be frozen, and if the window is then destroyed, nothing ever
  
      // avoid problem with GTK+ 2.18 where a frozen window causes the whole
      // TLW to be frozen, and if the window is then destroyed, nothing ever
@@ -2300,8 +2383,11 @@ bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const w
      m_width = WidthDefault(size.x) ;
      m_height = HeightDefault(size.y);
  
      m_width = WidthDefault(size.x) ;
      m_height = HeightDefault(size.y);
  
-    m_x = (int)pos.x;
-    m_y = (int)pos.y;
+    if (pos != wxDefaultPosition)
+    {
+        m_x = pos.x;
+        m_y = pos.y;
+    }
  
      return true;
  }
  
      return true;
  }
@@ -2310,14 +2396,34 @@ void wxWindowGTK::PostCreation()
  {
      wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
  
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+    // Set RGBA visual as soon as possible to minimize the possibility that
+    // somebody uses the wrong one.
+    if ( m_backgroundStyle == wxBG_STYLE_TRANSPARENT &&
+            IsTransparentBackgroundSupported() )
+    {
+        GdkScreen *screen = gtk_widget_get_screen (m_widget);
+#ifdef __WXGTK3__
+        gtk_widget_set_visual(m_widget, gdk_screen_get_rgba_visual(screen));
+#else
+        GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen);
+
+        if (rgba_colormap)
+            gtk_widget_set_colormap(m_widget, rgba_colormap);
+#endif
+    }
+#endif // wxGTK_HAS_COMPOSITING_SUPPORT
+
      if (m_wxwindow)
      {
          if (!m_noExpose)
          {
              // these get reported to wxWidgets -> wxPaintEvent
      if (m_wxwindow)
      {
          if (!m_noExpose)
          {
              // these get reported to wxWidgets -> wxPaintEvent
-
-            g_signal_connect (m_wxwindow, "expose_event",
-                              G_CALLBACK (gtk_window_expose_callback), this);
+#ifdef __WXGTK3__
+            g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this);
+#else
+            g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(expose_event), this);
+#endif
  
              if (GetLayoutDirection() == wxLayout_LeftToRight)
                  gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
  
              if (GetLayoutDirection() == wxLayout_LeftToRight)
                  gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
@@ -2331,6 +2437,7 @@ void wxWindowGTK::PostCreation()
  
          g_signal_connect (m_imData->context, "commit",
                            G_CALLBACK (gtk_wxwindow_commit_cb), this);
  
          g_signal_connect (m_imData->context, "commit",
                            G_CALLBACK (gtk_wxwindow_commit_cb), this);
+        g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this);
      }
  
      // focus handling
      }
  
      // focus handling
@@ -2370,10 +2477,18 @@ void wxWindowGTK::PostCreation()
  
      ConnectWidget( connect_widget );
  
  
      ConnectWidget( connect_widget );
  
-    /* We cannot set colours, fonts and cursors before the widget has
-       been realized, so we do this directly after realization */
-    g_signal_connect (connect_widget, "realize",
-                      G_CALLBACK (gtk_window_realized_callback), this);
+    // We cannot set colours, fonts and cursors before the widget has been
+    // realized, so we do this directly after realization -- unless the widget
+    // was in fact realized already.
+    if ( gtk_widget_get_realized(connect_widget) )
+    {
+        gtk_window_realized_callback(connect_widget, this);
+    }
+    else
+    {
+        g_signal_connect (connect_widget, "realize",
+                          G_CALLBACK (gtk_window_realized_callback), this);
+    }
  
      if (!IsTopLevel())
      {
  
      if (!IsTopLevel())
      {
@@ -2382,7 +2497,9 @@ void wxWindowGTK::PostCreation()
      }
  
  #if GTK_CHECK_VERSION(2, 8, 0)
      }
  
  #if GTK_CHECK_VERSION(2, 8, 0)
+#ifndef __WXGTK3__
      if ( gtk_check_version(2,8,0) == NULL )
      if ( gtk_check_version(2,8,0) == NULL )
+#endif
      {
          // Make sure we can notify the app when mouse capture is lost
          if ( m_wxwindow )
      {
          // Make sure we can notify the app when mouse capture is lost
          if ( m_wxwindow )
@@ -2399,16 +2516,8 @@ void wxWindowGTK::PostCreation()
      }
  #endif // GTK+ >= 2.8
  
      }
  #endif // GTK+ >= 2.8
  
-    if ( GTKShouldConnectSizeRequest() )
-    {
-        // This is needed if we want to add our windows into native
-        // GTK controls, such as the toolbar. With this callback, the
-        // toolbar gets to know the correct size (the one set by the
-        // programmer). Sadly, it misbehaves for wxComboBox.
-        g_signal_connect (m_widget, "size_request",
-                          G_CALLBACK (wxgtk_window_size_request_callback),
-                          this);
-    }
+    if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
+        gtk_widget_set_size_request(m_widget, m_width, m_height);
  
      InheritAttributes();
  
  
      InheritAttributes();
  
@@ -2422,7 +2531,8 @@ void wxWindowGTK::PostCreation()
          gtk_widget_show( m_widget );
  }
  
          gtk_widget_show( m_widget );
  }
  
-gulong wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)())
+unsigned long
+wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback)
  {
      return g_signal_connect(m_widget, signal, callback, this);
  }
  {
      return g_signal_connect(m_widget, signal, callback, this);
  }
@@ -2455,29 +2565,55 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
                        G_CALLBACK (gtk_window_enter_callback), this);
      g_signal_connect (widget, "leave_notify_event",
                        G_CALLBACK (gtk_window_leave_callback), this);
                        G_CALLBACK (gtk_window_enter_callback), this);
      g_signal_connect (widget, "leave_notify_event",
                        G_CALLBACK (gtk_window_leave_callback), this);
-
-    if (IsTopLevel() && m_wxwindow)
-        g_signal_connect (m_wxwindow, "style_set",
-                              G_CALLBACK (gtk_window_style_set_callback), this);
  }
  
  bool wxWindowGTK::Destroy()
  {
  }
  
  bool wxWindowGTK::Destroy()
  {
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
-
      m_hasVMT = false;
  
      return wxWindowBase::Destroy();
  }
  
      m_hasVMT = false;
  
      return wxWindowBase::Destroy();
  }
  
+static GSList* gs_queueResizeList;
+
+extern "C" {
+static gboolean queue_resize(void*)
+{
+    gdk_threads_enter();
+    for (GSList* p = gs_queueResizeList; p; p = p->next)
+    {
+        if (p->data)
+        {
+            gtk_widget_queue_resize(GTK_WIDGET(p->data));
+            g_object_remove_weak_pointer(G_OBJECT(p->data), &p->data);
+        }
+    }
+    g_slist_free(gs_queueResizeList);
+    gs_queueResizeList = NULL;
+    gdk_threads_leave();
+    return false;
+}
+}
+
  void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
  {
      gtk_widget_set_size_request(m_widget, width, height);
  void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
  {
      gtk_widget_set_size_request(m_widget, width, height);
+    GtkWidget* parent = gtk_widget_get_parent(m_widget);
+    if (WX_IS_PIZZA(parent))
+        WX_PIZZA(parent)->move(m_widget, x, y, width, height);
  
  
-    // inform the parent to perform the move
-    wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
-                 "the parent window has no client area?");
-    WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
+    // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
+    // is in progress. This situation is common in wxWidgets, since
+    // size-allocate can generate wxSizeEvent and size event handlers often
+    // call SetSize(), directly or indirectly. Work around this by deferring
+    // the queue-resize until after size-allocate processing is finished.
+    if (g_slist_find(gs_queueResizeList, m_widget) == NULL)
+    {
+        if (gs_queueResizeList == NULL)
+            g_idle_add_full(GTK_PRIORITY_RESIZE, queue_resize, NULL, NULL);
+        gs_queueResizeList = g_slist_prepend(gs_queueResizeList, m_widget);
+        g_object_add_weak_pointer(G_OBJECT(m_widget), &gs_queueResizeList->data);
+    }
  }
  
  void wxWindowGTK::ConstrainSize()
  }
  
  void wxWindowGTK::ConstrainSize()
@@ -2499,16 +2635,24 @@ void wxWindowGTK::ConstrainSize()
  
  void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
  {
  
  void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
  {
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
-    wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
+    wxCHECK_RET(m_widget, "invalid window");
  
  
-    int currentX, currentY;
-    GetPosition(&currentX, &currentY);
-    if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-        x = currentX;
-    if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
-        y = currentY;
-    AdjustForParentClientOrigin(x, y, sizeFlags);
+    int scrollX = 0, scrollY = 0;
+    GtkWidget* parent = gtk_widget_get_parent(m_widget);
+    if (WX_IS_PIZZA(parent))
+    {
+        wxPizza* pizza = WX_PIZZA(parent);
+        scrollX = pizza->m_scroll_x;
+        scrollY = pizza->m_scroll_y;
+    }
+    if (x != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+        x += scrollX;
+    else
+        x = m_x;
+    if (y != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+        y += scrollY;
+    else
+        y = m_y;
  
      // calculate the best size if we should auto size the window
      if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
  
      // calculate the best size if we should auto size the window
      if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
@@ -2521,22 +2665,18 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
              height = sizeBest.y;
      }
  
              height = sizeBest.y;
      }
  
-    const wxSize oldSize(m_width, m_height);
-    if (width != -1)
-        m_width = width;
-    if (height != -1)
-        m_height = height;
+    if (width == -1)
+        width = m_width;
+    if (height == -1)
+        height = m_height;
  
  
-    if (m_parent->m_wxwindow)
+    const bool sizeChange = m_width != width || m_height != height;
+    if (sizeChange || m_x != x || m_y != y)
      {
      {
-        wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
-        m_x = x + pizza->m_scroll_x;
-        m_y = y + pizza->m_scroll_y;
-
-        int left_border = 0;
-        int right_border = 0;
-        int top_border = 0;
-        int bottom_border = 0;
+        m_x = x;
+        m_y = y;
+        m_width = width;
+        m_height = height;
  
          /* the default button has a border around it */
          if (gtk_widget_get_can_default(m_widget))
  
          /* the default button has a border around it */
          if (gtk_widget_get_can_default(m_widget))
@@ -2545,36 +2685,23 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
              gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
              if (default_border)
              {
              gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
              if (default_border)
              {
-                left_border += default_border->left;
-                right_border += default_border->right;
-                top_border += default_border->top;
-                bottom_border += default_border->bottom;
+                x -= default_border->left;
+                y -= default_border->top;
+                width += default_border->left + default_border->right;
+                height += default_border->top + default_border->bottom;
                  gtk_border_free( default_border );
              }
          }
  
                  gtk_border_free( default_border );
              }
          }
  
-        DoMoveWindow( m_x - left_border,
-                      m_y - top_border,
-                      m_width+left_border+right_border,
-                      m_height+top_border+bottom_border );
+        DoMoveWindow(x, y, width, height);
      }
  
      }
  
-    if (m_width != oldSize.x || m_height != oldSize.y)
+    if ((sizeChange && !m_nativeSizeEvent) || (sizeFlags & wxSIZE_FORCE_EVENT))
      {
          // update these variables to keep size_allocate handler
          // from sending another size event for this change
          GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
  
      {
          // update these variables to keep size_allocate handler
          // from sending another size event for this change
          GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
  
-        gtk_widget_queue_resize(m_widget);
-        if (!m_nativeSizeEvent)
-        {
-            wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-            event.SetEventObject( this );
-            HandleWindowEvent( event );
-        }
-    } else
-    if (sizeFlags & wxSIZE_FORCE_EVENT)
-    {
          wxSizeEvent event( wxSize(m_width,m_height), GetId() );
          event.SetEventObject( this );
          HandleWindowEvent( event );
          wxSizeEvent event( wxSize(m_width,m_height), GetId() );
          event.SetEventObject( this );
          HandleWindowEvent( event );
@@ -2616,21 +2743,11 @@ void wxWindowGTK::OnInternalIdle()
          RealizeTabOrder();
      }
  
          RealizeTabOrder();
      }
  
-    // Update style if the window was not yet realized when
-    // SetBackgroundStyle() was called
-    if (m_needsStyleChange)
-    {
-        SetBackgroundStyle(GetBackgroundStyle());
-        m_needsStyleChange = false;
-    }
-
      wxWindowBase::OnInternalIdle();
  }
  
  void wxWindowGTK::DoGetSize( int *width, int *height ) const
  {
      wxWindowBase::OnInternalIdle();
  }
  
  void wxWindowGTK::DoGetSize( int *width, int *height ) const
  {
-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
-
      if (width) (*width) = m_width;
      if (height) (*height) = m_height;
  }
      if (width) (*width) = m_width;
      if (height) (*height) = m_height;
  }
@@ -2660,6 +2777,8 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
              gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
                                             &policy[ScrollDir_Horz],
                                             &policy[ScrollDir_Vert]);
              gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
                                             &policy[ScrollDir_Horz],
                                             &policy[ScrollDir_Vert]);
+            const int scrollbar_spacing =
+                GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing;
  
              for ( int i = 0; i < ScrollDir_Max; i++ )
              {
  
              for ( int i = 0; i < ScrollDir_Max; i++ )
              {
@@ -2682,19 +2801,36 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
                      case GTK_POLICY_AUTOMATIC:
                          // may be shown or not, check
                          GtkAdjustment *adj = gtk_range_get_adjustment(range);
                      case GTK_POLICY_AUTOMATIC:
                          // may be shown or not, check
                          GtkAdjustment *adj = gtk_range_get_adjustment(range);
-                        if ( adj->upper <= adj->page_size )
+                        if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
                              continue;
                  }
  
                              continue;
                  }
  
-                GtkScrolledWindowClass *scroll_class =
-                    GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-
                  GtkRequisition req;
                  GtkRequisition req;
+#ifdef __WXGTK3__
+                GtkWidget* widget = GTK_WIDGET(range);
+                if (i == ScrollDir_Horz)
+                {
+                    if (height)
+                    {
+                        gtk_widget_get_preferred_height(widget, NULL, &req.height);
+                        h -= req.height + scrollbar_spacing;
+                    }
+                }
+                else
+                {
+                    if (width)
+                    {
+                        gtk_widget_get_preferred_width(widget, NULL, &req.width);
+                        w -= req.width + scrollbar_spacing;
+                    }
+                }
+#else // !__WXGTK3__
                  gtk_widget_size_request(GTK_WIDGET(range), &req);
                  if (i == ScrollDir_Horz)
                  gtk_widget_size_request(GTK_WIDGET(range), &req);
                  if (i == ScrollDir_Horz)
-                    h -= req.height + scroll_class->scrollbar_spacing;
+                    h -= req.height + scrollbar_spacing;
                  else
                  else
-                    w -= req.width + scroll_class->scrollbar_spacing;
+                    w -= req.width + scrollbar_spacing;
+#endif // !__WXGTK3__
              }
          }
  
              }
          }
  
@@ -2717,47 +2853,24 @@ wxSize wxWindowGTK::DoGetBorderSize() const
      if ( !m_wxwindow )
          return wxWindowBase::DoGetBorderSize();
  
      if ( !m_wxwindow )
          return wxWindowBase::DoGetBorderSize();
  
-    int x, y;
-    WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
-
-    return 2*wxSize(x, y);
+    GtkBorder border;
+    WX_PIZZA(m_wxwindow)->get_border(border);
+    return wxSize(border.left + border.right, border.top + border.bottom);
  }
  
  void wxWindowGTK::DoGetPosition( int *x, int *y ) const
  {
  }
  
  void wxWindowGTK::DoGetPosition( int *x, int *y ) const
  {
-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
-
      int dx = 0;
      int dy = 0;
      int dx = 0;
      int dy = 0;
-    if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
+    GtkWidget* parent = NULL;
+    if (m_widget)
+        parent = gtk_widget_get_parent(m_widget);
+    if (WX_IS_PIZZA(parent))
      {
      {
-        wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
+        wxPizza* pizza = WX_PIZZA(parent);
          dx = pizza->m_scroll_x;
          dy = pizza->m_scroll_y;
      }
          dx = pizza->m_scroll_x;
          dy = pizza->m_scroll_y;
      }
-
-    if (m_x == -1 && m_y == -1)
-    {
-        GdkWindow *source = NULL;
-        if (m_wxwindow)
-            source = m_wxwindow->window;
-        else
-            source = m_widget->window;
-
-        if (source)
-        {
-            int org_x = 0;
-            int org_y = 0;
-            gdk_window_get_origin( source, &org_x, &org_y );
-
-            if (m_parent)
-                m_parent->ScreenToClient(&org_x, &org_y);
-
-            const_cast<wxWindowGTK*>(this)->m_x = org_x;
-            const_cast<wxWindowGTK*>(this)->m_y = org_y;
-        }
-    }
-
      if (x) (*x) = m_x - dx;
      if (y) (*y) = m_y - dy;
  }
      if (x) (*x) = m_x - dx;
      if (y) (*y) = m_y - dy;
  }
@@ -2766,13 +2879,13 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (!m_widget->window) return;
+    if (gtk_widget_get_window(m_widget) == NULL) return;
  
      GdkWindow *source = NULL;
      if (m_wxwindow)
  
      GdkWindow *source = NULL;
      if (m_wxwindow)
-        source = m_wxwindow->window;
+        source = gtk_widget_get_window(m_wxwindow);
      else
      else
-        source = m_widget->window;
+        source = gtk_widget_get_window(m_widget);
  
      int org_x = 0;
      int org_y = 0;
  
      int org_x = 0;
      int org_y = 0;
@@ -2782,8 +2895,10 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
      {
          if (!gtk_widget_get_has_window(m_widget))
          {
      {
          if (!gtk_widget_get_has_window(m_widget))
          {
-            org_x += m_widget->allocation.x;
-            org_y += m_widget->allocation.y;
+            GtkAllocation a;
+            gtk_widget_get_allocation(m_widget, &a);
+            org_x += a.x;
+            org_y += a.y;
          }
      }
  
          }
      }
  
@@ -2803,13 +2918,13 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (!m_widget->window) return;
+    if (!gtk_widget_get_realized(m_widget)) return;
  
      GdkWindow *source = NULL;
      if (m_wxwindow)
  
      GdkWindow *source = NULL;
      if (m_wxwindow)
-        source = m_wxwindow->window;
+        source = gtk_widget_get_window(m_wxwindow);
      else
      else
-        source = m_widget->window;
+        source = gtk_widget_get_window(m_widget);
  
      int org_x = 0;
      int org_y = 0;
  
      int org_x = 0;
      int org_y = 0;
@@ -2819,8 +2934,10 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
      {
          if (!gtk_widget_get_has_window(m_widget))
          {
      {
          if (!gtk_widget_get_has_window(m_widget))
          {
-            org_x += m_widget->allocation.x;
-            org_y += m_widget->allocation.y;
+            GtkAllocation a;
+            gtk_widget_get_allocation(m_widget, &a);
+            org_x += a.x;
+            org_y += a.y;
          }
      }
  
          }
      }
  
@@ -2887,7 +3004,7 @@ int wxWindowGTK::GetCharHeight() const
      wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
  
      wxFont font = GetFont();
      wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
  
      wxFont font = GetFont();
-    wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
+    wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
  
      PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
  
      PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
@@ -2913,7 +3030,7 @@ int wxWindowGTK::GetCharWidth() const
      wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
  
      wxFont font = GetFont();
      wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
  
      wxFont font = GetFont();
-    wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
+    wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
  
      PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
  
      PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
@@ -2943,7 +3060,7 @@ void wxWindowGTK::DoGetTextExtent( const wxString& string,
  {
      wxFont fontToUse = theFont ? *theFont : GetFont();
  
  {
      wxFont fontToUse = theFont ? *theFont : GetFont();
  
-    wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
+    wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
  
      if (string.empty())
      {
  
      if (string.empty())
      {
@@ -3131,6 +3248,7 @@ void wxWindowGTK::GTKHandleFocusOutNoDeferring()
  
      wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
      event.SetEventObject( this );
  
      wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
      event.SetEventObject( this );
+    event.SetWindow( FindFocus() );
      GTKProcessEvent( event );
  }
  
      GTKProcessEvent( event );
  }
  
@@ -3204,8 +3322,7 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
  {
      wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
  
  {
      wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
  
-    wxWindowGTK *oldParent = m_parent,
-             *newParent = (wxWindowGTK *)newParentBase;
+    wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
@@ -3214,8 +3331,11 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
-    if (oldParent)
-        gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
+    // Notice that old m_parent pointer might be non-NULL here but the widget
+    // still not have any parent at GTK level if it's a notebook page that had
+    // been removed from the notebook so test this at GTK level and not wx one.
+    if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
+        gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
  
      wxASSERT( GTK_IS_WIDGET(m_widget) );
  
@@ -3345,7 +3465,7 @@ bool wxWindowGTK::DoNavigateIn(int flags)
          gboolean rc;
          g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
  
          gboolean rc;
          g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
  
-        return rc == TRUE;
+        return rc != 0;
      }
  }
  
      }
  }
  
@@ -3379,9 +3499,11 @@ void wxWindowGTK::RealizeTabOrder()
              {
                  wxWindowGTK *win = *i;
  
              {
                  wxWindowGTK *win = *i;
  
+                bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
+
                  if ( mnemonicWindow )
                  {
                  if ( mnemonicWindow )
                  {
-                    if ( win->AcceptsFocusFromKeyboard() )
+                    if ( focusableFromKeyboard )
                      {
                          // wxComboBox et al. needs to focus on on a different
                          // widget than m_widget, so if the main widget isn't
                      {
                          // wxComboBox et al. needs to focus on on a different
                          // widget than m_widget, so if the main widget isn't
@@ -3406,7 +3528,8 @@ void wxWindowGTK::RealizeTabOrder()
                      mnemonicWindow = win;
                  }
  
                      mnemonicWindow = win;
                  }
  
-                chain = g_list_prepend(chain, win->m_widget);
+                if ( focusableFromKeyboard )
+                    chain = g_list_prepend(chain, win->m_widget);
              }
  
              chain = g_list_reverse(chain);
              }
  
              chain = g_list_reverse(chain);
@@ -3425,13 +3548,13 @@ void wxWindowGTK::Raise()
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (m_wxwindow && m_wxwindow->window)
+    if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
      {
      {
-        gdk_window_raise( m_wxwindow->window );
+        gdk_window_raise(gtk_widget_get_window(m_wxwindow));
      }
      }
-    else if (m_widget->window)
+    else if (gtk_widget_get_window(m_widget))
      {
      {
-        gdk_window_raise( m_widget->window );
+        gdk_window_raise(gtk_widget_get_window(m_widget));
      }
  }
  
      }
  }
  
@@ -3439,19 +3562,19 @@ void wxWindowGTK::Lower()
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (m_wxwindow && m_wxwindow->window)
+    if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
      {
      {
-        gdk_window_lower( m_wxwindow->window );
+        gdk_window_lower(gtk_widget_get_window(m_wxwindow));
      }
      }
-    else if (m_widget->window)
+    else if (gtk_widget_get_window(m_widget))
      {
      {
-        gdk_window_lower( m_widget->window );
+        gdk_window_lower(gtk_widget_get_window(m_widget));
      }
  }
  
  bool wxWindowGTK::SetCursor( const wxCursor &cursor )
  {
      }
  }
  
  bool wxWindowGTK::SetCursor( const wxCursor &cursor )
  {
-    if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
+    if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
          return false;
  
      GTKUpdateCursor();
          return false;
  
      GTKUpdateCursor();
@@ -3463,8 +3586,8 @@ void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=tr
  {
      if (update_self)
      {
  {
      if (update_self)
      {
-        wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
-        if ( cursor.Ok() )
+        wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
+        if ( cursor.IsOk() )
          {
              wxArrayGdkWindows windowsThis;
              GdkWindow* window = GTKGetWindow(windowsThis);
          {
              wxArrayGdkWindows windowsThis;
              GdkWindow* window = GTKGetWindow(windowsThis);
@@ -3499,17 +3622,20 @@ void wxWindowGTK::WarpPointer( int x, int y )
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    // We provide this function ourselves as it is
-    // missing in GDK (top of this file).
-
-    GdkWindow *window = NULL;
-    if (m_wxwindow)
-        window = m_wxwindow->window;
-    else
-        window = GetConnectWidget()->window;
-
-    if (window)
-        gdk_window_warp_pointer( window, x, y );
+    ClientToScreen(&x, &y);
+    GdkDisplay* display = gtk_widget_get_display(m_widget);
+    GdkScreen* screen = gtk_widget_get_screen(m_widget);
+#ifdef __WXGTK3__
+    GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+    gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
+#else
+#ifdef GDK_WINDOWING_X11
+    XWarpPointer(GDK_DISPLAY_XDISPLAY(display),
+        None,
+        GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
+        0, 0, 0, 0, x, y);
+#endif
+#endif
  }
  
  wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
  }
  
  wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
@@ -3532,14 +3658,14 @@ bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
      GtkRange* range = m_scrollBar[dir];
      if ( range && units )
      {
      GtkRange* range = m_scrollBar[dir];
      if ( range && units )
      {
-        GtkAdjustment* adj = range->adjustment;
-        gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
-                                              : adj->page_increment;
+        GtkAdjustment* adj = gtk_range_get_adjustment(range);
+        double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
+                                             : gtk_adjustment_get_page_increment(adj);
  
  
-        const int posOld = int(adj->value + 0.5);
+        const int posOld = wxRound(gtk_adjustment_get_value(adj));
          gtk_range_set_value(range, posOld + units*inc);
  
          gtk_range_set_value(range, posOld + units*inc);
  
-        changed = int(adj->value + 0.5) != posOld;
+        changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
      }
  
      return changed;
      }
  
      return changed;
@@ -3558,43 +3684,31 @@ bool wxWindowGTK::ScrollPages(int pages)
  void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
                            const wxRect *rect)
  {
  void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
                            const wxRect *rect)
  {
-    if ( !m_widget )
-    {
-        // it is valid to call Refresh() for a window which hasn't been created
-        // yet, it simply doesn't do anything in this case
-        return;
-    }
-
-    if (!m_wxwindow)
+    if (m_wxwindow)
      {
      {
-        if (rect)
-            gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
-        else
-            gtk_widget_queue_draw( m_widget );
+        if (gtk_widget_get_mapped(m_wxwindow))
+        {
+            GdkWindow* window = gtk_widget_get_window(m_wxwindow);
+            if (rect)
+            {
+                GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
+                if (GetLayoutDirection() == wxLayout_RightToLeft)
+                    r.x = gdk_window_get_width(window) - r.x - rect->width;
+                gdk_window_invalidate_rect(window, &r, true);
+            }
+            else
+                gdk_window_invalidate_rect(window, NULL, true);
+        }
      }
      }
-    else
+    else if (m_widget)
      {
      {
-        // Just return if the widget or one of its ancestors isn't mapped
-        GtkWidget *w;
-        for (w = m_wxwindow; w != NULL; w = w->parent)
-            if (!gtk_widget_get_mapped (w))
-                return;
-
-        GdkWindow* window = GTKGetDrawingWindow();
-        if (rect)
+        if (gtk_widget_get_mapped(m_widget))
          {
          {
-            int x = rect->x;
-            if (GetLayoutDirection() == wxLayout_RightToLeft)
-                x = GetClientSize().x - x - rect->width;
-            GdkRectangle r;
-            r.x = rect->x;
-            r.y = rect->y;
-            r.width = rect->width;
-            r.height = rect->height;
-            gdk_window_invalidate_rect(window, &r, true);
+            if (rect)
+                gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
+            else
+                gtk_widget_queue_draw(m_widget);
          }
          }
-        else
-            gdk_window_invalidate_rect(window, NULL, true);
      }
  }
  
      }
  }
  
@@ -3609,7 +3723,7 @@ void wxWindowGTK::Update()
  
          GdkWindow* window = GTKGetDrawingWindow();
          if (window == NULL)
  
          GdkWindow* window = GTKGetDrawingWindow();
          if (window == NULL)
-            window = m_widget->window;
+            window = gtk_widget_get_window(m_widget);
          gdk_window_process_updates(window, true);
  
          // Flush again, but no need to wait for it to finish
          gdk_window_process_updates(window, true);
  
          // Flush again, but no need to wait for it to finish
@@ -3630,14 +3744,23 @@ bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
          return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
  }
  
          return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
  }
  
-void wxWindowGTK::GtkSendPaintEvents()
+#ifdef __WXGTK3__
+void wxWindowGTK::GTKSendPaintEvents(cairo_t* cr)
+#else
+void wxWindowGTK::GTKSendPaintEvents(const GdkRegion* region)
+#endif
  {
  {
-    if (!m_wxwindow)
-    {
-        m_updateRegion.Clear();
-        return;
-    }
-
+#ifdef __WXGTK3__
+    m_paintContext = cr;
+    double x1, y1, x2, y2;
+    cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
+    m_updateRegion = wxRegion(int(x1), int(y1), int(x2 - x1), int(y2 - y1));
+#else // !__WXGTK3__
+    m_updateRegion = wxRegion(region);
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+    cairo_t* cr = NULL;
+#endif
+#endif // !__WXGTK3__
      // Clip to paint region in wxClientDC
      m_clipPaintRegion = true;
  
      // Clip to paint region in wxClientDC
      m_clipPaintRegion = true;
  
@@ -3648,8 +3771,7 @@ void wxWindowGTK::GtkSendPaintEvents()
          // Transform m_updateRegion under RTL
          m_updateRegion.Clear();
  
          // Transform m_updateRegion under RTL
          m_updateRegion.Clear();
  
-        gint width;
-        gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
+        const int width = gdk_window_get_width(GTKGetDrawingWindow());
  
          wxRegionIterator upd( m_nativeUpdateRegion );
          while (upd)
  
          wxRegionIterator upd( m_nativeUpdateRegion );
          while (upd)
@@ -3669,8 +3791,35 @@ void wxWindowGTK::GtkSendPaintEvents()
  
      switch ( GetBackgroundStyle() )
      {
  
      switch ( GetBackgroundStyle() )
      {
+        case wxBG_STYLE_TRANSPARENT:
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+            if (IsTransparentBackgroundSupported())
+            {
+                // Set a transparent background, so that overlaying in parent
+                // might indeed let see through where this child did not
+                // explicitly paint.
+                // NB: it works also for top level windows (but this is the
+                // windows manager which then does the compositing job)
+#ifndef __WXGTK3__
+                cr = gdk_cairo_create(m_wxwindow->window);
+                gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
+                cairo_clip(cr);
+#endif
+                cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
+                cairo_paint(cr);
+                cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+#ifndef __WXGTK3__
+                cairo_surface_flush(cairo_get_target(cr));
+#endif
+            }
+#endif // wxGTK_HAS_COMPOSITING_SUPPORT
+            break;
+
          case wxBG_STYLE_ERASE:
              {
          case wxBG_STYLE_ERASE:
              {
+#ifdef __WXGTK3__
+                wxGTKCairoDC dc(cr);
+#else
                  wxWindowDC dc( (wxWindow*)this );
                  dc.SetDeviceClippingRegion( m_updateRegion );
  
                  wxWindowDC dc( (wxWindow*)this );
                  dc.SetDeviceClippingRegion( m_updateRegion );
  
@@ -3683,7 +3832,7 @@ void wxWindowGTK::GtkSendPaintEvents()
                      dc.SetBackground(GetBackgroundColour());
                      dc.Clear();
                  }
                      dc.SetBackground(GetBackgroundColour());
                      dc.Clear();
                  }
-
+#endif // !__WXGTK3__
                  wxEraseEvent erase_event( GetId(), &dc );
                  erase_event.SetEventObject( this );
  
                  wxEraseEvent erase_event( GetId(), &dc );
                  erase_event.SetEventObject( this );
  
@@ -3698,34 +3847,28 @@ void wxWindowGTK::GtkSendPaintEvents()
          case wxBG_STYLE_SYSTEM:
              if ( GetThemeEnabled() )
              {
          case wxBG_STYLE_SYSTEM:
              if ( GetThemeEnabled() )
              {
+                GdkWindow* gdkWindow = GTKGetDrawingWindow();
+                const int w = gdk_window_get_width(gdkWindow);
+                const int h = gdk_window_get_height(gdkWindow);
+#ifdef __WXGTK3__
+                GtkStyleContext* sc = gtk_widget_get_style_context(m_wxwindow);
+                gtk_render_background(sc, cr, 0, 0, w, h);
+#else
                  // find ancestor from which to steal background
                  wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
                  if (!parent)
                      parent = (wxWindow*)this;
                  // find ancestor from which to steal background
                  wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
                  if (!parent)
                      parent = (wxWindow*)this;
-
-                if (gtk_widget_get_mapped(parent->m_widget))
-                {
-                    wxRegionIterator upd( m_nativeUpdateRegion );
-                    while (upd)
-                    {
-                        GdkRectangle rect;
-                        rect.x = upd.GetX();
-                        rect.y = upd.GetY();
-                        rect.width = upd.GetWidth();
-                        rect.height = upd.GetHeight();
-
-                        gtk_paint_flat_box( parent->m_widget->style,
-                                    GTKGetDrawingWindow(),
-                                    (GtkStateType)gtk_widget_get_state(m_wxwindow),
+                GdkRectangle rect;
+                m_nativeUpdateRegion.GetBox(rect.x, rect.y, rect.width, rect.height);
+                gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
+                                    gdkWindow,
+                                    gtk_widget_get_state(m_wxwindow),
                                      GTK_SHADOW_NONE,
                                      &rect,
                                      parent->m_widget,
                                      (char *)"base",
                                      GTK_SHADOW_NONE,
                                      &rect,
                                      parent->m_widget,
                                      (char *)"base",
-                                    0, 0, -1, -1 );
-
-                        ++upd;
-                    }
-                }
+                                    0, 0, w, h);
+#endif // !__WXGTK3__
              }
              break;
  
              }
              break;
  
@@ -3745,8 +3888,46 @@ void wxWindowGTK::GtkSendPaintEvents()
      paint_event.SetEventObject( this );
      HandleWindowEvent( paint_event );
  
      paint_event.SetEventObject( this );
      HandleWindowEvent( paint_event );
  
-    m_clipPaintRegion = false;
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+    if (IsTransparentBackgroundSupported())
+    { // now composite children which need it
+        // Overlay all our composite children on top of the painted area
+        wxWindowList::compatibility_iterator node;
+        for ( node = m_children.GetFirst(); node ; node = node->GetNext() )
+        {
+            wxWindow *compositeChild = node->GetData();
+            if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT)
+            {
+#ifndef __WXGTK3__
+                if (cr == NULL)
+                {
+                    cr = gdk_cairo_create(m_wxwindow->window);
+                    gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
+                    cairo_clip(cr);
+                }
+#endif // !__WXGTK3__
+                GtkWidget *child = compositeChild->m_wxwindow;
+                GtkAllocation alloc;
+                gtk_widget_get_allocation(child, &alloc);
+
+                // The source data is the (composited) child
+                gdk_cairo_set_source_window(
+                    cr, gtk_widget_get_window(child), alloc.x, alloc.y);
  
  
+                cairo_paint(cr);
+            }
+        }
+#ifndef __WXGTK3__
+        if (cr)
+            cairo_destroy(cr);
+#endif
+    }
+#endif // wxGTK_HAS_COMPOSITING_SUPPORT
+
+    m_clipPaintRegion = false;
+#ifdef __WXGTK3__
+    m_paintContext = NULL;
+#endif
      m_updateRegion.Clear();
      m_nativeUpdateRegion.Clear();
  }
      m_updateRegion.Clear();
      m_nativeUpdateRegion.Clear();
  }
@@ -3761,7 +3942,7 @@ void wxWindowGTK::SetDoubleBuffered( bool on )
  
  bool wxWindowGTK::IsDoubleBuffered() const
  {
  
  bool wxWindowGTK::IsDoubleBuffered() const
  {
-    return gtk_widget_get_double_buffered( m_wxwindow );
+    return gtk_widget_get_double_buffered( m_wxwindow ) != 0;
  }
  
  void wxWindowGTK::ClearBackground()
  }
  
  void wxWindowGTK::ClearBackground()
@@ -3796,11 +3977,13 @@ bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
      if (!wxWindowBase::SetBackgroundColour(colour))
          return false;
  
      if (!wxWindowBase::SetBackgroundColour(colour))
          return false;
  
-    if (colour.Ok())
+#ifndef __WXGTK3__
+    if (colour.IsOk())
      {
          // We need the pixel value e.g. for background clearing.
          m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
      }
      {
          // We need the pixel value e.g. for background clearing.
          m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
      }
+#endif
  
      // apply style change (forceStyle=true so that new style is applied
      // even if the bg colour changed from valid to wxNullColour)
  
      // apply style change (forceStyle=true so that new style is applied
      // even if the bg colour changed from valid to wxNullColour)
@@ -3818,11 +4001,13 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
          return false;
      }
  
          return false;
      }
  
-    if (colour.Ok())
+#ifndef __WXGTK3__
+    if (colour.IsOk())
      {
          // We need the pixel value e.g. for background clearing.
          m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
      }
      {
          // We need the pixel value e.g. for background clearing.
          m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
      }
+#endif
  
      // apply style change (forceStyle=true so that new style is applied
      // even if the bg colour changed from valid to wxNullColour):
  
      // apply style change (forceStyle=true so that new style is applied
      // even if the bg colour changed from valid to wxNullColour):
@@ -3836,19 +4021,20 @@ PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
      return gtk_widget_get_pango_context( m_widget );
  }
  
      return gtk_widget_get_pango_context( m_widget );
  }
  
+#ifndef __WXGTK3__
  GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
  {
      // do we need to apply any changes at all?
      if ( !forceStyle &&
  GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
  {
      // do we need to apply any changes at all?
      if ( !forceStyle &&
-         !m_font.Ok() &&
-         !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
+         !m_font.IsOk() &&
+         !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
      {
          return NULL;
      }
  
      GtkRcStyle *style = gtk_rc_style_new();
  
      {
          return NULL;
      }
  
      GtkRcStyle *style = gtk_rc_style_new();
  
-    if ( m_font.Ok() )
+    if ( m_font.IsOk() )
      {
          style->font_desc =
              pango_font_description_copy( m_font.GetNativeFontInfo()->description );
      {
          style->font_desc =
              pango_font_description_copy( m_font.GetNativeFontInfo()->description );
@@ -3859,7 +4045,7 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
          flagsActive = 0,
          flagsInsensitive = 0;
  
          flagsActive = 0,
          flagsInsensitive = 0;
  
-    if ( m_foregroundColour.Ok() )
+    if ( m_foregroundColour.IsOk() )
      {
          const GdkColor *fg = m_foregroundColour.GetColor();
  
      {
          const GdkColor *fg = m_foregroundColour.GetColor();
  
@@ -3876,7 +4062,7 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
          flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
      }
  
          flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
      }
  
-    if ( m_backgroundColour.Ok() )
+    if ( m_backgroundColour.IsOk() )
      {
          const GdkColor *bg = m_backgroundColour.GetColor();
  
      {
          const GdkColor *bg = m_backgroundColour.GetColor();
  
@@ -3904,15 +4090,20 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
  
      return style;
  }
  
      return style;
  }
+#endif // !__WXGTK3__
  
  
-void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
+void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle))
  {
  {
+#ifdef __WXGTK3__
+    DoApplyWidgetStyle(NULL);
+#else
      GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
      if ( style )
      {
          DoApplyWidgetStyle(style);
      GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
      if ( style )
      {
          DoApplyWidgetStyle(style);
-        gtk_rc_style_unref(style);
+        g_object_unref(style);
      }
      }
+#endif
  
      // Style change may affect GTK+'s size calculation:
      InvalidateBestSize();
  
      // Style change may affect GTK+'s size calculation:
      InvalidateBestSize();
@@ -3920,63 +4111,72 @@ void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
  
  void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
  {
  
  void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
  {
-    if ( m_wxwindow )
+    GtkWidget* widget = m_wxwindow ? m_wxwindow : m_widget;
+
+    // block the signal temporarily to avoid sending
+    // wxSysColourChangedEvents when we change the colours ourselves
+    bool unblock = false;
+    if (m_wxwindow && IsTopLevel())
      {
      {
-        // block the signal temporarily to avoid sending
-        // wxSysColourChangedEvents when we change the colours ourselves
-        bool unblock = false;
-        if ( IsTopLevel() )
-        {
-            unblock = true;
-            g_signal_handlers_block_by_func(
-                m_wxwindow, (void *)gtk_window_style_set_callback, this);
-        }
+        unblock = true;
+        g_signal_handlers_block_by_func(
+            m_wxwindow, (void*)style_updated, this);
+    }
  
  
-        gtk_widget_modify_style(m_wxwindow, style);
+    GTKApplyStyle(widget, style);
  
  
-        if ( unblock )
-        {
-            g_signal_handlers_unblock_by_func(
-                m_wxwindow, (void *)gtk_window_style_set_callback, this);
-        }
-    }
-    else
+    if (unblock)
      {
      {
-        gtk_widget_modify_style(m_widget, style);
+        g_signal_handlers_unblock_by_func(
+            m_wxwindow, (void*)style_updated, this);
      }
  }
  
      }
  }
  
+void wxWindowGTK::GTKApplyStyle(GtkWidget* widget, GtkRcStyle* WXUNUSED_IN_GTK3(style))
+{
+#ifdef __WXGTK3__
+    const PangoFontDescription* pfd = NULL;
+    if (m_font.IsOk())
+        pfd = pango_font_description_copy(m_font.GetNativeFontInfo()->description);
+    gtk_widget_override_font(widget, pfd);
+    gtk_widget_override_color(widget, GTK_STATE_FLAG_NORMAL, m_foregroundColour);
+    gtk_widget_override_background_color(widget, GTK_STATE_FLAG_NORMAL, m_backgroundColour);
+#else
+    gtk_widget_modify_style(widget, style);
+#endif
+}
+
  bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
  {
  bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
  {
-    wxWindowBase::SetBackgroundStyle(style);
+    if (!wxWindowBase::SetBackgroundStyle(style))
+        return false;
  
  
-    if ( style == wxBG_STYLE_PAINT )
+#ifndef __WXGTK3__
+    GdkWindow *window;
+    if ( m_wxwindow )
      {
      {
-        GdkWindow *window;
-        if ( m_wxwindow )
-        {
-            window = GTKGetDrawingWindow();
-        }
-        else
-        {
-            GtkWidget * const w = GetConnectWidget();
-            window = w ? w->window : NULL;
-        }
+        window = GTKGetDrawingWindow();
+    }
+    else
+    {
+        GtkWidget * const w = GetConnectWidget();
+        window = w ? gtk_widget_get_window(w) : NULL;
+    }
  
  
+    bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT;
+
+    if ( wantNoBackPixmap )
+    {
          if (window)
          {
              // Make sure GDK/X11 doesn't refresh the window
              // automatically.
          if (window)
          {
              // Make sure GDK/X11 doesn't refresh the window
              // automatically.
-            gdk_window_set_back_pixmap( window, None, False );
-#ifdef __X__
-            Display* display = GDK_WINDOW_DISPLAY(window);
-            XFlush(display);
-#endif
+            gdk_window_set_back_pixmap( window, NULL, FALSE );
              m_needsStyleChange = false;
          }
          else // window not realized yet
          {
              m_needsStyleChange = false;
          }
          else // window not realized yet
          {
-            // Do in OnIdle, because the window is not yet available
+            // Do when window is realized
              m_needsStyleChange = true;
          }
  
              m_needsStyleChange = true;
          }
  
@@ -3988,8 +4188,54 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
          // even if the bg colour changed from valid to wxNullColour):
          GTKApplyWidgetStyle(true);
      }
          // even if the bg colour changed from valid to wxNullColour):
          GTKApplyWidgetStyle(true);
      }
+#endif // !__WXGTK3__
+
+    return true;
+}
+
+bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
+{
+#if wxGTK_HAS_COMPOSITING_SUPPORT
+#ifndef __WXGTK3__
+    if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL)
+    {
+        if (reason)
+        {
+            *reason = _("GTK+ installed on this machine is too old to "
+                        "support screen compositing, please install "
+                        "GTK+ 2.12 or later.");
+        }
+
+        return false;
+    }
+#endif // !__WXGTK3__
+
+    // NB: We don't check here if the particular kind of widget supports
+    // transparency, we check only if it would be possible for a generic window
+
+    wxCHECK_MSG ( m_widget, false, "Window must be created first" );
+
+    if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget)))
+    {
+        if (reason)
+        {
+            *reason = _("Compositing not supported by this system, "
+                        "please enable it in your Window Manager.");
+        }
+
+        return false;
+    }
  
      return true;
  
      return true;
+#else
+    if (reason)
+    {
+        *reason = _("This program was compiled with a too old version of GTK+, "
+                    "please rebuild with GTK+ 2.12 or newer.");
+    }
+
+    return false;
+#endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
  }
  
  // ----------------------------------------------------------------------------
  }
  
  // ----------------------------------------------------------------------------
@@ -4100,7 +4346,7 @@ bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
  
  GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
  {
  
  GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
  {
-    return m_wxwindow ? GTKGetDrawingWindow() : m_widget->window;
+    return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
  }
  
  bool wxWindowGTK::SetFont( const wxFont &font )
  }
  
  bool wxWindowGTK::SetFont( const wxFont &font )
@@ -4125,12 +4371,12 @@ void wxWindowGTK::DoCaptureMouse()
      if (m_wxwindow)
          window = GTKGetDrawingWindow();
      else
      if (m_wxwindow)
          window = GTKGetDrawingWindow();
      else
-        window = GetConnectWidget()->window;
+        window = gtk_widget_get_window(GetConnectWidget());
  
      wxCHECK_RET( window, wxT("CaptureMouse() failed") );
  
      const wxCursor* cursor = &m_cursor;
  
      wxCHECK_RET( window, wxT("CaptureMouse() failed") );
  
      const wxCursor* cursor = &m_cursor;
-    if (!cursor->Ok())
+    if (!cursor->IsOk())
          cursor = wxSTANDARD_CURSOR;
  
      gdk_pointer_grab( window, FALSE,
          cursor = wxSTANDARD_CURSOR;
  
      gdk_pointer_grab( window, FALSE,
@@ -4158,7 +4404,7 @@ void wxWindowGTK::DoReleaseMouse()
      if (m_wxwindow)
          window = GTKGetDrawingWindow();
      else
      if (m_wxwindow)
          window = GTKGetDrawingWindow();
      else
-        window = GetConnectWidget()->window;
+        window = gtk_widget_get_window(GetConnectWidget());
  
      if (!window)
          return;
  
      if (!window)
          return;
@@ -4202,13 +4448,11 @@ void wxWindowGTK::SetScrollbar(int orient,
          thumbVisible = 1;
      }
  
          thumbVisible = 1;
      }
  
-    GtkAdjustment * const adj = sb->adjustment;
-    adj->page_size = thumbVisible;
-
      g_signal_handlers_block_by_func(
          sb, (void*)gtk_scrollbar_value_changed, this);
  
      gtk_range_set_increments(sb, 1, thumbVisible);
      g_signal_handlers_block_by_func(
          sb, (void*)gtk_scrollbar_value_changed, this);
  
      gtk_range_set_increments(sb, 1, thumbVisible);
+    gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
      gtk_range_set_range(sb, 0, range);
      gtk_range_set_value(sb, pos);
      m_scrollPos[dir] = gtk_range_get_value(sb);
      gtk_range_set_range(sb, 0, range);
      gtk_range_set_value(sb, pos);
      m_scrollPos[dir] = gtk_range_get_value(sb);
@@ -4243,7 +4487,7 @@ int wxWindowGTK::GetScrollThumb(int orient) const
      GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
      wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
  
      GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
      wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
  
-    return wxRound(sb->adjustment->page_size);
+    return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
  }
  
  int wxWindowGTK::GetScrollPos( int orient ) const
  }
  
  int wxWindowGTK::GetScrollPos( int orient ) const
@@ -4259,7 +4503,7 @@ int wxWindowGTK::GetScrollRange( int orient ) const
      GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
      wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
  
      GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
      wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
  
-    return wxRound(sb->adjustment->upper);
+    return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb)));
  }
  
  // Determine if increment is the same as +/-x, allowing for some small
  }
  
  // Determine if increment is the same as +/-x, allowing for some small
@@ -4297,11 +4541,11 @@ wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
          const bool isDown = diff > 0;
  
          GtkAdjustment* adj = gtk_range_get_adjustment(range);
          const bool isDown = diff > 0;
  
          GtkAdjustment* adj = gtk_range_get_adjustment(range);
-        if (IsScrollIncrement(adj->step_increment, diff))
+        if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
          {
              eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
          }
          {
              eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
          }
-        else if (IsScrollIncrement(adj->page_increment, diff))
+        else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
          {
              eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
          }
          {
              eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
          }
@@ -4378,12 +4622,6 @@ void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
      }
  }
  
      }
  }
  
-void wxWindowGTK::SetWindowStyleFlag( long style )
-{
-    // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
-    wxWindowBase::SetWindowStyleFlag(style);
-}
-
  // Find the wxWindow at the current mouse position, also returning the mouse
  // position.
  wxWindow* wxFindWindowAtPointer(wxPoint& pt)
  // Find the wxWindow at the current mouse position, also returning the mouse
  // position.
  wxWindow* wxFindWindowAtPointer(wxPoint& pt)
@@ -4396,38 +4634,17 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt)
  // Get the current mouse position.
  wxPoint wxGetMousePosition()
  {
  // Get the current mouse position.
  wxPoint wxGetMousePosition()
  {
-  /* This crashes when used within wxHelpContext,
-     so we have to use the X-specific implementation below.
-    gint x, y;
-    GdkModifierType *mask;
-    (void) gdk_window_get_pointer(NULL, &x, &y, mask);
-
-    return wxPoint(x, y);
-  */
-
      int x, y;
      int x, y;
-    GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
-
-    Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
-    Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
-    Window rootReturn, childReturn;
-    int rootX, rootY, winX, winY;
-    unsigned int maskReturn;
-
-    XQueryPointer (display,
-           rootWindow,
-           &rootReturn,
-                   &childReturn,
-                   &rootX, &rootY, &winX, &winY, &maskReturn);
-    return wxPoint(rootX, rootY);
-
+    GdkModifierType unused;
+    GetMouseState(x, y, unused);
+    return wxPoint(x, y);
  }
  
  GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
  {
      GdkWindow* window = NULL;
      if (m_wxwindow)
  }
  
  GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
  {
      GdkWindow* window = NULL;
      if (m_wxwindow)
-        window = m_wxwindow->window;
+        window = gtk_widget_get_window(m_wxwindow);
      return window;
  }
  
      return window;
  }
  
@@ -4452,9 +4669,11 @@ static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
          win
      );
  
          win
      );
  
-    GdkWindow* window = w->window;
+    GdkWindow* window;
      if (w == win->m_wxwindow)
          window = win->GTKGetDrawingWindow();
      if (w == win->m_wxwindow)
          window = win->GTKGetDrawingWindow();
+    else
+        window = gtk_widget_get_window(w);
      gdk_window_freeze_updates(window);
  }
  
      gdk_window_freeze_updates(window);
  }
  
@@ -4465,7 +4684,8 @@ void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
      if ( !w || !gtk_widget_get_has_window(w) )
          return; // window-less widget, cannot be frozen
  
      if ( !w || !gtk_widget_get_has_window(w) )
          return; // window-less widget, cannot be frozen
  
-    if ( !gtk_widget_get_realized(w) )
+    GdkWindow* window = gtk_widget_get_window(w);
+    if (window == NULL)
      {
          // we can't thaw unrealized widgets because they don't have GdkWindow,
          // so set it up to be done immediately after realization:
      {
          // we can't thaw unrealized widgets because they don't have GdkWindow,
          // so set it up to be done immediately after realization:
@@ -4479,7 +4699,6 @@ void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
          return;
      }
  
          return;
      }
  
-    GdkWindow* window = w->window;
      if (w == m_wxwindow)
          window = GTKGetDrawingWindow();
      gdk_window_freeze_updates(window);
      if (w == m_wxwindow)
          window = GTKGetDrawingWindow();
      gdk_window_freeze_updates(window);
@@ -4490,7 +4709,8 @@ void wxWindowGTK::GTKThawWidget(GtkWidget *w)
      if ( !w || !gtk_widget_get_has_window(w) )
          return; // window-less widget, cannot be frozen
  
      if ( !w || !gtk_widget_get_has_window(w) )
          return; // window-less widget, cannot be frozen
  
-    if ( !gtk_widget_get_realized(w) )
+    GdkWindow* window = gtk_widget_get_window(w);
+    if (window == NULL)
      {
          // the widget wasn't realized yet, no need to thaw
          g_signal_handlers_disconnect_by_func
      {
          // the widget wasn't realized yet, no need to thaw
          g_signal_handlers_disconnect_by_func
@@ -4502,7 +4722,6 @@ void wxWindowGTK::GTKThawWidget(GtkWidget *w)
          return;
      }
  
          return;
      }
  
-    GdkWindow* window = w->window;
      if (w == m_wxwindow)
          window = GTKGetDrawingWindow();
      gdk_window_thaw_updates(window);
      if (w == m_wxwindow)
          window = GTKGetDrawingWindow();
      gdk_window_thaw_updates(window);