use IMPLEMENT_APP_CONSOLE and not IMPLEMENT_APP for console apps

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

index 4dbeb3449891dc24b43bb133d36c9f7f9a94d8f6..5634ab6e2bc3753995b903188b986dd8e5807a58 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -1,5 +1,5 @@
  /////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////
-// Name:        gtk/window.cpp
+// Name:        src/gtk/window.cpp
  // Purpose:
  // Author:      Robert Roebling
  // Id:          $Id$
  // Purpose:
  // Author:      Robert Roebling
  // Id:          $Id$
@@ -15,71 +15,31 @@
  #endif
  
  #include "wx/window.h"
  #endif
  
  #include "wx/window.h"
-#include "wx/dcclient.h"
-#include "wx/frame.h"
-#include "wx/app.h"
-#include "wx/layout.h"
-#include "wx/utils.h"
-#include "wx/dialog.h"
-#include "wx/msgdlg.h"
-#include "wx/module.h"
-#include "wx/combobox.h"
  
  
-#if wxUSE_DRAG_AND_DROP
-    #include "wx/dnd.h"
-#endif
-
-#if wxUSE_TOOLTIPS
-    #include "wx/tooltip.h"
-#endif
-
-#if wxUSE_CARET
-    #include "wx/caret.h"
-#endif // wxUSE_CARET
-
-#if wxUSE_TEXTCTRL
-    #include "wx/textctrl.h"
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/toplevel.h"
+    #include "wx/dcclient.h"
+    #include "wx/menu.h"
+    #include "wx/settings.h"
+    #include "wx/msgdlg.h"
+    #include "wx/math.h"
  #endif
  
  #endif
  
-#include "wx/menu.h"
-#include "wx/statusbr.h"
-#include "wx/intl.h"
-#include "wx/settings.h"
-#include "wx/log.h"
+#include "wx/dnd.h"
+#include "wx/tooltip.h"
+#include "wx/caret.h"
  #include "wx/fontutil.h"
  #include "wx/fontutil.h"
-#include "wx/stattext.h"
-
-#ifdef __WXDEBUG__
-    #include "wx/thread.h"
-#endif
+#include "wx/sysopt.h"
  
  
-#include "wx/math.h"
  #include <ctype.h>
  
  #include <ctype.h>
  
-// FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
-#include <gtk/gtkversion.h>
-#if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
-#undef GTK_DISABLE_DEPRECATED
-#endif
-
  #include "wx/gtk/private.h"
  #include "wx/gtk/private.h"
-#include <gdk/gdkprivate.h>
+#include "wx/gtk/private/win_gtk.h"
  #include <gdk/gdkkeysyms.h>
  #include <gdk/gdkx.h>
  
  #include <gdk/gdkkeysyms.h>
  #include <gdk/gdkx.h>
  
-#include <gtk/gtk.h>
-#include <gtk/gtkprivate.h>
-
-#include "wx/gtk/win_gtk.h"
-
-#include <pango/pangox.h>
-
-#ifdef HAVE_XIM
-    #undef HAVE_XIM
-#endif
-
-extern GtkContainerClass *pizza_parent_class;
-
  //-----------------------------------------------------------------------------
  // documentation on internals
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
  // documentation on internals
  //-----------------------------------------------------------------------------
@@ -121,7 +81,7 @@ extern GtkContainerClass *pizza_parent_class;
     6) Display a border (sunken, raised, simple or none).
  
     Normally one might expect, that one wxWidgets window would always correspond
     6) Display a border (sunken, raised, simple or none).
  
     Normally one might expect, that one wxWidgets window would always correspond
-   to one GTK widget. Under GTK, there is no such allround widget that has all
+   to one GTK widget. Under GTK, there is no such all-round widget that has all
     the functionality. Moreover, the GTK defines a client area as a different
     widget from the actual widget you are handling. Last but not least some
     special classes (e.g. wxFrame) handle different categories of widgets and
     the functionality. Moreover, the GTK defines a client area as a different
     widget from the actual widget you are handling. Last but not least some
     special classes (e.g. wxFrame) handle different categories of widgets and
@@ -140,19 +100,19 @@ extern GtkContainerClass *pizza_parent_class;
     can find in m_widget (defined in wxWindow)
  
     When the class has a client area for drawing into and for containing children
     can find in m_widget (defined in wxWindow)
  
     When the class has a client area for drawing into and for containing children
-   it has to handle the client area widget (of the type GtkPizza, defined in
-   win_gtk.c), but there could be any number of widgets, handled by a class
+   it has to handle the client area widget (of the type wxPizza, defined in
+   win_gtk.cpp), but there could be any number of widgets, handled by a class.
     The common rule for all windows is only, that the widget that interacts with
     the rest of GTK must be referenced in m_widget and all other widgets must be
     children of this widget on the GTK level. The top-most widget, which also
     represents the client area, must be in the m_wxwindow field and must be of
     The common rule for all windows is only, that the widget that interacts with
     the rest of GTK must be referenced in m_widget and all other widgets must be
     children of this widget on the GTK level. The top-most widget, which also
     represents the client area, must be in the m_wxwindow field and must be of
-   the type GtkPizza.
+   the type wxPizza.
  
     As I said, the window classes that display a GTK native widget only have
     one widget, so in the case of e.g. the wxButton class m_widget holds a
     pointer to a GtkButton widget. But windows with client areas (for drawing
     and children) have a m_widget field that is a pointer to a GtkScrolled-
  
     As I said, the window classes that display a GTK native widget only have
     one widget, so in the case of e.g. the wxButton class m_widget holds a
     pointer to a GtkButton widget. But windows with client areas (for drawing
     and children) have a m_widget field that is a pointer to a GtkScrolled-
-   Window and a m_wxwindow field that is pointer to a GtkPizza and this
+   Window and a m_wxwindow field that is pointer to a wxPizza and this
     one is (in the GTK sense) a child of the GtkScrolledWindow.
  
     If the m_wxwindow field is set, then all input to this widget is inter-
     one is (in the GTK sense) a child of the GtkScrolledWindow.
  
     If the m_wxwindow field is set, then all input to this widget is inter-
@@ -166,14 +126,14 @@ extern GtkContainerClass *pizza_parent_class;
     clicking on a scrollbar belonging to scrolled window will inevitably move
     the window. In wxWidgets, the scrollbar will only emit an event, send this
     to (normally) a wxScrolledWindow and that class will call ScrollWindow()
     clicking on a scrollbar belonging to scrolled window will inevitably move
     the window. In wxWidgets, the scrollbar will only emit an event, send this
     to (normally) a wxScrolledWindow and that class will call ScrollWindow()
-   which actually moves the window and its subchildren. Note that GtkPizza
+   which actually moves the window and its sub-windows. Note that wxPizza
     memorizes how much it has been scrolled but that wxWidgets forgets this
     so that the two coordinates systems have to be kept in synch. This is done
     memorizes how much it has been scrolled but that wxWidgets forgets this
     so that the two coordinates systems have to be kept in synch. This is done
-   in various places using the pizza->xoffset and pizza->yoffset values.
+   in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
  
     III)
  
  
     III)
  
-   Singularily the most broken code in GTK is the code that is supposed to
+   Singularly the most broken code in GTK is the code that is supposed to
     inform subwindows (child windows) about new positions. Very often, duplicate
     events are sent without changes in size or position, equally often no
     events are sent at all (All this is due to a bug in the GtkContainer code
     inform subwindows (child windows) about new positions. Very often, duplicate
     events are sent without changes in size or position, equally often no
     events are sent at all (All this is due to a bug in the GtkContainer code
@@ -214,46 +174,36 @@ extern GtkContainerClass *pizza_parent_class;
  // data
  //-----------------------------------------------------------------------------
  
  // data
  //-----------------------------------------------------------------------------
  
-extern wxList     wxPendingDelete;
-extern bool       g_blockEventsOnDrag;
-extern bool       g_blockEventsOnScroll;
+// Don't allow event propagation during drag
+bool g_blockEventsOnDrag;
+// Don't allow mouse event propagation during scroll
+bool g_blockEventsOnScroll;
  extern wxCursor   g_globalCursor;
  
  extern wxCursor   g_globalCursor;
  
-static GdkGC *g_eraseGC = NULL;
-
  // mouse capture state: the window which has it and if the mouse is currently
  // inside it
  static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;
  static bool g_captureWindowHasMouse = false;
  
  // mouse capture state: the window which has it and if the mouse is currently
  // inside it
  static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;
  static bool g_captureWindowHasMouse = false;
  
-wxWindowGTK  *g_focusWindow = (wxWindowGTK*) NULL;
+// The window that currently has focus:
+static wxWindowGTK *gs_currentFocus = NULL;
+// The window that is scheduled to get focus in the next event loop iteration
+// or NULL if there's no pending focus change:
+static wxWindowGTK *gs_pendingFocus = NULL;
  
  
-// the last window which had the focus - this is normally never NULL (except
-// if we never had focus at all) as even when g_focusWindow is NULL it still
-// keeps its previous value
-wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
+// the window that has deferred focus-out event pending, if any (see
+// GTKAddDeferredFocusOut() for details)
+static wxWindowGTK *gs_deferredFocusOut = NULL;
  
  
-// If a window get the focus set but has not been realized
-// yet, defer setting the focus to idle time.
-wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
-
-extern bool g_mainThreadLocked;
+// global variables because GTK+ DnD want to have the
+// mouse event that caused it
+GdkEvent    *g_lastMouseEvent = (GdkEvent*) NULL;
+int          g_lastButtonNumber = 0;
  
  //-----------------------------------------------------------------------------
  // debug
  //-----------------------------------------------------------------------------
  
  
  //-----------------------------------------------------------------------------
  // debug
  //-----------------------------------------------------------------------------
  
-#ifdef __WXDEBUG__
-
-#if wxUSE_THREADS
-#   define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
-#else
-#   define DEBUG_MAIN_THREAD
-#endif
-#else
-#define DEBUG_MAIN_THREAD
-#endif // Debug
-
  // the trace mask used for the focus debugging messages
  #define TRACE_FOCUS _T("focus")
  
  // the trace mask used for the focus debugging messages
  #define TRACE_FOCUS _T("focus")
  
@@ -267,7 +217,7 @@ gdk_window_warp_pointer (GdkWindow      *window,
                           gint            y)
  {
    if (!window)
                           gint            y)
  {
    if (!window)
-    window = GDK_ROOT_PARENT();
+    window = gdk_get_default_root_window();
  
    if (!GDK_WINDOW_DESTROYED(window))
    {
  
    if (!GDK_WINDOW_DESTROYED(window))
    {
@@ -279,144 +229,6 @@ gdk_window_warp_pointer (GdkWindow      *window,
    }
  }
  
    }
  }
  
-//-----------------------------------------------------------------------------
-// idle system
-//-----------------------------------------------------------------------------
-
-extern void wxapp_install_idle_handler();
-extern bool g_isIdle;
-
-//-----------------------------------------------------------------------------
-// local code (see below)
-//-----------------------------------------------------------------------------
-
-// returns the child of win which currently has focus or NULL if not found
-//
-// Note: can't be static, needed by textctrl.cpp.
-wxWindow *wxFindFocusedChild(wxWindowGTK *win)
-{
-    wxWindow *winFocus = wxWindowGTK::FindFocus();
-    if ( !winFocus )
-        return (wxWindow *)NULL;
-
-    if ( winFocus == win )
-        return (wxWindow *)win;
-
-    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
-          node;
-          node = node->GetNext() )
-    {
-        wxWindow *child = wxFindFocusedChild(node->GetData());
-        if ( child )
-            return child;
-    }
-
-    return (wxWindow *)NULL;
-}
-
-static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
-{
-    // wxUniversal widgets draw the borders and scrollbars themselves
-#ifndef __WXUNIVERSAL__
-    if (!win->m_hasVMT)
-        return;
-
-    int dw = 0;
-    int dh = 0;
-
-    if (win->m_hasScrolling)
-    {
-        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
-
-        GtkRequisition vscroll_req;
-        vscroll_req.width = 2;
-        vscroll_req.height = 2;
-        (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
-            (scroll_window->vscrollbar, &vscroll_req );
-
-        GtkRequisition hscroll_req;
-        hscroll_req.width = 2;
-        hscroll_req.height = 2;
-        (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
-            (scroll_window->hscrollbar, &hscroll_req );
-
-        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
-
-        if (scroll_window->vscrollbar_visible)
-        {
-            dw += vscroll_req.width;
-            dw += scroll_class->scrollbar_spacing;
-        }
-
-        if (scroll_window->hscrollbar_visible)
-        {
-            dh += hscroll_req.height;
-            dh += scroll_class->scrollbar_spacing;
-        }
-    }
-
-    int dx = 0;
-    int dy = 0;
-    if (GTK_WIDGET_NO_WINDOW (widget))
-    {
-        dx += widget->allocation.x;
-        dy += widget->allocation.y;
-    }
-
-    if (win->HasFlag(wxRAISED_BORDER))
-    {
-        gtk_paint_shadow (widget->style,
-                          widget->window,
-                          GTK_STATE_NORMAL,
-                          GTK_SHADOW_OUT,
-                          NULL, NULL, NULL, // FIXME: No clipping?
-                          dx, dy,
-                          widget->allocation.width-dw, widget->allocation.height-dh );
-        return;
-    }
-
-    if (win->HasFlag(wxSUNKEN_BORDER))
-    {
-        gtk_paint_shadow (widget->style,
-                          widget->window,
-                          GTK_STATE_NORMAL,
-                          GTK_SHADOW_IN,
-                          NULL, NULL, NULL, // FIXME: No clipping?
-                          dx, dy,
-                          widget->allocation.width-dw, widget->allocation.height-dh );
-        return;
-    }
-
-    if (win->HasFlag(wxSIMPLE_BORDER))
-    {
-        GdkGC *gc;
-        gc = gdk_gc_new( widget->window );
-        gdk_gc_set_foreground( gc, &widget->style->black );
-        gdk_draw_rectangle( widget->window, gc, FALSE,
-                         dx, dy,
-                         widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
-        gdk_gc_unref( gc );
-        return;
-    }
-#endif // __WXUNIVERSAL__
-}
-
-//-----------------------------------------------------------------------------
-// "expose_event" of m_widget
-//-----------------------------------------------------------------------------
-
-extern "C" {
-static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
-{
-    if (gdk_event->count > 0) return FALSE;
-
-    draw_frame( widget, win );
-
-    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
-
-    return TRUE;
-}
-}
  
  //-----------------------------------------------------------------------------
  // "size_request" of m_widget
  
  //-----------------------------------------------------------------------------
  // "size_request" of m_widget
@@ -424,9 +236,9 @@ static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
  
  // make it extern because wxStaticText needs to disconnect this one
  extern "C" {
  
  // make it extern because wxStaticText needs to disconnect this one
  extern "C" {
-void wxgtk_window_size_request_callback(GtkWidget *widget,
+void wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget),
                                          GtkRequisition *requisition,
                                          GtkRequisition *requisition,
-                                        wxWindow *win)
+                                        wxWindow * win)
  {
      int w, h;
      win->GetSize( &w, &h );
  {
      int w, h;
      win->GetSize( &w, &h );
@@ -440,97 +252,102 @@ void wxgtk_window_size_request_callback(GtkWidget *widget,
  }
  }
  
  }
  }
  
+//-----------------------------------------------------------------------------
+// "expose_event" of m_wxwindow
+//-----------------------------------------------------------------------------
+
  extern "C" {
  extern "C" {
-static
-void wxgtk_combo_size_request_callback(GtkWidget *widget,
-                                       GtkRequisition *requisition,
-                                       wxComboBox *win)
+static gboolean
+gtk_window_expose_callback( GtkWidget* widget,
+                            GdkEventExpose *gdk_event,
+                            wxWindow *win )
  {
  {
-    // This callback is actually hooked into the text entry
-    // of the combo box, not the GtkHBox.
-
-    int w, h;
-    win->GetSize( &w, &h );
-    if (w < 2)
-        w = 2;
-    if (h < 2)
-        h = 2;
-
-    GtkCombo *gcombo = GTK_COMBO(win->m_widget);
-
-    GtkRequisition entry_req;
-    entry_req.width = 2;
-    entry_req.height = 2;
-    (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request )
-        (gcombo->button, &entry_req );
-
-    requisition->width = w - entry_req.width;
-    requisition->height = entry_req.height;
+    if (gdk_event->window == widget->window)
+    {
+        win->GetUpdateRegion() = wxRegion( gdk_event->region );
+        win->GtkSendPaintEvents();
+    }
+    // Let parent window draw window-less widgets
+    return FALSE;
  }
  }
  
  //-----------------------------------------------------------------------------
  }
  }
  
  //-----------------------------------------------------------------------------
-// "expose_event" of m_wxwindow
+// "expose_event" from m_widget, for drawing border
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static int gtk_window_expose_callback( GtkWidget *widget,
-                                       GdkEventExpose *gdk_event,
-                                       wxWindow *win )
-{
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+#ifndef __WXUNIVERSAL__
  
  
-    // This callback gets called in drawing-idle time under
-    // GTK 2.0, so we don't need to defer anything to idle
-    // time anymore.
+GtkWidget* GetEntryWidget();
  
  
-    GtkPizza *pizza = GTK_PIZZA( widget );
-    if (gdk_event->window != pizza->bin_window) return FALSE;
+extern "C" {
+static gboolean
+expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+{
+    // if this event is not for the GdkWindow the border is drawn on
+    if (win->m_wxwindow == win->m_widget && gdk_event->window == widget->window)
+        return false;
  
  
-#if 0
-    if (win->GetName())
+    int x = 0;
+    int y = 0;
+    // GtkScrolledWindow is GTK_NO_WINDOW
+    if (GTK_WIDGET_NO_WINDOW(widget))
      {
      {
-        wxPrintf( wxT("OnExpose from ") );
-        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-            wxPrintf( win->GetClassInfo()->GetClassName() );
-        wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
-                                         (int)gdk_event->area.y,
-                                         (int)gdk_event->area.width,
-                                         (int)gdk_event->area.height );
+        x = widget->allocation.x;
+        y = widget->allocation.y;
      }
      }
+    int w = win->m_wxwindow->allocation.width;
+    int h = win->m_wxwindow->allocation.height;
+    if (win->HasFlag(wxBORDER_SIMPLE))
+    {
+        GdkGC* gc = gdk_gc_new(gdk_event->window);
+        gdk_gc_set_foreground(gc, &widget->style->black);
+        gdk_draw_rectangle(gdk_event->window, gc, false, x, y, w - 1, h - 1);
+        g_object_unref(gc);
+    }
+    else
+    {
+        GtkShadowType shadow = GTK_SHADOW_IN;
+        if (win->HasFlag(wxBORDER_RAISED))
+            shadow = GTK_SHADOW_OUT;
+
+        // Style detail to use
+        const char* detail;
+        if (widget == win->m_wxwindow)
+            // for non-scrollable wxWindows
+            detail = "entry";
+        else
+            // for scrollable ones
+            detail = "viewport";
  
  
-    gtk_paint_box
-    (
-        win->m_wxwindow->style,
-        pizza->bin_window,
-        GTK_STATE_NORMAL,
-        GTK_SHADOW_OUT,
-        (GdkRectangle*) NULL,
-        win->m_wxwindow,
-        (char *)"button", // const_cast
-        20,20,24,24
-    );
-#endif
-
-    win->GetUpdateRegion() = wxRegion( gdk_event->region );
-
-    win->GtkSendPaintEvents();
-
-
-    // Let parent window draw window-less widgets
-    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
+        GtkWidget* styleWidget = GetEntryWidget();
+        gtk_paint_shadow(
+           styleWidget->style, gdk_event->window, GTK_STATE_NORMAL,
+           shadow, NULL, styleWidget, detail, x, y, w, h);
+    }
  
  
-    return FALSE;
+    // no further painting is needed for border-only GdkWindow
+    return win->m_wxwindow == win->m_widget;
  }
  }
  }
  }
+#endif // !__WXUNIVERSAL__
  
  //-----------------------------------------------------------------------------
  // "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  _T("keyevent")
  
  // set WXTRACE to this to see the key event codes on the console
  #define TRACE_KEYS  _T("keyevent")
  
@@ -652,11 +469,11 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
              break;
  
          case GDK_Prior:     // == GDK_Page_Up
              break;
  
          case GDK_Prior:     // == GDK_Page_Up
-            key_code = WXK_PRIOR;
+            key_code = WXK_PAGEUP;
              break;
  
          case GDK_Next:      // == GDK_Page_Down
              break;
  
          case GDK_Next:      // == GDK_Page_Down
-            key_code = WXK_NEXT;
+            key_code = WXK_PAGEDOWN;
              break;
  
          case GDK_End:
              break;
  
          case GDK_End:
@@ -683,11 +500,11 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
          case GDK_KP_7:
          case GDK_KP_8:
          case GDK_KP_9:
          case GDK_KP_7:
          case GDK_KP_8:
          case GDK_KP_9:
-            key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
+            key_code = (isChar ? '0' : int(WXK_NUMPAD0)) + keysym - GDK_KP_0;
              break;
  
          case GDK_KP_Space:
              break;
  
          case GDK_KP_Space:
-            key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
+            key_code = isChar ? ' ' : int(WXK_NUMPAD_SPACE);
              break;
  
          case GDK_KP_Tab:
              break;
  
          case GDK_KP_Tab:
@@ -735,11 +552,11 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
              break;
  
          case GDK_KP_Prior: // == GDK_KP_Page_Up
              break;
  
          case GDK_KP_Prior: // == GDK_KP_Page_Up
-            key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
+            key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
              break;
  
          case GDK_KP_Next: // == GDK_KP_Page_Down
              break;
  
          case GDK_KP_Next: // == GDK_KP_Page_Down
-            key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
+            key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
              break;
  
          case GDK_KP_End:
              break;
  
          case GDK_KP_End:
@@ -759,32 +576,32 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
              break;
  
          case GDK_KP_Equal:
              break;
  
          case GDK_KP_Equal:
-            key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
+            key_code = isChar ? '=' : int(WXK_NUMPAD_EQUAL);
              break;
  
          case GDK_KP_Multiply:
              break;
  
          case GDK_KP_Multiply:
-            key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
+            key_code = isChar ? '*' : int(WXK_NUMPAD_MULTIPLY);
              break;
  
          case GDK_KP_Add:
              break;
  
          case GDK_KP_Add:
-            key_code = isChar ? '+' : WXK_NUMPAD_ADD;
+            key_code = isChar ? '+' : int(WXK_NUMPAD_ADD);
              break;
  
          case GDK_KP_Separator:
              // FIXME: what is this?
              break;
  
          case GDK_KP_Separator:
              // FIXME: what is this?
-            key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
+            key_code = isChar ? '.' : int(WXK_NUMPAD_SEPARATOR);
              break;
  
          case GDK_KP_Subtract:
              break;
  
          case GDK_KP_Subtract:
-            key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
+            key_code = isChar ? '-' : int(WXK_NUMPAD_SUBTRACT);
              break;
  
          case GDK_KP_Decimal:
              break;
  
          case GDK_KP_Decimal:
-            key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
+            key_code = isChar ? '.' : int(WXK_NUMPAD_DECIMAL);
              break;
  
          case GDK_KP_Divide:
              break;
  
          case GDK_KP_Divide:
-            key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
+            key_code = isChar ? '/' : int(WXK_NUMPAD_DIVIDE);
              break;
  
  
              break;
  
  
@@ -837,10 +654,6 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event,
      event.m_rawFlags = 0;
  #if wxUSE_UNICODE
      event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
      event.m_rawFlags = 0;
  #if wxUSE_UNICODE
      event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
-    if ( gdk_event->type == GDK_KEY_PRESS ||  gdk_event->type == GDK_KEY_RELEASE )
-    {
-        event.m_uniChar = toupper(event.m_uniChar);
-    }
  #endif
      wxGetMousePosition( &x, &y );
      win->ScreenToClient( &x, &y );
  #endif
      wxGetMousePosition( &x, &y );
      win->ScreenToClient( &x, &y );
@@ -948,6 +761,12 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
      wxFillOtherKeyEventFields(event, win, gdk_event);
  
      event.m_keyCode = key_code;
      wxFillOtherKeyEventFields(event, win, gdk_event);
  
      event.m_keyCode = key_code;
+#if wxUSE_UNICODE
+    if ( gdk_event->type == GDK_KEY_PRESS ||  gdk_event->type == GDK_KEY_RELEASE )
+    {
+        event.m_uniChar = key_code;
+    }
+#endif
  
      return true;
  }
  
      return true;
  }
@@ -965,25 +784,26 @@ struct wxGtkIMData
      }
      ~wxGtkIMData()
      {
      }
      ~wxGtkIMData()
      {
-        g_object_unref(context);
+        g_object_unref (context);
      }
  };
  
  extern "C" {
      }
  };
  
  extern "C" {
-static gint gtk_window_key_press_callback( GtkWidget *widget,
-                                           GdkEventKey *gdk_event,
-                                           wxWindow *win )
+static gboolean
+gtk_window_key_press_callback( GtkWidget *widget,
+                               GdkEventKey *gdk_event,
+                               wxWindow *win )
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
      if (!win->m_hasVMT)
          return FALSE;
      if (g_blockEventsOnDrag)
          return FALSE;
  
      if (!win->m_hasVMT)
          return FALSE;
      if (g_blockEventsOnDrag)
          return FALSE;
  
+    // GTK+ sends keypress events to the focus widget and then
+    // to all its parent and grandparent widget. We only want
+    // the key events from the focus widget.
+    if (!GTK_WIDGET_HAS_FOCUS(widget))
+        return FALSE;
  
      wxKeyEvent event( wxEVT_KEY_DOWN );
      bool ret = false;
  
      wxKeyEvent event( wxEVT_KEY_DOWN );
      bool ret = false;
@@ -992,7 +812,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
      if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
          // Emit KEY_DOWN event
      if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
      {
          // Emit KEY_DOWN event
-        ret = win->GetEventHandler()->ProcessEvent( event );
+        ret = win->HandleWindowEvent( event );
      }
      else
      {
      }
      else
      {
@@ -1001,18 +821,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
          return_after_IM = true;
      }
  
          return_after_IM = true;
      }
  
-    // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
-    // When we get a key_press event here, it could be originate
-    // from the current widget or its child widgets.  However, only the widget
-    // with the INPUT FOCUS can generate the INITIAL key_press event.  That is,
-    // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
-    // originated from its child widgets and shouldn't be passed to IM context.
-    // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
-    // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS.  Besides, when current
-    // widgets has both IM context and input focus, the event should be filtered
-    // by gtk_im_context_filter_keypress().
-    // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
-    if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win ))
+    if ((!ret) && (win->m_imData != NULL))
      {
          // 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 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.
@@ -1022,12 +831,12 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
          if (intercepted_by_IM)
          {
              wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM"));
          if (intercepted_by_IM)
          {
              wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM"));
-            return true;
+            return TRUE;
          }
      }
  
      if (return_after_IM)
          }
      }
  
      if (return_after_IM)
-        return false;
+        return FALSE;
  
  #if wxUSE_ACCEL
      if (!ret)
  
  #if wxUSE_ACCEL
      if (!ret)
@@ -1038,8 +847,18 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
              int command = ancestor->GetAcceleratorTable()->GetCommand( event );
              if (command != -1)
              {
              int command = ancestor->GetAcceleratorTable()->GetCommand( event );
              if (command != -1)
              {
-                wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
-                ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+                wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
+                ret = ancestor->HandleWindowEvent( menu_event );
+
+                if ( !ret )
+                {
+                    // if the accelerator wasn't handled as menu event, try
+                    // it as button click (for compatibility with other
+                    // platforms):
+                    wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
+                    ret = ancestor->HandleWindowEvent( button_event );
+                }
+
                  break;
              }
              if (ancestor->IsTopLevel())
                  break;
              }
              if (ancestor->IsTopLevel())
@@ -1079,13 +898,17 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
  
              // To conform to the docs we need to translate Ctrl-alpha
              // characters to values in the range 1-26.
  
              // To conform to the docs we need to translate Ctrl-alpha
              // characters to values in the range 1-26.
-            if (event.ControlDown() && key_code >= 'a' && key_code <= 'z' )
+            if ( event.ControlDown() &&
+                 ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
              {
              {
-                event.m_keyCode = key_code - 'a' + 1;
+                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
  #if wxUSE_UNICODE
                  event.m_uniChar = event.m_keyCode;
  #endif
-            }               
+            }
  
              // Implement OnCharHook by checking ancestor top level windows
              wxWindow *parent = win;
  
              // Implement OnCharHook by checking ancestor top level windows
              wxWindow *parent = win;
@@ -1094,96 +917,26 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
              if (parent)
              {
                  event.SetEventType( wxEVT_CHAR_HOOK );
              if (parent)
              {
                  event.SetEventType( wxEVT_CHAR_HOOK );
-                ret = parent->GetEventHandler()->ProcessEvent( event );
+                ret = parent->HandleWindowEvent( event );
              }
  
              if (!ret)
              {
                  event.SetEventType(wxEVT_CHAR);
              }
  
              if (!ret)
              {
                  event.SetEventType(wxEVT_CHAR);
-                ret = win->GetEventHandler()->ProcessEvent( event );
-            }
-        }
-    }
-
-
-
-
-
-    // win is a control: tab can be propagated up
-    if ( !ret &&
-         ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
-// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may
-//     have this style, yet choose not to process this particular TAB in which
-//     case TAB must still work as a navigational character
-// JS: enabling again to make consistent with other platforms
-//     (with wxTE_PROCESS_TAB you have to call Navigate to get default
-//     navigation behaviour)
-#if wxUSE_TEXTCTRL
-         (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) &&
-#endif
-         win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
-    {
-        wxNavigationKeyEvent new_event;
-        new_event.SetEventObject( win->GetParent() );
-        // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
-        new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
-        // CTRL-TAB changes the (parent) window, i.e. switch notebook page
-        new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
-        new_event.SetCurrentFocus( win );
-        ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
-    }
-
-    // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
-    if ( !ret &&
-         (gdk_event->keyval == GDK_Escape) )
-    {
-        // however only do it if we have a Cancel button in the dialog,
-        // otherwise the user code may get confused by the events from a
-        // non-existing button and, worse, a wxButton might get button event
-        // from another button which is not really expected
-        wxWindow *winForCancel = win,
-                 *btnCancel = NULL;
-        while ( winForCancel )
-        {
-            btnCancel = winForCancel->FindWindow(wxID_CANCEL);
-            if ( btnCancel )
-            {
-                // found a cancel button
-                break;
+                ret = win->HandleWindowEvent( event );
              }
              }
-
-            if ( winForCancel->IsTopLevel() )
-            {
-                // no need to look further
-                break;
-            }
-
-            // maybe our parent has a cancel button?
-            winForCancel = winForCancel->GetParent();
-        }
-
-        if ( btnCancel )
-        {
-            wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
-            eventClick.SetEventObject(btnCancel);
-            ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick);
          }
      }
  
          }
      }
  
-    if (ret)
-    {
-        g_signal_stop_emission_by_name (widget, "key_press_event");
-        return TRUE;
-    }
-
-    return FALSE;
+    return ret;
  }
  }
  
  extern "C" {
  }
  }
  
  extern "C" {
-static void gtk_wxwindow_commit_cb (GtkIMContext *context,
-                           const gchar  *str,
-                           wxWindow     *window)
+static void
+gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
+                        const gchar  *str,
+                        wxWindow     *window)
  {
      wxKeyEvent event( wxEVT_KEY_DOWN );
  
  {
      wxKeyEvent event( wxEVT_KEY_DOWN );
  
@@ -1194,14 +947,13 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context,
          wxFillOtherKeyEventFields(event,
                                    window, window->m_imData->lastKeyEvent);
      }
          wxFillOtherKeyEventFields(event,
                                    window, window->m_imData->lastKeyEvent);
      }
+    else
+    {
+        event.SetEventObject( window );
+    }
  
  
-#if wxUSE_UNICODE
-    const wxWCharBuffer data = wxConvUTF8.cMB2WC( (char*)str );
-#else
-    const wxWCharBuffer wdata = wxConvUTF8.cMB2WC( (char*)str );
-    const wxCharBuffer data = wxConvLocal.cWC2MB( wdata );
-#endif // wxUSE_UNICODE
-    if( !(const wxChar*)data )
+    const wxString data(wxGTK_CONV_BACK_SYS(str));
+    if( data.empty() )
          return;
  
      bool ret = false;
          return;
  
      bool ret = false;
@@ -1211,7 +963,7 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context,
      while (parent && !parent->IsTopLevel())
          parent = parent->GetParent();
  
      while (parent && !parent->IsTopLevel())
          parent = parent->GetParent();
  
-    for( const wxChar* pstr = data; *pstr; pstr++ )
+    for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
      {
  #if wxUSE_UNICODE
          event.m_uniChar = *pstr;
      {
  #if wxUSE_UNICODE
          event.m_uniChar = *pstr;
@@ -1219,29 +971,35 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context,
          event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
          wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
  #else
          event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
          wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
  #else
-        event.m_keyCode = *pstr;
+        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.
  #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() && *pstr >= 'a' && *pstr <= 'z' )
+        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;
              event.m_keyCode = *pstr - 'a' + 1;
  #if wxUSE_UNICODE
              event.m_uniChar = event.m_keyCode;
-#endif  
-        }               
+#endif
+        }
  
          if (parent)
          {
              event.SetEventType( wxEVT_CHAR_HOOK );
  
          if (parent)
          {
              event.SetEventType( wxEVT_CHAR_HOOK );
-            ret = parent->GetEventHandler()->ProcessEvent( event );
+            ret = parent->HandleWindowEvent( event );
          }
  
          if (!ret)
          {
              event.SetEventType(wxEVT_CHAR);
          }
  
          if (!ret)
          {
              event.SetEventType(wxEVT_CHAR);
-            ret = window->GetEventHandler()->ProcessEvent( event );
+            ret = window->HandleWindowEvent( event );
          }
      }
  }
          }
      }
  }
@@ -1253,15 +1011,11 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context,
  //-----------------------------------------------------------------------------
  
  extern "C" {
  //-----------------------------------------------------------------------------
  
  extern "C" {
-static gint gtk_window_key_release_callback( GtkWidget *widget,
-                                             GdkEventKey *gdk_event,
-                                             wxWindowGTK *win )
+static gboolean
+gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
+                                 GdkEventKey *gdk_event,
+                                 wxWindowGTK *win )
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
      if (!win->m_hasVMT)
          return FALSE;
  
      if (!win->m_hasVMT)
          return FALSE;
  
@@ -1275,11 +1029,7 @@ static gint gtk_window_key_release_callback( GtkWidget *widget,
          return FALSE;
      }
  
          return FALSE;
      }
  
-    if ( !win->GetEventHandler()->ProcessEvent( event ) )
-        return FALSE;
-
-    g_signal_stop_emission_by_name (widget, "key_release_event");
-    return TRUE;
+    return win->GTKProcessEvent(event);
  }
  }
  
  }
  }
  
@@ -1297,27 +1047,27 @@ template<typename T> void InitMouseEvent(wxWindowGTK *win,
                                           T *gdk_event)
  {
      event.SetTimestamp( gdk_event->time );
                                           T *gdk_event)
  {
      event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
-    {
-       event.m_linesPerAction = 3;
-       event.m_wheelDelta = 120;
-       if (((GdkEventButton*)gdk_event)->button == 4)
-           event.m_wheelRotation = 120;
-       else if (((GdkEventButton*)gdk_event)->button == 5)
-           event.m_wheelRotation = -120;
-    }
+    event.m_shiftDown = gdk_event->state & GDK_SHIFT_MASK;
+    event.m_controlDown = gdk_event->state & GDK_CONTROL_MASK;
+    event.m_altDown = gdk_event->state & GDK_MOD1_MASK;
+    event.m_metaDown = gdk_event->state & GDK_MOD2_MASK;
+    event.m_leftDown = gdk_event->state & GDK_BUTTON1_MASK;
+    event.m_middleDown = gdk_event->state & GDK_BUTTON2_MASK;
+    event.m_rightDown = gdk_event->state & GDK_BUTTON3_MASK;
+    event.m_aux1Down = gdk_event->state & GDK_BUTTON4_MASK;
+    event.m_aux2Down = gdk_event->state & GDK_BUTTON5_MASK;
  
      wxPoint pt = win->GetClientAreaOrigin();
      event.m_x = (wxCoord)gdk_event->x - pt.x;
      event.m_y = (wxCoord)gdk_event->y - pt.y;
  
  
      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 );
      event.SetEventObject( win );
      event.SetId( win->GetId() );
      event.SetTimestamp( gdk_event->time );
@@ -1364,9 +1114,9 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
  
      if (win->m_wxwindow)
      {
  
      if (win->m_wxwindow)
      {
-        GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
-        xx += pizza->xoffset;
-        yy += pizza->yoffset;
+        wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
+        xx += pizza->m_scroll_x;
+        yy += pizza->m_scroll_y;
      }
  
      wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
      }
  
      wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
@@ -1421,47 +1171,72 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
      return win;
  }
  
      return win;
  }
  
-//-----------------------------------------------------------------------------
-// "button_press_event"
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// common event handlers helpers
+// ----------------------------------------------------------------------------
  
  
-extern "C" {
-static gint gtk_window_button_press_callback( GtkWidget *widget,
-                                              GdkEventButton *gdk_event,
-                                              wxWindowGTK *win )
+bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
  {
  {
-    DEBUG_MAIN_THREAD
+    // nothing special at this level
+    return HandleWindowEvent(event);
+}
  
  
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
+{
+    if (!m_hasVMT)
+        return FALSE;
+    if (g_blockEventsOnDrag)
+        return TRUE;
+    if (g_blockEventsOnScroll)
+        return TRUE;
  
  
-/*
-    wxPrintf( wxT("1) OnButtonPress from ") );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( wxT(".\n") );
-*/
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return TRUE;
-    if (g_blockEventsOnScroll) return TRUE;
+    if (!GTKIsOwnWindow(event->window))
+        return FALSE;
  
  
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    return -1;
+}
  
  
-    if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
-    {
-        gtk_widget_grab_focus( win->m_wxwindow );
-/*
-        wxPrintf( wxT("GrabFocus from ") );
-        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-            wxPrintf( win->GetClassInfo()->GetClassName() );
-        wxPrintf( wxT(".\n") );
-*/
+// overloads for all GDK event types we use here: we need to have this as
+// GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
+// derives from it in the sense that the structs have the same layout
+#define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T)                                  \
+    static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win)        \
+    {                                                                         \
+        return win->GTKCallbackCommonPrologue((GdkEventAny *)event);          \
      }
  
      }
  
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
+
+#undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
+
+#define wxCOMMON_CALLBACK_PROLOGUE(event, win)                                \
+    const int rc = wxGtkCallbackCommonPrologue(event, win);                   \
+    if ( rc != -1 )                                                           \
+        return rc
+
+// all event handlers must have C linkage as they're called from GTK+ C code
+extern "C"
+{
+
+//-----------------------------------------------------------------------------
+// "button_press_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_button_press_callback( GtkWidget *widget,
+                                  GdkEventButton *gdk_event,
+                                  wxWindowGTK *win )
+{
+    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.
      // GDK sends surplus button down events
      // before a double click event. We
      // need to filter these out.
-    if (gdk_event->type == GDK_BUTTON_PRESS)
+    if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
      {
          GdkEvent *peek_event = gdk_event_peek();
          if (peek_event)
      {
          GdkEvent *peek_event = gdk_event_peek();
          if (peek_event)
@@ -1481,10 +1256,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
  
      wxEventType event_type = wxEVT_NULL;
  
  
      wxEventType event_type = wxEVT_NULL;
  
-    // GdkDisplay is a GTK+ 2.2.0 thing
-#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
      if ( gdk_event->type == GDK_2BUTTON_PRESS &&
      if ( gdk_event->type == GDK_2BUTTON_PRESS &&
-            !gtk_check_version(2,2,0) &&
              gdk_event->button >= 1 && gdk_event->button <= 3 )
      {
          // Reset GDK internal timestamp variables in order to disable GDK
              gdk_event->button >= 1 && gdk_event->button <= 3 )
      {
          // Reset GDK internal timestamp variables in order to disable GDK
@@ -1494,7 +1266,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
          display->button_click_time[1] = 0;
          display->button_click_time[0] = 0;
      }
          display->button_click_time[1] = 0;
          display->button_click_time[0] = 0;
      }
-#endif // GTK 2+
  
      if (gdk_event->button == 1)
      {
  
      if (gdk_event->button == 1)
      {
@@ -1555,13 +1326,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
                  ;
          }
      }
                  ;
          }
      }
-    else if (gdk_event->button == 4 || gdk_event->button == 5)
-    {
-        if (gdk_event->type == GDK_BUTTON_PRESS )
-        {
-            event_type = wxEVT_MOUSEWHEEL;
-        }
-    }
  
      if ( event_type == wxEVT_NULL )
      {
  
      if ( event_type == wxEVT_NULL )
      {
@@ -1569,6 +1333,8 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
          return FALSE;
      }
  
          return FALSE;
      }
  
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
+
      wxMouseEvent event( event_type );
      InitMouseEvent( win, event, gdk_event );
  
      wxMouseEvent event( event_type );
      InitMouseEvent( win, event, gdk_event );
  
@@ -1584,10 +1350,19 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
      if ( !g_captureWindow )
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
  
      if ( !g_captureWindow )
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
  
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        g_signal_stop_emission_by_name (widget, "button_press_event");
+    // reset the event object and id in case win changed.
+    event.SetEventObject( win );
+    event.SetId( win->GetId() );
+
+    bool ret = win->GTKProcessEvent( event );
+    g_lastMouseEvent = NULL;
+    if ( ret )
          return TRUE;
          return TRUE;
+
+    if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
+        (gs_currentFocus != win) /* && win->IsFocusable() */)
+    {
+        win->SetFocus();
      }
  
      if (event_type == wxEVT_RIGHT_DOWN)
      }
  
      if (event_type == wxEVT_RIGHT_DOWN)
@@ -1604,32 +1379,24 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
              win->GetId(),
              win->ClientToScreen(event.GetPosition()));
          evtCtx.SetEventObject(win);
              win->GetId(),
              win->ClientToScreen(event.GetPosition()));
          evtCtx.SetEventObject(win);
-        return win->GetEventHandler()->ProcessEvent(evtCtx);
+        return win->GTKProcessEvent(evtCtx);
      }
  
      return FALSE;
  }
      }
  
      return FALSE;
  }
-}
  
  //-----------------------------------------------------------------------------
  // "button_release_event"
  //-----------------------------------------------------------------------------
  
  
  //-----------------------------------------------------------------------------
  // "button_release_event"
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gint gtk_window_button_release_callback( GtkWidget *widget,
-                                                GdkEventButton *gdk_event,
-                                                wxWindowGTK *win )
+static gboolean
+gtk_window_button_release_callback( GtkWidget *widget,
+                                    GdkEventButton *gdk_event,
+                                    wxWindowGTK *win )
  {
  {
-    DEBUG_MAIN_THREAD
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
  
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-    if (g_blockEventsOnScroll) return FALSE;
-
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    g_lastButtonNumber = 0;
  
      wxEventType event_type = wxEVT_NULL;
  
  
      wxEventType event_type = wxEVT_NULL;
  
@@ -1648,10 +1415,12 @@ static gint gtk_window_button_release_callback( GtkWidget *widget,
              break;
  
          default:
              break;
  
          default:
-            // unknwon button, don't process
+            // unknown button, don't process
              return FALSE;
      }
  
              return FALSE;
      }
  
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
+
      wxMouseEvent event( event_type );
      InitMouseEvent( win, event, gdk_event );
  
      wxMouseEvent event( event_type );
      InitMouseEvent( win, event, gdk_event );
  
@@ -1663,35 +1432,27 @@ static gint gtk_window_button_release_callback( GtkWidget *widget,
      if ( !g_captureWindow )
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
  
      if ( !g_captureWindow )
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
  
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        g_signal_stop_emission_by_name (widget, "button_release_event");
-        return TRUE;
-    }
+    // reset the event object and id in case win changed.
+    event.SetEventObject( win );
+    event.SetId( win->GetId() );
  
  
-    return FALSE;
-}
+    bool ret = win->GTKProcessEvent(event);
+
+    g_lastMouseEvent = NULL;
+
+    return ret;
  }
  
  //-----------------------------------------------------------------------------
  // "motion_notify_event"
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "motion_notify_event"
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gint gtk_window_motion_notify_callback( GtkWidget *widget,
-                                               GdkEventMotion *gdk_event,
-                                               wxWindowGTK *win )
+static gboolean
+gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
+                                   GdkEventMotion *gdk_event,
+                                   wxWindowGTK *win )
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-    if (g_blockEventsOnScroll) return FALSE;
-
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      if (gdk_event->is_hint)
      {
  
      if (gdk_event->is_hint)
      {
@@ -1703,19 +1464,14 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
          gdk_event->y = y;
      }
  
          gdk_event->y = y;
      }
  
-/*
-    printf( "OnMotion from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-      printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
  
      wxMouseEvent event( wxEVT_MOTION );
      InitMouseEvent(win, event, gdk_event);
  
      if ( g_captureWindow )
      {
  
      wxMouseEvent event( wxEVT_MOTION );
      InitMouseEvent(win, event, gdk_event);
  
      if ( g_captureWindow )
      {
-        // synthetize a mouse enter or leave event if needed
+        // synthesise a mouse enter or leave event if needed
          GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
          // This seems to be necessary and actually been added to
          // GDK itself in version 2.0.X
          GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
          // This seems to be necessary and actually been added to
          // GDK itself in version 2.0.X
@@ -1731,65 +1487,51 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
                                                          : wxEVT_LEAVE_WINDOW);
              InitMouseEvent(win, eventM, gdk_event);
              eventM.SetEventObject(win);
                                                          : wxEVT_LEAVE_WINDOW);
              InitMouseEvent(win, eventM, gdk_event);
              eventM.SetEventObject(win);
-            win->GetEventHandler()->ProcessEvent(eventM);
+            win->GTKProcessEvent(eventM);
          }
      }
      else // no capture
      {
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
          }
      }
      else // no capture
      {
          win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+        // reset the event object and id in case win changed.
+        event.SetEventObject( win );
+        event.SetId( win->GetId() );
      }
  
      if ( !g_captureWindow )
      {
          wxSetCursorEvent cevent( event.m_x, event.m_y );
      }
  
      if ( !g_captureWindow )
      {
          wxSetCursorEvent cevent( event.m_x, event.m_y );
-        if (win->GetEventHandler()->ProcessEvent( cevent ))
+        if (win->GTKProcessEvent( cevent ))
          {
          {
-            // Rewrite cursor handling here (away from idle).
+            win->SetCursor( cevent.GetCursor() );
          }
      }
          }
      }
-    
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        g_signal_stop_emission_by_name (widget, "motion_notify_event");
-        return TRUE;
-    }
  
  
-    return FALSE;
-}
+    bool ret = win->GTKProcessEvent(event);
+
+    g_lastMouseEvent = NULL;
+
+    return ret;
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
-// "mouse_wheel_event"
+// "scroll_event" (mouse wheel event)
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gint gtk_window_wheel_callback (GtkWidget * widget,
-                                       GdkEventScroll * gdk_event,
-                                       wxWindowGTK * win)
+static gboolean
+window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    if (gdk_event->direction != GDK_SCROLL_UP &&
+        gdk_event->direction != GDK_SCROLL_DOWN)
+    {
+        return false;
+    }
  
  
-    wxEventType event_type = wxEVT_NULL;
-    if (gdk_event->direction == GDK_SCROLL_UP)
-        event_type = wxEVT_MOUSEWHEEL;
-    else if (gdk_event->direction == GDK_SCROLL_DOWN)
-        event_type = wxEVT_MOUSEWHEEL;
-    else
-        return FALSE;
+    wxMouseEvent event(wxEVT_MOUSEWHEEL);
+    InitMouseEvent(win, event, gdk_event);
  
  
-    wxMouseEvent event( event_type );
-    // Can't use InitMouse macro because scroll events don't have button
-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    // 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_linesPerAction = 3;
      event.m_wheelDelta = 120;
      if (gdk_event->direction == GDK_SCROLL_UP)
@@ -1797,202 +1539,80 @@ static gint gtk_window_wheel_callback (GtkWidget * widget,
      else
          event.m_wheelRotation = -120;
  
      else
          event.m_wheelRotation = -120;
  
-    wxPoint pt = win->GetClientAreaOrigin();
-    event.m_x = (wxCoord)gdk_event->x - pt.x;
-    event.m_y = (wxCoord)gdk_event->y - pt.y;
-
-    event.SetEventObject( win );
-    event.SetId( win->GetId() );
-    event.SetTimestamp( gdk_event->time );
-
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        g_signal_stop_emission_by_name (widget, "scroll_event");
-        return TRUE;
-    }
-
-    return FALSE;
-}
+    return win->GTKProcessEvent(event);
  }
  
  //-----------------------------------------------------------------------------
  // "popup-menu"
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
  // "popup-menu"
  //-----------------------------------------------------------------------------
-extern "C" {
+
  static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
  {
  static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
  {
-    wxContextMenuEvent event(
-        wxEVT_CONTEXT_MENU,
-        win->GetId(),
-        wxPoint(-1, -1));
+    wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
      event.SetEventObject(win);
      event.SetEventObject(win);
-    return win->GetEventHandler()->ProcessEvent(event);
-}
+    return win->GTKProcessEvent(event);
  }
  
  //-----------------------------------------------------------------------------
  // "focus_in_event"
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "focus_in_event"
  //-----------------------------------------------------------------------------
  
-// send the wxChildFocusEvent and wxFocusEvent, common code of
-// gtk_window_focus_in_callback() and SetFocus()
-static bool DoSendFocusEvents(wxWindow *win)
-{
-    // Notify the parent keeping track of focus for the kbd navigation
-    // purposes that we got it.
-    wxChildFocusEvent eventChildFocus(win);
-    (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
-
-    wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
-    eventFocus.SetEventObject(win);
-
-    return win->GetEventHandler()->ProcessEvent(eventFocus);
-}
-
-extern "C" {
-static gboolean gtk_window_focus_in_callback( GtkWidget *widget,
-                                              GdkEvent *WXUNUSED(event),
-                                              wxWindow *win )
+static gboolean
+gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
+                              GdkEventFocus *WXUNUSED(event),
+                              wxWindowGTK *win )
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (win->m_imData)
-        gtk_im_context_focus_in(win->m_imData->context);
-
-    g_focusWindowLast =
-    g_focusWindow = win;
-
-    wxLogTrace(TRACE_FOCUS,
-               _T("%s: focus in"), win->GetName().c_str());
-
-#ifdef HAVE_XIM
-    if (win->m_ic)
-        gdk_im_begin(win->m_ic, win->m_wxwindow->window);
-#endif
-
-#if wxUSE_CARET
-    // caret needs to be informed about focus change
-    wxCaret *caret = win->GetCaret();
-    if ( caret )
-    {
-        caret->OnSetFocus();
-    }
-#endif // wxUSE_CARET
-
-    gboolean ret = FALSE;
-
-    // does the window itself think that it has the focus?
-    if ( !win->m_hasFocus )
-    {
-        // not yet, notify it
-        win->m_hasFocus = true;
-
-        (void)DoSendFocusEvents(win);
-        
-        ret = true;
-    }
-
-    // Disable default focus handling for custom windows
-    // since the default GTK+ handler issues a repaint
-    if (win->m_wxwindow)
-        return ret;
-        
-    return false;
-}
+    return win->GTKHandleFocusIn();
  }
  
  //-----------------------------------------------------------------------------
  // "focus_out_event"
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "focus_out_event"
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gboolean gtk_window_focus_out_callback( GtkWidget *widget,
-                                               GdkEventFocus *gdk_event,
-                                               wxWindowGTK *win )
+static gboolean
+gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
+                               GdkEventFocus * WXUNUSED(gdk_event),
+                               wxWindowGTK *win )
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (win->m_imData)
-        gtk_im_context_focus_out(win->m_imData->context);
-
-    wxLogTrace( TRACE_FOCUS,
-                _T("%s: focus out"), win->GetName().c_str() );
-
-
-    wxWindowGTK *winFocus = wxFindFocusedChild(win);
-    if ( winFocus )
-        win = winFocus;
-
-    g_focusWindow = (wxWindowGTK *)NULL;
-
-#ifdef HAVE_XIM
-    if (win->m_ic)
-        gdk_im_end();
-#endif
-
-#if wxUSE_CARET
-    // caret needs to be informed about focus change
-    wxCaret *caret = win->GetCaret();
-    if ( caret )
-    {
-        caret->OnKillFocus();
-    }
-#endif // wxUSE_CARET
-
-    gboolean ret = FALSE;
-
-    // don't send the window a kill focus event if it thinks that it doesn't
-    // have focus already
-    if ( win->m_hasFocus )
-    {
-        win->m_hasFocus = false;
+    return win->GTKHandleFocusOut();
+}
  
  
-        wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
-        event.SetEventObject( win );
+//-----------------------------------------------------------------------------
+// "focus"
+//-----------------------------------------------------------------------------
  
  
-        (void)win->GetEventHandler()->ProcessEvent( event );
-        
-        ret = true;
-    }
-    
-    // Disable default focus handling for custom windows
-    // since the default GTK+ handler issues a repaint
-    if (win->m_wxwindow)
-        return ret;
-           
-    return false;
-}
+static gboolean
+wx_window_focus_callback(GtkWidget *widget,
+                         GtkDirectionType WXUNUSED(direction),
+                         wxWindowGTK *win)
+{
+    // the default handler for focus signal in GtkScrolledWindow sets
+    // focus to the window itself even if it doesn't accept focus, i.e. has no
+    // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
+    // the signal from reaching gtk_scrolled_window_focus() if we don't have
+    // any children which might accept focus (we know we don't accept the focus
+    // ourselves as this signal is only connected in this case)
+    if ( win->GetChildren().empty() )
+        g_signal_stop_emission_by_name(widget, "focus");
+
+    // we didn't change the focus
+    return FALSE;
  }
  
  //-----------------------------------------------------------------------------
  // "enter_notify_event"
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "enter_notify_event"
  //-----------------------------------------------------------------------------
  
-extern "C" {
  static gboolean
  gtk_window_enter_callback( GtkWidget *widget,
                             GdkEventCrossing *gdk_event,
                             wxWindowGTK *win )
  {
  static gboolean
  gtk_window_enter_callback( GtkWidget *widget,
                             GdkEventCrossing *gdk_event,
                             wxWindowGTK *win )
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      // Event was emitted after a grab
      if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
  
  
      // Event was emitted after a grab
      if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
  
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-
      int x = 0;
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
      int x = 0;
      int y = 0;
      GdkModifierType state = (GdkModifierType)0;
@@ -2008,48 +1628,30 @@ gtk_window_enter_callback( GtkWidget *widget,
      if ( !g_captureWindow )
      {
          wxSetCursorEvent cevent( event.m_x, event.m_y );
      if ( !g_captureWindow )
      {
          wxSetCursorEvent cevent( event.m_x, event.m_y );
-        if (win->GetEventHandler()->ProcessEvent( cevent ))
+        if (win->GTKProcessEvent( cevent ))
          {
          {
-            // Rewrite cursor handling here (away from idle).
+            win->SetCursor( cevent.GetCursor() );
          }
      }
          }
      }
-    
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-       g_signal_stop_emission_by_name (widget, "enter_notify_event");
-       return TRUE;
-    }
  
  
-    return FALSE;
-}
+    return win->GTKProcessEvent(event);
  }
  
  //-----------------------------------------------------------------------------
  // "leave_notify_event"
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "leave_notify_event"
  //-----------------------------------------------------------------------------
  
-extern "C" {
  static gboolean
  gtk_window_leave_callback( GtkWidget *widget,
                             GdkEventCrossing *gdk_event,
                             wxWindowGTK *win )
  {
  static gboolean
  gtk_window_leave_callback( GtkWidget *widget,
                             GdkEventCrossing *gdk_event,
                             wxWindowGTK *win )
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
  
      // Event was emitted after an ungrab
      if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
  
  
      // Event was emitted after an ungrab
      if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
  
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-
      wxMouseEvent event( wxEVT_LEAVE_WINDOW );
      wxMouseEvent event( wxEVT_LEAVE_WINDOW );
-    event.SetTimestamp( gdk_event->time );
-    event.SetEventObject( win );
  
      int x = 0;
      int y = 0;
  
      int x = 0;
      int y = 0;
@@ -2057,367 +1659,229 @@ gtk_window_leave_callback( GtkWidget *widget,
  
      gdk_window_get_pointer( widget->window, &x, &y, &state );
  
  
      gdk_window_get_pointer( widget->window, &x, &y, &state );
  
-    event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
-    event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
-    event.m_altDown = (state & GDK_MOD1_MASK) != 0;
-    event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
-    event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
-    event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
-    event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
-
-    wxPoint pt = win->GetClientAreaOrigin();
-    event.m_x = x + pt.x;
-    event.m_y = y + pt.y;
-
-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        g_signal_stop_emission_by_name (widget, "leave_notify_event");
-        return TRUE;
-    }
+    InitMouseEvent(win, event, gdk_event);
  
  
-    return FALSE;
-}
+    return win->GTKProcessEvent(event);
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
-// "value_changed" from m_vAdjust
+// "value_changed" from scrollbar
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
-                                         wxWindowGTK *win )
+static void
+gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
-
-    if (!win->m_hasVMT) return;
-
-    float diff = adjust->value - win->m_oldVerticalPos;
-    if (fabs(diff) < 0.2) return;
-
-    win->m_oldVerticalPos = adjust->value;
+    wxEventType eventType = win->GetScrollEventType(range);
+    if (eventType != wxEVT_NULL)
+    {
+        // Convert scroll event type to scrollwin event type
+        eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
  
  
-    wxEventType command = GtkScrollWinTypeToWx(GTK_SCROLL_JUMP);
+        // find the scrollbar which generated the event
+        wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
  
  
-    int value = (int)(adjust->value+0.5);
+        // generate the corresponding wx event
+        const int orient = wxWindow::OrientFromScrollDir(dir);
+        wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
+        event.SetEventObject(win);
  
  
-    wxScrollWinEvent event( command, value, wxVERTICAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
-}
+        win->GTKProcessEvent(event);
+    }
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
-// "value_changed" from m_hAdjust
+// "button_press_event" from scrollbar
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
-                                         wxWindowGTK *win )
+static gboolean
+gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
-    if (!win->m_hasVMT) return;
-
-    float diff = adjust->value - win->m_oldHorizontalPos;
-    if (fabs(diff) < 0.2) return;
-
-    wxEventType command = GtkScrollWinTypeToWx(GTK_SCROLL_JUMP);
-
-    win->m_oldHorizontalPos = adjust->value;
-
-    int value = (int)(adjust->value+0.5);
+    g_blockEventsOnScroll = true;
+    win->m_mouseButtonDown = true;
  
  
-    wxScrollWinEvent event( command, value, wxHORIZONTAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
-}
+    return false;
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
-// "button_press_event" from scrollbar
+// "event_after" from scrollbar
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
-                                                 GdkEventButton *gdk_event,
-                                                 wxWindowGTK *win)
+static void
+gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-
-    g_blockEventsOnScroll = true;
-
-// FIXME: there is no 'slider' field in GTK+ 2.0 any more
-#if 0
-    win->m_isScrolling = (gdk_event->window == widget->slider);
-#endif
-
-    return FALSE;
-}
+    if (event->type == GDK_BUTTON_RELEASE)
+    {
+        g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
+
+        const int orient = wxWindow::OrientFromScrollDir(
+                                        win->ScrollDirFromRange(range));
+        wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
+                                win->GetScrollPos(orient), orient);
+        evt.SetEventObject(win);
+        win->GTKProcessEvent(evt);
+    }
  }
  
  //-----------------------------------------------------------------------------
  // "button_release_event" from scrollbar
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "button_release_event" from scrollbar
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
-                                                   GdkEventButton *WXUNUSED(gdk_event),
-                                                   wxWindowGTK *win)
+static gboolean
+gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-//  don't test here as we can release the mouse while being over
-//  a different window than the slider
-//
-//    if (gdk_event->window != widget->slider) return FALSE;
-
      g_blockEventsOnScroll = false;
      g_blockEventsOnScroll = false;
-
+    win->m_mouseButtonDown = false;
+    // If thumb tracking
      if (win->m_isScrolling)
      {
      if (win->m_isScrolling)
      {
-        wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
-        int value = -1;
-        int dir = -1;
-
-        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-        if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
-        {
-            value = (int)(win->m_hAdjust->value+0.5);
-            dir = wxHORIZONTAL;
-        }
-        if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
-        {
-            value = (int)(win->m_vAdjust->value+0.5);
-            dir = wxVERTICAL;
-        }
-
-        wxScrollWinEvent event( command, value, dir );
-        event.SetEventObject( win );
-        win->GetEventHandler()->ProcessEvent( event );
+        win->m_isScrolling = false;
+        // Hook up handler to send thumb release event after this emission is finished.
+        // To allow setting scroll position from event handler, sending event must
+        // be deferred until after the GtkRange handler for this signal has run
+        g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
      }
  
      }
  
-    win->m_isScrolling = false;
-
-    return FALSE;
-}
-}
-
-// ----------------------------------------------------------------------------
-// this wxWindowBase function is implemented here (in platform-specific file)
-// because it is static and so couldn't be made virtual
-// ----------------------------------------------------------------------------
-
-wxWindow *wxWindowBase::DoFindFocus()
-{
-    // the cast is necessary when we compile in wxUniversal mode
-    return (wxWindow *)g_focusWindow;
+    return false;
  }
  
  //-----------------------------------------------------------------------------
  // "realize" from m_widget
  //-----------------------------------------------------------------------------
  
  }
  
  //-----------------------------------------------------------------------------
  // "realize" from m_widget
  //-----------------------------------------------------------------------------
  
-/* We cannot set colours and fonts before the widget has
-   been realized, so we do this directly after realization. */
-
-extern "C" {
-static gint
-gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
+static void
+gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
  {
  {
-    DEBUG_MAIN_THREAD
-
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
      if (win->m_imData)
      {
      if (win->m_imData)
      {
-        GtkPizza *pizza = GTK_PIZZA( m_widget );
          gtk_im_context_set_client_window( win->m_imData->context,
          gtk_im_context_set_client_window( win->m_imData->context,
-                                          pizza->bin_window );
+                                          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 );
      }
  
      wxWindowCreateEvent event( win );
      event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
-
-    return FALSE;
-}
+    win->GTKProcessEvent( event );
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
-// "size_allocate"
+// "size_allocate" from m_wxwindow or m_widget
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-extern "C" {
-static
-void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
-                               GtkAllocation *WXUNUSED(alloc),
-                               wxWindow *win )
+static void
+size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
  {
  {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasScrolling) return;
-
-    int client_width = 0;
-    int client_height = 0;
-    win->GetClientSize( &client_width, &client_height );
-    if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
-        return;
-
-    win->m_oldClientWidth = client_width;
-    win->m_oldClientHeight = client_height;
-
-    if (!win->m_nativeSizeEvent)
+    int w = alloc->width;
+    int h = alloc->height;
+    if (win->m_wxwindow)
      {
      {
-        wxSizeEvent event( win->GetSize(), win->GetId() );
-        event.SetEventObject( win );
-        win->GetEventHandler()->ProcessEvent( event );
+        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;
+        if (w < 0) w = 0;
+        if (h < 0) h = 0;
+    }
+    if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
+    {
+        win->m_oldClientWidth  = w;
+        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;
+        if (!win->m_nativeSizeEvent)
+        {
+            wxSizeEvent event(win->GetSize(), win->GetId());
+            event.SetEventObject(win);
+            win->GTKProcessEvent(event);
+        }
      }
  }
      }
  }
-}
-
-
-#ifdef HAVE_XIM
-    #define WXUNUSED_UNLESS_XIM(param)  param
-#else
-    #define WXUNUSED_UNLESS_XIM(param)  WXUNUSED(param)
-#endif
  
  
-/* Resize XIM window */
+//-----------------------------------------------------------------------------
+// "grab_broken"
+//-----------------------------------------------------------------------------
  
  
-extern "C" {
-static
-void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
-                                 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
-                                 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
+#if GTK_CHECK_VERSION(2, 8, 0)
+static gboolean
+gtk_window_grab_broken( GtkWidget*,
+                        GdkEventGrabBroken *event,
+                        wxWindow *win )
  {
  {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-#ifdef HAVE_XIM
-    if (!win->m_ic)
-        return;
-
-    if  (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
+    // Mouse capture has been lost involuntarily, notify the application
+    if(!event->keyboard && wxWindow::GetCapture() == win)
      {
      {
-        gint width, height;
-
-        gdk_window_get_size (widget->window, &width, &height);
-        win->m_icattr->preedit_area.width = width;
-        win->m_icattr->preedit_area.height = height;
-        gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
+        wxMouseCaptureLostEvent evt( win->GetId() );
+        evt.SetEventObject( win );
+        win->HandleWindowEvent( evt );
      }
      }
-#endif // HAVE_XIM
-}
+    return false;
  }
  }
+#endif
  
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
-// "realize" from m_wxwindow
+// "style_set"
  //-----------------------------------------------------------------------------
  
  //-----------------------------------------------------------------------------
  
-/* Initialize XIM support */
-
-extern "C" {
-static gint
-gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
-                                wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
+static
+void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
+                               GtkStyle *previous_style,
+                               wxWindow* win )
  {
  {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-#ifdef HAVE_XIM
-    if (win->m_ic) return FALSE;
-    if (!widget) return FALSE;
-    if (!gdk_im_ready()) return FALSE;
-
-    win->m_icattr = gdk_ic_attr_new();
-    if (!win->m_icattr) return FALSE;
-
-    gint width, height;
-    GdkEventMask mask;
-    GdkColormap *colormap;
-    GdkICAttr *attr = win->m_icattr;
-    unsigned attrmask = GDK_IC_ALL_REQ;
-    GdkIMStyle style;
-    GdkIMStyle supported_style = (GdkIMStyle)
-                                  (GDK_IM_PREEDIT_NONE |
-                                   GDK_IM_PREEDIT_NOTHING |
-                                   GDK_IM_PREEDIT_POSITION |
-                                   GDK_IM_STATUS_NONE |
-                                   GDK_IM_STATUS_NOTHING);
+    if (win && previous_style)
+    {
+        wxSysColourChangedEvent event;
+        event.SetEventObject(win);
  
  
-    if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
-        supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
+        win->GTKProcessEvent( event );
+    }
+}
  
  
-    attr->style = style = gdk_im_decide_style (supported_style);
-    attr->client_window = widget->window;
+} // extern "C"
  
  
-    if ((colormap = gtk_widget_get_colormap (widget)) !=
-            gtk_widget_get_default_colormap ())
+// Helper to suspend colour change event event processing while we change a widget's style
+class wxSuspendStyleEvents
+{
+public:
+    wxSuspendStyleEvents(wxWindow* win)
      {
      {
-        attrmask |= GDK_IC_PREEDIT_COLORMAP;
-        attr->preedit_colormap = colormap;
+        m_win = NULL;
+        if (win->m_wxwindow && win->IsTopLevel())
+        {
+            m_win = win;
+            g_signal_handlers_block_by_func(
+                m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
+        }
      }
      }
-
-    attrmask |= GDK_IC_PREEDIT_FOREGROUND;
-    attrmask |= GDK_IC_PREEDIT_BACKGROUND;
-    attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
-    attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
-
-    switch (style & GDK_IM_PREEDIT_MASK)
+    ~wxSuspendStyleEvents()
      {
      {
-        case GDK_IM_PREEDIT_POSITION:
-            if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
-            {
-                g_warning ("over-the-spot style requires fontset");
-                break;
-            }
-
-            gdk_window_get_size (widget->window, &width, &height);
-
-            attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
-            attr->spot_location.x = 0;
-            attr->spot_location.y = height;
-            attr->preedit_area.x = 0;
-            attr->preedit_area.y = 0;
-            attr->preedit_area.width = width;
-            attr->preedit_area.height = height;
-            attr->preedit_fontset = widget->style->font;
-
-            break;
+        if (m_win)
+            g_signal_handlers_unblock_by_func(
+                m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
      }
  
      }
  
-      win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
-
-      if (win->m_ic == NULL)
-          g_warning ("Can't create input context.");
-      else
-      {
-          mask = gdk_window_get_events (widget->window);
-          mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
-          gdk_window_set_events (widget->window, mask);
+    wxWindow* m_win;
+};
  
  
-          if (GTK_WIDGET_HAS_FOCUS(widget))
-              gdk_im_begin (win->m_ic, widget->window);
-      }
-#endif // HAVE_XIM
+// ----------------------------------------------------------------------------
+// this wxWindowBase function is implemented here (in platform-specific file)
+// because it is static and so couldn't be made virtual
+// ----------------------------------------------------------------------------
  
  
-    return FALSE;
-}
+wxWindow *wxWindowBase::DoFindFocus()
+{
+    wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
+    // the cast is necessary when we compile in wxUniversal mode
+    return wx_static_cast(wxWindow*, focus);
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
@@ -2435,16 +1899,14 @@ static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
  {
      /* the window might have been scrolled already, do we
         have to adapt the position */
  {
      /* the window might have been scrolled already, do we
         have to adapt the position */
-    GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
-    child->m_x += pizza->xoffset;
-    child->m_y += pizza->yoffset;
+    wxPizza* pizza = WX_PIZZA(parent->m_wxwindow);
+    child->m_x += pizza->m_scroll_x;
+    child->m_y += pizza->m_scroll_y;
  
  
-    gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
-                     GTK_WIDGET(child->m_widget),
-                     child->m_x,
-                     child->m_y,
-                     child->m_width,
-                     child->m_height );
+    gtk_widget_set_size_request(
+        child->m_widget, child->m_width, child->m_height);
+    gtk_fixed_put(
+        GTK_FIXED(parent->m_wxwindow), child->m_widget, child->m_x, child->m_y);
  }
  
  //-----------------------------------------------------------------------------
  }
  
  //-----------------------------------------------------------------------------
@@ -2472,6 +1934,8 @@ wxMouseState wxGetMouseState()
      ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
      ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
      ms.SetRightDown(mask & GDK_BUTTON3_MASK);
      ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
      ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
      ms.SetRightDown(mask & GDK_BUTTON3_MASK);
+    ms.SetAux1Down(mask & GDK_BUTTON4_MASK);
+    ms.SetAux2Down(mask & GDK_BUTTON5_MASK);
  
      ms.SetControlDown(mask & GDK_CONTROL_MASK);
      ms.SetShiftDown(mask & GDK_SHIFT_MASK);
  
      ms.SetControlDown(mask & GDK_CONTROL_MASK);
      ms.SetShiftDown(mask & GDK_SHIFT_MASK);
@@ -2506,30 +1970,28 @@ void wxWindowGTK::Init()
      m_width = 0;
      m_height = 0;
  
      m_width = 0;
      m_height = 0;
  
-    m_sizeSet = false;
      m_hasVMT = false;
      m_hasVMT = false;
-    m_needParent = true;
      m_isBeingDeleted = false;
  
      m_isBeingDeleted = false;
  
+    m_showOnIdle= false;
+
      m_noExpose = false;
      m_nativeSizeEvent = false;
  
      m_noExpose = false;
      m_nativeSizeEvent = false;
  
-    m_hasScrolling = false;
      m_isScrolling = false;
      m_isScrolling = false;
+    m_mouseButtonDown = false;
+
+    // initialize scrolling stuff
+    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+    {
+        m_scrollBar[dir] = NULL;
+        m_scrollPos[dir] = 0;
+    }
  
  
-    m_hAdjust = (GtkAdjustment*) NULL;
-    m_vAdjust = (GtkAdjustment*) NULL;
-    m_oldHorizontalPos =
-    m_oldVerticalPos = 0.0;
      m_oldClientWidth =
      m_oldClientHeight = 0;
  
      m_oldClientWidth =
      m_oldClientHeight = 0;
  
-    m_resizing = false;
-
-    m_insertCallback = (wxInsertChildFunction) NULL;
-
-    m_acceptsFocus = false;
-    m_hasFocus = false;
+    m_insertCallback = wxInsertChildInWindow;
  
      m_clipPaintRegion = false;
  
  
      m_clipPaintRegion = false;
  
@@ -2565,6 +2027,11 @@ bool wxWindowGTK::Create( wxWindow *parent,
                            long style,
                            const wxString &name  )
  {
                            long style,
                            const wxString &name  )
  {
+    // Get default border
+    wxBorder border = GetBorder(style);
+    style &= ~wxBORDER_MASK;
+    style |= border;
+
      if (!PreCreation( parent, pos, size ) ||
          !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
      {
      if (!PreCreation( parent, pos, size ) ||
          !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
      {
@@ -2572,93 +2039,85 @@ bool wxWindowGTK::Create( wxWindow *parent,
          return false;
      }
  
          return false;
      }
  
-    m_insertCallback = wxInsertChildInWindow;
  
  
-    m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
-    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
+    m_wxwindow = wxPizza::New(m_windowStyle);
+    if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
+        m_widget = m_wxwindow;
+    else
+    {
+        m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
+
+        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
  
  
-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
+        scroll_class->scrollbar_spacing = 0;
  
  
-    GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-    scroll_class->scrollbar_spacing = 0;
+        // There is a conflict with default bindings at GTK+
+        // level between scrolled windows and notebooks both of which want to use
+        // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
+        // direction and notebooks for changing pages -- we decide that if we don't
+        // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
+        // means we can get working keyboard navigation in notebooks
+        if ( !HasFlag(wxHSCROLL) )
+        {
+            GtkBindingSet *
+                bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
+            if ( bindings )
+            {
+                gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
+                gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
+            }
+        }
  
  
-    gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        if (HasFlag(wxALWAYS_SHOW_SB))
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
  
  
-    m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
-    m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
+            scrolledWindow->hscrollbar_visible = TRUE;
+            scrolledWindow->vscrollbar_visible = TRUE;
+        }
+        else
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        }
  
  
-    m_wxwindow = gtk_pizza_new();
+        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
+        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
  
  
-#ifndef __WXUNIVERSAL__
-    GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+        gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
  
  
-    if (HasFlag(wxRAISED_BORDER))
-    {
-        gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
-    }
-    else if (HasFlag(wxSUNKEN_BORDER))
-    {
-        gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
-    }
-    else if (HasFlag(wxSIMPLE_BORDER))
-    {
-        gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
+        // connect various scroll-related events
+        for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+        {
+            // these handlers block mouse events to any window during scrolling
+            // such as motion events and prevent GTK and wxWidgets from fighting
+            // over where the slider should be
+            g_signal_connect(m_scrollBar[dir], "button_press_event",
+                         G_CALLBACK(gtk_scrollbar_button_press_event), this);
+            g_signal_connect(m_scrollBar[dir], "button_release_event",
+                         G_CALLBACK(gtk_scrollbar_button_release_event), this);
+
+            gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
+                                G_CALLBACK(gtk_scrollbar_event_after), this);
+            g_signal_handler_block(m_scrollBar[dir], handler_id);
+
+            // these handlers get notified when scrollbar slider moves
+            g_signal_connect_after(m_scrollBar[dir], "value_changed",
+                         G_CALLBACK(gtk_scrollbar_value_changed), this);
+        }
+
+        gtk_widget_show( m_wxwindow );
      }
      }
-    else
-    {
-        gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
-    }
-#endif // __WXUNIVERSAL__
-
-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
-
-    GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-    m_acceptsFocus = true;
-
-    // I _really_ don't want scrollbars in the beginning
-    m_vAdjust->lower = 0.0;
-    m_vAdjust->upper = 1.0;
-    m_vAdjust->value = 0.0;
-    m_vAdjust->step_increment = 1.0;
-    m_vAdjust->page_increment = 1.0;
-    m_vAdjust->page_size = 5.0;
-    g_signal_emit_by_name (m_vAdjust, "changed");
-    m_hAdjust->lower = 0.0;
-    m_hAdjust->upper = 1.0;
-    m_hAdjust->value = 0.0;
-    m_hAdjust->step_increment = 1.0;
-    m_hAdjust->page_increment = 1.0;
-    m_hAdjust->page_size = 5.0;
-    g_signal_emit_by_name (m_hAdjust, "changed");
-
-    // these handlers block mouse events to any window during scrolling such as
-    // motion events and prevent GTK and wxWidgets from fighting over where the
-    // slider should be
-    g_signal_connect (scrolledWindow->vscrollbar, "button_press_event",
-                      G_CALLBACK (gtk_scrollbar_button_press_callback), this);
-    g_signal_connect (scrolledWindow->hscrollbar, "button_press_event",
-                      G_CALLBACK (gtk_scrollbar_button_press_callback), this);
-    g_signal_connect (scrolledWindow->vscrollbar, "button_release_event",
-                      G_CALLBACK (gtk_scrollbar_button_release_callback), this);
-    g_signal_connect (scrolledWindow->hscrollbar, "button_release_event",
-                      G_CALLBACK (gtk_scrollbar_button_release_callback), this);
-
-    // these handlers get notified when screen updates are required either when
-    // scrolling or when the window size (and therefore scrollbar configuration)
-    // has changed
-
-    g_signal_connect (m_hAdjust, "value_changed",
-                      G_CALLBACK (gtk_window_hscroll_callback), this);
-    g_signal_connect (m_vAdjust, "value_changed",
-                      G_CALLBACK (gtk_window_vscroll_callback), this);
-
-    gtk_widget_show( m_wxwindow );
  
      if (m_parent)
          m_parent->DoAddChild( this );
  
      m_focusWidget = m_wxwindow;
  
  
      if (m_parent)
          m_parent->DoAddChild( this );
  
      m_focusWidget = m_wxwindow;
  
+    SetCanFocus(AcceptsFocus());
+
      PostCreation();
  
      return true;
      PostCreation();
  
      return true;
@@ -2668,11 +2127,13 @@ wxWindowGTK::~wxWindowGTK()
  {
      SendDestroyEvent();
  
  {
      SendDestroyEvent();
  
-    if (g_focusWindow == this)
-        g_focusWindow = NULL;
+    if (gs_currentFocus == this)
+        gs_currentFocus = NULL;
+    if (gs_pendingFocus == this)
+        gs_pendingFocus = NULL;
  
  
-    if ( g_delayedFocus == this )
-        g_delayedFocus = NULL;
+    if ( gs_deferredFocusOut == this )
+        gs_deferredFocusOut = NULL;
  
      m_isBeingDeleted = true;
      m_hasVMT = false;
  
      m_isBeingDeleted = true;
      m_hasVMT = false;
@@ -2695,17 +2156,10 @@ wxWindowGTK::~wxWindowGTK()
      if (m_widget)
          Show( false );
  
      if (m_widget)
          Show( false );
  
-#ifdef HAVE_XIM
-    if (m_ic)
-        gdk_ic_destroy (m_ic);
-    if (m_icattr)
-        gdk_ic_attr_destroy (m_icattr);
-#endif
-
      // 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;
  
-    if (m_wxwindow)
+    if (m_wxwindow && (m_wxwindow != m_widget))
      {
          gtk_widget_destroy( m_wxwindow );
          m_wxwindow = (GtkWidget*) NULL;
      {
          gtk_widget_destroy( m_wxwindow );
          m_wxwindow = (GtkWidget*) NULL;
@@ -2720,7 +2174,10 @@ wxWindowGTK::~wxWindowGTK()
  
  bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
  {
  
  bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
  {
-    wxCHECK_MSG( !m_needParent || parent, false, wxT("Need complete parent.") );
+    if ( GTKNeedsParent() )
+    {
+        wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
+    }
  
      // Use either the given size, or the default if -1 is given.
      // See wxWindowBase for these functions.
  
      // Use either the given size, or the default if -1 is given.
      // See wxWindowBase for these functions.
@@ -2743,12 +2200,11 @@ void wxWindowGTK::PostCreation()
          {
              // these get reported to wxWidgets -> wxPaintEvent
  
          {
              // these get reported to wxWidgets -> wxPaintEvent
  
-            gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
-
              g_signal_connect (m_wxwindow, "expose_event",
                                G_CALLBACK (gtk_window_expose_callback), this);
  
              g_signal_connect (m_wxwindow, "expose_event",
                                G_CALLBACK (gtk_window_expose_callback), this);
  
-            gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
+            if (GetLayoutDirection() == wxLayout_LeftToRight)
+                gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
          }
  
          // Create input method handler
          }
  
          // Create input method handler
@@ -2760,9 +2216,14 @@ 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);
  
-        // these are called when the "sunken" or "raised" borders are drawn
-        g_signal_connect (m_widget, "expose_event",
-                          G_CALLBACK (gtk_window_own_expose_callback), this);
+        // border drawing
+#ifndef __WXUNIVERSAL__
+        if (HasFlag(wxPizza::BORDER_STYLES))
+        {
+            g_signal_connect(m_widget, "expose_event",
+                G_CALLBACK(expose_event_border), this);
+        }
+#endif
      }
  
      // focus handling
      }
  
      // focus handling
@@ -2788,6 +2249,14 @@ void wxWindowGTK::PostCreation()
          }
      }
  
          }
      }
  
+    if ( !AcceptsFocusFromKeyboard() )
+    {
+        SetCanFocus(false);
+
+        g_signal_connect(m_widget, "focus",
+                            G_CALLBACK(wx_window_focus_callback), this);
+    }
+
      // connect to the various key and mouse handlers
  
      GtkWidget *connect_widget = GetConnectWidget();
      // connect to the various key and mouse handlers
  
      GtkWidget *connect_widget = GetConnectWidget();
@@ -2799,30 +2268,46 @@ void wxWindowGTK::PostCreation()
      g_signal_connect (connect_widget, "realize",
                        G_CALLBACK (gtk_window_realized_callback), this);
  
      g_signal_connect (connect_widget, "realize",
                        G_CALLBACK (gtk_window_realized_callback), this);
  
-    if (m_wxwindow)
+    if (!IsTopLevel())
      {
      {
-        // Catch native resize events
-        g_signal_connect (m_wxwindow, "size_allocate",
-                          G_CALLBACK (gtk_window_size_callback), this);
-
-        // Initialize XIM support
-        g_signal_connect (m_wxwindow, "realize",
-                          G_CALLBACK (gtk_wxwindow_realized_callback), this);
-
-        // And resize XIM window
-        g_signal_connect (m_wxwindow, "size_allocate",
-                          G_CALLBACK (gtk_wxwindow_size_callback), this);
+        g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
+            G_CALLBACK(size_allocate), this);
      }
  
      }
  
-    if (GTK_IS_COMBO(m_widget))
+    if (m_wxwindow)
      {
      {
-        GtkCombo *gcombo = GTK_COMBO(m_widget);
+#if GTK_CHECK_VERSION(2, 8, 0)
+        if (!gtk_check_version(2,8,0))
+        {
+            // Make sure we can notify the app when mouse capture is lost
+            g_signal_connect (m_wxwindow, "grab_broken_event",
+                          G_CALLBACK (gtk_window_grab_broken), this);
+        }
+#endif
+    }
  
  
-        g_signal_connect (gcombo->entry, "size_request",
-                          G_CALLBACK (wxgtk_combo_size_request_callback),
-                          this);
+    if ( connect_widget != m_wxwindow )
+    {
+#if GTK_CHECK_VERSION(2, 8, 0)
+        if (!gtk_check_version(2,8,0))
+        {
+            // Make sure we can notify app code when mouse capture is lost
+            g_signal_connect (connect_widget, "grab_broken_event",
+                        G_CALLBACK (gtk_window_grab_broken), this);
+        }
+#endif
      }
      }
-    else
+
+#ifdef GTK_IS_FILE_CHOOSER_BUTTON
+    if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
+    {
+        // If we connect to the "size_request" signal of a GtkFileChooserButton
+        // then that control won't be sized properly when placed inside sizers
+        // (this can be tested removing this elseif and running XRC or WIDGETS samples)
+        // FIXME: what should be done here ?
+    } else
+#endif
+    if ( !IsTopLevel() ) // top level windows use their own callback
      {
          // This is needed if we want to add our windows into native
          // GTK controls, such as the toolbar. With this callback, the
      {
          // This is needed if we want to add our windows into native
          // GTK controls, such as the toolbar. With this callback, the
@@ -2837,6 +2322,8 @@ void wxWindowGTK::PostCreation()
  
      m_hasVMT = true;
  
  
      m_hasVMT = true;
  
+    SetLayoutDirection(wxLayout_Default);
+
      // unless the window was created initially hidden (i.e. Hide() had been
      // called before Create()), we should show it at GTK+ level as well
      if ( IsShown() )
      // unless the window was created initially hidden (i.e. Hide() had been
      // called before Create()), we should show it at GTK+ level as well
      if ( IsShown() )
@@ -2856,13 +2343,17 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
      g_signal_connect (widget, "motion_notify_event",
                        G_CALLBACK (gtk_window_motion_notify_callback), this);
      g_signal_connect (widget, "scroll_event",
      g_signal_connect (widget, "motion_notify_event",
                        G_CALLBACK (gtk_window_motion_notify_callback), this);
      g_signal_connect (widget, "scroll_event",
-                      G_CALLBACK (gtk_window_wheel_callback), this);
+                      G_CALLBACK (window_scroll_event), this);
      g_signal_connect (widget, "popup_menu",
                       G_CALLBACK (wxgtk_window_popup_menu_callback), this);
      g_signal_connect (widget, "enter_notify_event",
                        G_CALLBACK (gtk_window_enter_callback), this);
      g_signal_connect (widget, "leave_notify_event",
                        G_CALLBACK (gtk_window_leave_callback), this);
      g_signal_connect (widget, "popup_menu",
                       G_CALLBACK (wxgtk_window_popup_menu_callback), this);
      g_signal_connect (widget, "enter_notify_event",
                        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()
@@ -2876,7 +2367,26 @@ bool wxWindowGTK::Destroy()
  
  void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
  {
  
  void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
  {
-    gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
+    gtk_widget_set_size_request(m_widget, width, height);
+    // inform the parent to perform the move
+    WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
+}
+
+void wxWindowGTK::ConstrainSize()
+{
+#ifdef __WXGPE__
+    // GPE's window manager doesn't like size hints at all, esp. when the user
+    // has to use the virtual keyboard, so don't constrain size there
+    if (!IsTopLevel())
+#endif
+    {
+        const wxSize minSize = GetMinSize();
+        const wxSize maxSize = GetMaxSize();
+        if (minSize.x > 0 && m_width  < minSize.x) m_width  = minSize.x;
+        if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
+        if (maxSize.x > 0 && m_width  > maxSize.x) m_width  = maxSize.x;
+        if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
+    }
  }
  
  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 )
@@ -2884,13 +2394,6 @@ 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") );
  
      wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
      wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
  
-/*
-    printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
-*/
-
-    if (m_resizing) return; /* I don't like recursions */
-    m_resizing = true;
-
      int currentX, currentY;
      GetPosition(&currentX, &currentY);
      if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
      int currentX, currentY;
      GetPosition(&currentX, &currentY);
      if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
@@ -2899,53 +2402,28 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
          y = currentY;
      AdjustForParentClientOrigin(x, y, sizeFlags);
  
          y = currentY;
      AdjustForParentClientOrigin(x, y, sizeFlags);
  
-    if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
+    // calculate the best size if we should auto size the window
+    if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
+         ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
      {
      {
-        /* don't set the size for children of wxNotebook, just take the values. */
-        m_x = x;
-        m_y = y;
-        m_width = width;
-        m_height = height;
+        const wxSize sizeBest = GetBestSize();
+        if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
+            width = sizeBest.x;
+        if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
+            height = sizeBest.y;
      }
      }
-    else
-    {
-        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
-        if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
-        {
-            if (x != -1) m_x = x + pizza->xoffset;
-            if (y != -1) m_y = y + pizza->yoffset;
-        }
-        else
-        {
-            m_x = x + pizza->xoffset;
-            m_y = y + pizza->yoffset;
-        }
-
-        // calculate the best size if we should auto size the window
-        if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
-                ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
-        {
-            const wxSize sizeBest = GetBestSize();
-            if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
-                width = sizeBest.x;
-            if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
-                height = sizeBest.y;
-        }
  
  
-        if (width != -1)
-            m_width = width;
-        if (height != -1)
-            m_height = height;
-
-        int minWidth = GetMinWidth(),
-            minHeight = GetMinHeight(),
-            maxWidth = GetMaxWidth(),
-            maxHeight = GetMaxHeight();
+    const wxSize oldSize(m_width, m_height);
+    if (width != -1)
+        m_width = width;
+    if (height != -1)
+        m_height = height;
  
  
-        if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
-        if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
-        if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
-        if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
+    if (m_parent->m_wxwindow)
+    {
+        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 left_border = 0;
          int right_border = 0;
@@ -2963,46 +2441,61 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
                  right_border += default_border->right;
                  top_border += default_border->top;
                  bottom_border += default_border->bottom;
                  right_border += default_border->right;
                  top_border += default_border->top;
                  bottom_border += default_border->bottom;
-                g_free( default_border );
+                gtk_border_free( default_border );
              }
          }
  
              }
          }
  
-        DoMoveWindow( m_x-top_border,
-                      m_y-left_border,
+        DoMoveWindow( m_x - left_border,
+                      m_y - top_border,
                        m_width+left_border+right_border,
                        m_height+top_border+bottom_border );
      }
  
                        m_width+left_border+right_border,
                        m_height+top_border+bottom_border );
      }
  
-    if (m_hasScrolling)
+    if (m_width != oldSize.x || m_height != oldSize.y)
      {
      {
-        /* Sometimes the client area changes size without the
-           whole windows's size changing, but if the whole
-           windows's size doesn't change, no wxSizeEvent will
-           normally be sent. Here we add an extra test if
-           the client test has been changed and this will
-           be used then. */
+        // update these variables to keep size_allocate handler
+        // from sending another size event for this change
          GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
          GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
-    }
  
  
-/*
-    wxPrintf( "OnSize sent from " );
-    if (GetClassInfo() && GetClassInfo()->GetClassName())
-        wxPrintf( GetClassInfo()->GetClassName() );
-    wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
-*/
+        gtk_widget_queue_resize(m_widget);
+        if (!m_nativeSizeEvent)
+        {
+            wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+            event.SetEventObject( this );
+            HandleWindowEvent( event );
+        }
+    }
+}
  
  
-    if (!m_nativeSizeEvent)
+bool wxWindowGTK::GtkShowFromOnIdle()
+{
+    if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
      {
      {
-        wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-        event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent( event );
+        GtkAllocation alloc;
+        alloc.x = m_x;
+        alloc.y = m_y;
+        alloc.width = m_width;
+        alloc.height = m_height;
+        gtk_widget_size_allocate( m_widget, &alloc );
+        gtk_widget_show( m_widget );
+        wxShowEvent eventShow(GetId(), true);
+        eventShow.SetEventObject(this);
+        HandleWindowEvent(eventShow);
+        m_showOnIdle = false;
+        return true;
      }
  
      }
  
-    m_resizing = false;
+    return false;
  }
  
  void wxWindowGTK::OnInternalIdle()
  {
  }
  
  void wxWindowGTK::OnInternalIdle()
  {
+    if ( gs_deferredFocusOut )
+        GTKHandleDeferredFocusOut();
+
+    // Check if we have to show window now
+    if (GtkShowFromOnIdle()) return;
+
      if ( m_dirtyTabOrder )
      {
          m_dirtyTabOrder = false;
      if ( m_dirtyTabOrder )
      {
          m_dirtyTabOrder = false;
@@ -3017,9 +2510,6 @@ void wxWindowGTK::OnInternalIdle()
          m_needsStyleChange = false;
      }
  
          m_needsStyleChange = false;
      }
  
-    // Update invalidated regions.
-    GtkUpdate();
-
      wxCursor cursor = m_cursor;
      if (g_globalCursor.Ok()) cursor = g_globalCursor;
  
      wxCursor cursor = m_cursor;
      if (g_globalCursor.Ok()) cursor = g_globalCursor;
  
@@ -3030,9 +2520,9 @@ void wxWindowGTK::OnInternalIdle()
             windows above so that checking for the current cursor is
             not possible. */
  
             windows above so that checking for the current cursor is
             not possible. */
  
-        if (m_wxwindow)
+        if (m_wxwindow && (m_wxwindow != m_widget))
          {
          {
-            GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
+            GdkWindow *window = m_wxwindow->window;
              if (window)
                  gdk_window_set_cursor( window, cursor.GetCursor() );
  
              if (window)
                  gdk_window_set_cursor( window, cursor.GetCursor() );
  
@@ -3044,17 +2534,15 @@ void wxWindowGTK::OnInternalIdle()
                  gdk_window_set_cursor( window, cursor.GetCursor() );
  
          }
                  gdk_window_set_cursor( window, cursor.GetCursor() );
  
          }
-        else
+        else if ( m_widget )
          {
          {
-
              GdkWindow *window = m_widget->window;
              GdkWindow *window = m_widget->window;
-            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+            if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
                 gdk_window_set_cursor( window, cursor.GetCursor() );
                 gdk_window_set_cursor( window, cursor.GetCursor() );
-
          }
      }
  
          }
      }
  
-    if (wxUpdateUIEvent::CanUpdate(this))
+    if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
          UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
  }
  
          UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
  }
  
@@ -3070,135 +2558,49 @@ void wxWindowGTK::DoSetClientSize( int width, int height )
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (!m_wxwindow)
-    {
-        SetSize( width, height );
-    }
-    else
-    {
-        int dw = 0;
-        int dh = 0;
-
-#ifndef __WXUNIVERSAL__
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            /* when using GTK 1.2 we set the shadow border size to 2 */
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
-        {
-            /* when using GTK 1.2 we set the simple border size to 1 */
-            dw += 1 * 2;
-            dh += 1 * 2;
-        }
-#endif // __WXUNIVERSAL__
-
-        if (m_hasScrolling)
-        {
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-
-            GtkRequisition vscroll_req;
-            vscroll_req.width = 2;
-            vscroll_req.height = 2;
-            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
-                (scroll_window->vscrollbar, &vscroll_req );
-
-            GtkRequisition hscroll_req;
-            hscroll_req.width = 2;
-            hscroll_req.height = 2;
-            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
-                (scroll_window->hscrollbar, &hscroll_req );
-
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-
-            if (scroll_window->vscrollbar_visible)
-            {
-                dw += vscroll_req.width;
-                dw += scroll_class->scrollbar_spacing;
-            }
-
-            if (scroll_window->hscrollbar_visible)
-            {
-                dh += hscroll_req.height;
-                dh += scroll_class->scrollbar_spacing;
-            }
-        }
-
-       SetSize( width+dw, height+dh );
-    }
+    const wxSize size = GetSize();
+    const wxSize clientSize = GetClientSize();
+    SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
  }
  
  void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
  }
  
  void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
  {
      wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
-    if (!m_wxwindow)
-    {
-        if (width) (*width) = m_width;
-        if (height) (*height) = m_height;
-    }
-    else
-    {
-        int dw = 0;
-        int dh = 0;
-
-#ifndef __WXUNIVERSAL__
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            /* when using GTK 1.2 we set the shadow border size to 2 */
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
-        {
-            /* when using GTK 1.2 we set the simple border size to 1 */
-            dw += 1 * 2;
-            dh += 1 * 2;
-        }
-#endif // __WXUNIVERSAL__
+    int w = m_width;
+    int h = m_height;
  
  
-        if (m_hasScrolling)
+    if (m_wxwindow)
+    {
+        // if window is scrollable, account for scrollbars
+        for (int i = 0; i < 2 && m_scrollBar[i]; i++)
          {
          {
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-
-            GtkRequisition vscroll_req;
-            vscroll_req.width = 2;
-            vscroll_req.height = 2;
-            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
-                (scroll_window->vscrollbar, &vscroll_req );
-
-            GtkRequisition hscroll_req;
-            hscroll_req.width = 2;
-            hscroll_req.height = 2;
-            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
-                (scroll_window->hscrollbar, &hscroll_req );
-
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-
-            if (scroll_window->vscrollbar_visible)
-            {
-                dw += vscroll_req.width;
-                dw += scroll_class->scrollbar_spacing;
-            }
-
-            if (scroll_window->hscrollbar_visible)
+            GtkRequisition req;
+            GtkAdjustment* adj = gtk_range_get_adjustment(m_scrollBar[i]);
+            // if scrollbar enabled
+            if (adj->upper > adj->page_size)
              {
              {
-                dh += hscroll_req.height;
-                dh += scroll_class->scrollbar_spacing;
+                gtk_widget_size_request(GTK_WIDGET(m_scrollBar[i]), &req);
+                if (i == ScrollDir_Horz)
+                    h -= req.height;
+                else
+                    w -= req.width;
              }
          }
  
              }
          }
  
-        if (width) (*width) = m_width - dw;
-        if (height) (*height) = m_height - dh;
+        int border_x, border_y;
+        WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
+        w -= 2 * border_x;
+        h -= 2 * border_y;
+
+        if (w < 0)
+            w = 0;
+        if (h < 0)
+            h = 0;
      }
  
      }
  
-/*
-    printf( "GetClientSize, name %s ", GetName().c_str() );
-    if (width) printf( " width = %d", (*width) );
-    if (height) printf( " height = %d", (*height) );
-    printf( "\n" );
-*/
+    if (width) *width = w;
+    if (height) *height = h;
  }
  
  void wxWindowGTK::DoGetPosition( int *x, int *y ) const
  }
  
  void wxWindowGTK::DoGetPosition( int *x, int *y ) const
@@ -3207,11 +2609,33 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const
  
      int dx = 0;
      int dy = 0;
  
      int dx = 0;
      int dy = 0;
-    if (m_parent && m_parent->m_wxwindow)
+    if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
+    {
+        wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
+        dx = pizza->m_scroll_x;
+        dy = pizza->m_scroll_y;
+    }
+
+    if (m_x == -1 && m_y == -1)
      {
      {
-        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
-        dx = pizza->xoffset;
-        dy = pizza->yoffset;
+        GdkWindow *source = (GdkWindow *) 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);
+
+            wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
+            wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
+        }
      }
  
      if (x) (*x) = m_x - dx;
      }
  
      if (x) (*x) = m_x - dx;
@@ -3226,7 +2650,7 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
  
      GdkWindow *source = (GdkWindow *) NULL;
      if (m_wxwindow)
  
      GdkWindow *source = (GdkWindow *) NULL;
      if (m_wxwindow)
-        source = GTK_PIZZA(m_wxwindow)->bin_window;
+        source = m_wxwindow->window;
      else
          source = m_widget->window;
  
      else
          source = m_widget->window;
  
@@ -3243,7 +2667,15 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
          }
      }
  
          }
      }
  
-    if (x) *x += org_x;
+
+    if (x)
+    {
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            *x = (GetClientSize().x - *x) + org_x;
+        else
+            *x += org_x;
+    }
+
      if (y) *y += org_y;
  }
  
      if (y) *y += org_y;
  }
  
@@ -3255,7 +2687,7 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
  
      GdkWindow *source = (GdkWindow *) NULL;
      if (m_wxwindow)
  
      GdkWindow *source = (GdkWindow *) NULL;
      if (m_wxwindow)
-        source = GTK_PIZZA(m_wxwindow)->bin_window;
+        source = m_wxwindow->window;
      else
          source = m_widget->window;
  
      else
          source = m_widget->window;
  
@@ -3272,7 +2704,13 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
          }
      }
  
          }
      }
  
-    if (x) *x -= org_x;
+    if (x)
+    {
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            *x = (GetClientSize().x - *x) - org_x;
+        else
+            *x -= org_x;
+    }
      if (y) *y -= org_y;
  }
  
      if (y) *y -= org_y;
  }
  
@@ -3286,53 +2724,31 @@ bool wxWindowGTK::Show( bool show )
          return false;
      }
  
          return false;
      }
  
-    if (show)
-        gtk_widget_show( m_widget );
+    if (show && m_showOnIdle)
+    {
+        // deferred
+    }
      else
      else
-        gtk_widget_hide( m_widget );
-
-    wxShowEvent eventShow(GetId(), show);
-    eventShow.SetEventObject(this);
-
-    GetEventHandler()->ProcessEvent(eventShow);
-
-    return true;
-}
-
-static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
-{
-    win->OnParentEnable(enable);
-
-    // Recurse, so that children have the opportunity to Do The Right Thing
-    // and reset colours that have been messed up by a parent's (really ancestor's)
-    // Enable call
-    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
-          node;
-          node = node->GetNext() )
      {
      {
-        wxWindow *child = node->GetData();
-        if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
-            wxWindowNotifyEnable(child, enable);
+        if (show)
+            gtk_widget_show(m_widget);
+        else
+            gtk_widget_hide(m_widget);
+        wxShowEvent eventShow(GetId(), show);
+        eventShow.SetEventObject(this);
+        HandleWindowEvent(eventShow);
      }
      }
+
+    return true;
  }
  
  }
  
-bool wxWindowGTK::Enable( bool enable )
+void wxWindowGTK::DoEnable( bool enable )
  {
  {
-    wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
-
-    if (!wxWindowBase::Enable(enable))
-    {
-        // nothing to do
-        return false;
-    }
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
  
      gtk_widget_set_sensitive( m_widget, enable );
  
      gtk_widget_set_sensitive( m_widget, enable );
-    if ( m_wxwindow )
+    if (m_wxwindow && (m_wxwindow != m_widget))
          gtk_widget_set_sensitive( m_wxwindow, enable );
          gtk_widget_set_sensitive( m_wxwindow, enable );
-
-    wxWindowNotifyEnable(this, enable);
-
-    return true;
  }
  
  int wxWindowGTK::GetCharHeight() const
  }
  
  int wxWindowGTK::GetCharHeight() const
@@ -3342,9 +2758,7 @@ int wxWindowGTK::GetCharHeight() const
      wxFont font = GetFont();
      wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
  
      wxFont font = GetFont();
      wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
  
-    PangoContext *context = NULL;
-    if (m_widget)
-        context = gtk_widget_get_pango_context( m_widget );
+    PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
      if (!context)
          return 0;
  
      if (!context)
          return 0;
@@ -3358,7 +2772,7 @@ int wxWindowGTK::GetCharHeight() const
      PangoRectangle rect;
      pango_layout_line_get_extents(line, NULL, &rect);
  
      PangoRectangle rect;
      pango_layout_line_get_extents(line, NULL, &rect);
  
-    g_object_unref( G_OBJECT( layout ) );
+    g_object_unref (layout);
  
      return (int) PANGO_PIXELS(rect.height);
  }
  
      return (int) PANGO_PIXELS(rect.height);
  }
@@ -3370,9 +2784,7 @@ int wxWindowGTK::GetCharWidth() const
      wxFont font = GetFont();
      wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
  
      wxFont font = GetFont();
      wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
  
-    PangoContext *context = NULL;
-    if (m_widget)
-        context = gtk_widget_get_pango_context( m_widget );
+    PangoContext* context = gtk_widget_get_pango_context(m_widget);
  
      if (!context)
          return 0;
  
      if (!context)
          return 0;
@@ -3386,7 +2798,7 @@ int wxWindowGTK::GetCharWidth() const
      PangoRectangle rect;
      pango_layout_line_get_extents(line, NULL, &rect);
  
      PangoRectangle rect;
      pango_layout_line_get_extents(line, NULL, &rect);
  
-    g_object_unref( G_OBJECT( layout ) );
+    g_object_unref (layout);
  
      return (int) PANGO_PIXELS(rect.width);
  }
  
      return (int) PANGO_PIXELS(rect.width);
  }
@@ -3424,14 +2836,9 @@ void wxWindowGTK::GetTextExtent( const wxString& string,
      PangoLayout *layout = pango_layout_new(context);
      pango_layout_set_font_description(layout, desc);
      {
      PangoLayout *layout = pango_layout_new(context);
      pango_layout_set_font_description(layout, desc);
      {
-#if wxUSE_UNICODE
-        const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
-        pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
-#else
-        const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
-        const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
-        pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
-#endif
+        const wxCharBuffer data = wxGTK_CONV( string );
+        if ( data )
+            pango_layout_set_text(layout, data, strlen(data));
      }
  
      PangoRectangle rect;
      }
  
      PangoRectangle rect;
@@ -3448,67 +2855,213 @@ void wxWindowGTK::GetTextExtent( const wxString& string,
      }
      if (externalLeading) (*externalLeading) = 0;  // ??
  
      }
      if (externalLeading) (*externalLeading) = 0;  // ??
  
-    g_object_unref( G_OBJECT( layout ) );
+    g_object_unref (layout);
  }
  
  }
  
-void wxWindowGTK::SetFocus()
+
+bool wxWindowGTK::GTKHandleFocusIn()
  {
  {
-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-    if ( m_hasFocus )
-    {
-        // don't do anything if we already have focus
-        return;
-    }
+    // Disable default focus handling for custom windows since the default GTK+
+    // handler issues a repaint
+    const bool retval = m_wxwindow ? true : false;
  
  
-    if (m_wxwindow)
+
+    // NB: if there's still unprocessed deferred focus-out event (see
+    //     GTKHandleFocusOut() for explanation), we need to process it first so
+    //     that the order of focus events -- focus-out first, then focus-in
+    //     elsewhere -- is preserved
+    if ( gs_deferredFocusOut )
      {
      {
-        if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
+        if ( GTKNeedsToFilterSameWindowFocus() &&
+             gs_deferredFocusOut == this )
          {
          {
-            gtk_widget_grab_focus (m_wxwindow);
+            // GTK+ focus changed from this wxWindow back to itself, so don't
+            // emit any events at all
+            wxLogTrace(TRACE_FOCUS,
+                       "filtered out spurious focus change within %s(%p, %s)",
+                       GetClassInfo()->GetClassName(), this, GetLabel());
+            gs_deferredFocusOut = NULL;
+            return retval;
          }
          }
+
+        // otherwise we need to send focus-out first
+        wxASSERT_MSG ( gs_deferredFocusOut != this,
+                       "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
+        GTKHandleDeferredFocusOut();
+    }
+
+
+    wxLogTrace(TRACE_FOCUS,
+               "handling focus_in event for %s(%p, %s)",
+               GetClassInfo()->GetClassName(), this, GetLabel());
+
+    if (m_imData)
+        gtk_im_context_focus_in(m_imData->context);
+
+    gs_currentFocus = this;
+    gs_pendingFocus = NULL;
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = GetCaret();
+    if ( caret )
+    {
+        caret->OnSetFocus();
      }
      }
-    else if (m_widget)
+#endif // wxUSE_CARET
+
+    // Notify the parent keeping track of focus for the kbd navigation
+    // purposes that we got it.
+    wxChildFocusEvent eventChildFocus(this);
+    GTKProcessEvent(eventChildFocus);
+
+    wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
+    eventFocus.SetEventObject(this);
+    GTKProcessEvent(eventFocus);
+
+    return retval;
+}
+
+bool wxWindowGTK::GTKHandleFocusOut()
+{
+    // Disable default focus handling for custom windows since the default GTK+
+    // handler issues a repaint
+    const bool retval = m_wxwindow ? true : false;
+
+
+    // NB: If a control is composed of several GtkWidgets and when focus
+    //     changes from one of them to another within the same wxWindow, we get
+    //     a focus-out event followed by focus-in for another GtkWidget owned
+    //     by the same wx control. We don't want to generate two spurious
+    //     wxEVT_SET_FOCUS events in this case, so we defer sending wx events
+    //     from GTKHandleFocusOut() until we know for sure it's not coming back
+    //     (i.e. in GTKHandleFocusIn() or at idle time).
+    if ( GTKNeedsToFilterSameWindowFocus() )
      {
      {
-        if (GTK_IS_CONTAINER(m_widget))
-        {
-            gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
-        }
-        else
-        if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
-        {
+        wxASSERT_MSG( gs_deferredFocusOut == NULL,
+                      "deferred focus out event already pending" );
+        wxLogTrace(TRACE_FOCUS,
+                   "deferring focus_out event for %s(%p, %s)",
+                   GetClassInfo()->GetClassName(), this, GetLabel());
+        gs_deferredFocusOut = this;
+        return retval;
+    }
  
  
-            if (!GTK_WIDGET_REALIZED(m_widget))
-            {
-                // we can't set the focus to the widget now so we remember that
-                // it should be focused and will do it later, during the idle
-                // time, as soon as we can
-                wxLogTrace(TRACE_FOCUS,
-                           _T("Delaying setting focus to %s(%s)"),
-                           GetClassInfo()->GetClassName(), GetLabel().c_str());
-
-                g_delayedFocus = this;
-            }
-            else
-            {
-                wxLogTrace(TRACE_FOCUS,
-                           _T("Setting focus to %s(%s)"),
-                           GetClassInfo()->GetClassName(), GetLabel().c_str());
+    GTKHandleFocusOutNoDeferring();
  
  
-                gtk_widget_grab_focus (m_widget);
-            }
-        }
-        else
-        {
-           wxLogTrace(TRACE_FOCUS,
-                      _T("Can't set focus to %s(%s)"),
-                      GetClassInfo()->GetClassName(), GetLabel().c_str());
-        }
+    return retval;
+}
+
+void wxWindowGTK::GTKHandleFocusOutNoDeferring()
+{
+    wxLogTrace(TRACE_FOCUS,
+               "handling focus_out event for %s(%p, %s)",
+               GetClassInfo()->GetClassName(), this, GetLabel());
+
+    if (m_imData)
+        gtk_im_context_focus_out(m_imData->context);
+
+    if ( gs_currentFocus != this )
+    {
+        // Something is terribly wrong, gs_currentFocus is out of sync with the
+        // real focus. We will reset it to NULL anyway, because after this
+        // focus-out event is handled, one of the following with happen:
+        //
+        // * either focus will go out of the app altogether, in which case
+        //   gs_currentFocus _should_ be NULL
+        //
+        // * or it goes to another control, in which case focus-in event will
+        //   follow immediately and it will set gs_currentFocus to the right
+        //   value
+        wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
+                   GetClassInfo()->GetClassName(), this, GetLabel());
+    }
+    gs_currentFocus = NULL;
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = GetCaret();
+    if ( caret )
+    {
+        caret->OnKillFocus();
+    }
+#endif // wxUSE_CARET
+
+    wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
+    event.SetEventObject( this );
+    GTKProcessEvent( event );
+}
+
+/*static*/
+void wxWindowGTK::GTKHandleDeferredFocusOut()
+{
+    // NB: See GTKHandleFocusOut() for explanation. This function is called
+    //     from either GTKHandleFocusIn() or OnInternalIdle() to process
+    //     deferred event.
+    if ( gs_deferredFocusOut )
+    {
+        wxWindowGTK *win = gs_deferredFocusOut;
+        gs_deferredFocusOut = NULL;
+
+        wxLogTrace(TRACE_FOCUS,
+                   "processing deferred focus_out event for %s(%p, %s)",
+                   win->GetClassInfo()->GetClassName(), win, win->GetLabel());
+
+        win->GTKHandleFocusOutNoDeferring();
+    }
+}
+
+void wxWindowGTK::SetFocus()
+{
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+
+    // Setting "physical" focus is not immediate in GTK+ and while
+    // gtk_widget_is_focus ("determines if the widget is the focus widget
+    // within its toplevel", i.e. returns true for one widget per TLW, not
+    // globally) returns true immediately after grabbing focus,
+    // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
+    // has focus at the moment) takes affect only after the window is shown
+    // (if it was hidden at the moment of the call) or at the next event loop
+    // iteration.
+    //
+    // Because we want to FindFocus() call immediately following
+    // foo->SetFocus() to return foo, we have to keep track of "pending" focus
+    // ourselves.
+    gs_pendingFocus = this;
+
+    GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
+
+    if ( GTK_IS_CONTAINER(widget) &&
+         !GTK_WIDGET_CAN_FOCUS(widget) )
+    {
+        wxLogTrace(TRACE_FOCUS,
+                   _T("Setting focus to a child of %s(%p, %s)"),
+                   GetClassInfo()->GetClassName(), this, GetLabel().c_str());
+        gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
+    }
+    else
+    {
+        wxLogTrace(TRACE_FOCUS,
+                   _T("Setting focus to %s(%p, %s)"),
+                   GetClassInfo()->GetClassName(), this, GetLabel().c_str());
+        gtk_widget_grab_focus(widget);
      }
  }
  
      }
  }
  
-bool wxWindowGTK::AcceptsFocus() const
+void wxWindowGTK::SetCanFocus(bool canFocus)
  {
  {
-    return m_acceptsFocus && wxWindowBase::AcceptsFocus();
+    if ( canFocus )
+        GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
+    else
+        GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
+
+    if ( m_wxwindow && (m_widget != m_wxwindow) )
+    {
+        if ( canFocus )
+            GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+        else
+            GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+    }
  }
  
  bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
  }
  
  bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
@@ -3537,53 +3090,147 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
  
      if (newParent)
      {
  
      if (newParent)
      {
+        if (GTK_WIDGET_VISIBLE (newParent->m_widget))
+        {
+            m_showOnIdle = true;
+            gtk_widget_hide( m_widget );
+        }
+
          /* insert GTK representation */
          (*(newParent->m_insertCallback))(newParent, this);
      }
  
          /* insert GTK representation */
          (*(newParent->m_insertCallback))(newParent, this);
      }
  
-    /* reverse: prevent GTK from deleting the widget arbitrarily */
-    gtk_widget_unref( m_widget );
+    /* reverse: prevent GTK from deleting the widget arbitrarily */
+    gtk_widget_unref( m_widget );
+
+    SetLayoutDirection(wxLayout_Default);
+
+    return true;
+}
+
+void wxWindowGTK::DoAddChild(wxWindowGTK *child)
+{
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+    wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
+
+    /* add to list */
+    AddChild( child );
+
+    /* insert GTK representation */
+    (*m_insertCallback)(this, child);
+}
+
+void wxWindowGTK::AddChild(wxWindowBase *child)
+{
+    wxWindowBase::AddChild(child);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
+
+void wxWindowGTK::RemoveChild(wxWindowBase *child)
+{
+    wxWindowBase::RemoveChild(child);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
+
+/* static */
+wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
+{
+    return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
+                ? wxLayout_RightToLeft
+                : wxLayout_LeftToRight;
+}
+
+/* static */
+void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
+{
+    wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
+
+    gtk_widget_set_direction(widget,
+                             dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
+                                                         : GTK_TEXT_DIR_LTR);
+}
+
+wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
+{
+    return GTKGetLayout(m_widget);
+}
+
+void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
+{
+    if ( dir == wxLayout_Default )
+    {
+        const wxWindow *const parent = GetParent();
+        if ( parent )
+        {
+            // inherit layout from parent.
+            dir = parent->GetLayoutDirection();
+        }
+        else // no parent, use global default layout
+        {
+            dir = wxTheApp->GetLayoutDirection();
+        }
+    }
+
+    if ( dir == wxLayout_Default )
+        return;
+
+    GTKSetLayout(m_widget, dir);
  
  
-    return true;
+    if (m_wxwindow && (m_wxwindow != m_widget))
+        GTKSetLayout(m_wxwindow, dir);
  }
  
  }
  
-void wxWindowGTK::DoAddChild(wxWindowGTK *child)
+wxCoord
+wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
+                                      wxCoord WXUNUSED(width),
+                                      wxCoord WXUNUSED(widthTotal)) const
  {
  {
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+    // We now mirror the coordinates of RTL windows in wxPizza
+    return x;
+}
  
  
-    wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
+void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
+{
+    wxWindowBase::DoMoveInTabOrder(win, move);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
  
  
-    wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
+bool wxWindowGTK::DoNavigateIn(int flags)
+{
+    if ( flags & wxNavigationKeyEvent::WinChange )
+    {
+        wxFAIL_MSG( _T("not implemented") );
  
  
-    /* add to list */
-    AddChild( child );
+        return false;
+    }
+    else // navigate inside the container
+    {
+        wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
+        wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
  
  
-    /* insert GTK representation */
-    (*m_insertCallback)(this, child);
-}
+        GtkDirectionType dir;
+        dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
+                                                      : GTK_DIR_TAB_BACKWARD;
  
  
-void wxWindowGTK::AddChild(wxWindowBase *child)
-{
-    wxWindowBase::AddChild(child);
-    m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+        gboolean rc;
+        g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
+
+        return rc == TRUE;
+    }
  }
  
  }
  
-void wxWindowGTK::RemoveChild(wxWindowBase *child)
+bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
  {
  {
-    wxWindowBase::RemoveChild(child);
-    m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // none needed by default
+    return false;
  }
  
  }
  
-void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
  {
  {
-    wxWindowBase::DoMoveInTabOrder(win, move);
-    m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // nothing to do by default since none is needed
  }
  
  void wxWindowGTK::RealizeTabOrder()
  }
  
  void wxWindowGTK::RealizeTabOrder()
@@ -3592,38 +3239,45 @@ void wxWindowGTK::RealizeTabOrder()
      {
          if ( !m_children.empty() )
          {
      {
          if ( !m_children.empty() )
          {
-#if wxUSE_STATTEXT
              // we don't only construct the correct focus chain but also use
              // we don't only construct the correct focus chain but also use
-            // this opportunity to update the mnemonic widgets for all labels
-            //
-            // it would be nice to extract this code from here and put it in
-            // stattext.cpp to reduce dependencies but there is no really easy
-            // way to do it unfortunately
-            wxStaticText *lastLabel = NULL;
-#endif // wxUSE_STATTEXT
+            // this opportunity to update the mnemonic widgets for the widgets
+            // that need them
  
              GList *chain = NULL;
  
              GList *chain = NULL;
+            wxWindowGTK* mnemonicWindow = NULL;
  
              for ( wxWindowList::const_iterator i = m_children.begin();
                    i != m_children.end();
                    ++i )
              {
                  wxWindowGTK *win = *i;
  
              for ( wxWindowList::const_iterator i = m_children.begin();
                    i != m_children.end();
                    ++i )
              {
                  wxWindowGTK *win = *i;
-#if wxUSE_STATTEXT
-                if ( lastLabel )
+
+                if ( mnemonicWindow )
                  {
                      if ( win->AcceptsFocusFromKeyboard() )
                      {
                  {
                      if ( win->AcceptsFocusFromKeyboard() )
                      {
-                        GtkLabel *l = GTK_LABEL(lastLabel->m_widget);
-                        gtk_label_set_mnemonic_widget(l, win->m_widget);
-                        lastLabel = NULL;
+                        // wxComboBox et al. needs to focus on on a different
+                        // widget than m_widget, so if the main widget isn't
+                        // focusable try the connect widget
+                        GtkWidget* w = win->m_widget;
+                        if ( !GTK_WIDGET_CAN_FOCUS(w) )
+                        {
+                            w = win->GetConnectWidget();
+                            if ( !GTK_WIDGET_CAN_FOCUS(w) )
+                                w = NULL;
+                        }
+
+                        if ( w )
+                        {
+                            mnemonicWindow->GTKWidgetDoSetMnemonic(w);
+                            mnemonicWindow = NULL;
+                        }
                      }
                  }
                      }
                  }
-                else // check if this one is a label
+                else if ( win->GTKWidgetNeedsMnemonic() )
                  {
                  {
-                    lastLabel = wxDynamicCast(win, wxStaticText);
+                    mnemonicWindow = win;
                  }
                  }
-#endif // wxUSE_STATTEXT
  
                  chain = g_list_prepend(chain, win->m_widget);
              }
  
                  chain = g_list_prepend(chain, win->m_widget);
              }
@@ -3670,18 +3324,41 @@ void wxWindowGTK::Lower()
  
  bool wxWindowGTK::SetCursor( const wxCursor &cursor )
  {
  
  bool wxWindowGTK::SetCursor( const wxCursor &cursor )
  {
-    wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
+    if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
+        return false;
  
  
-    if (cursor == m_cursor)
-       return false;
+    GTKUpdateCursor();
  
  
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    return true;
+}
  
  
-    if (cursor == wxNullCursor)
-       return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
-    else
-       return wxWindowBase::SetCursor( cursor );
+void wxWindowGTK::GTKUpdateCursor()
+{
+    wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
+    if ( cursor.Ok() )
+    {
+        wxArrayGdkWindows windowsThis;
+        GdkWindow * const winThis = GTKGetWindow(windowsThis);
+        if ( winThis )
+        {
+            gdk_window_set_cursor(winThis, cursor.GetCursor());
+        }
+        else
+        {
+            const size_t count = windowsThis.size();
+            for ( size_t n = 0; n < count; n++ )
+            {
+                GdkWindow *win = windowsThis[n];
+                if ( !win )
+                {
+                    wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
+                    continue;
+                }
+
+                gdk_window_set_cursor(win, cursor.GetCursor());
+            }
+        }
+    }
  }
  
  void wxWindowGTK::WarpPointer( int x, int y )
  }
  
  void wxWindowGTK::WarpPointer( int x, int y )
@@ -3693,7 +3370,7 @@ void wxWindowGTK::WarpPointer( int x, int y )
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
      else
          window = GetConnectWidget()->window;
  
      else
          window = GetConnectWidget()->window;
  
@@ -3701,41 +3378,51 @@ void wxWindowGTK::WarpPointer( int x, int y )
          gdk_window_warp_pointer( window, x, y );
  }
  
          gdk_window_warp_pointer( window, x, y );
  }
  
-static bool wxScrollAdjust(GtkAdjustment* adj, double change)
+wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
  {
  {
-    double value_start = adj->value;
-    double value = value_start + change;
-    double upper = adj->upper - adj->page_size;
-    if (value > upper)
+    // find the scrollbar which generated the event
+    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
      {
      {
-        value = upper;
+        if ( range == m_scrollBar[dir] )
+            return (ScrollDir)dir;
      }
      }
-    // Lower bound will be checked by gtk_adjustment_set_value
-    gtk_adjustment_set_value(adj, value);
-    return adj->value != value_start;
+
+    wxFAIL_MSG( _T("event from unknown scrollbar received") );
+
+    return ScrollDir_Max;
  }
  
  }
  
-bool wxWindowGTK::ScrollLines(int lines)
+bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
  {
  {
-    return
-        m_vAdjust != NULL &&
-        wxScrollAdjust(m_vAdjust, lines * m_vAdjust->step_increment);
+    bool changed = false;
+    GtkRange* range = m_scrollBar[dir];
+    if ( range && units )
+    {
+        GtkAdjustment* adj = range->adjustment;
+        gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
+                                              : adj->page_increment;
+
+        const int posOld = int(adj->value + 0.5);
+        gtk_range_set_value(range, posOld + units*inc);
+
+        changed = int(adj->value + 0.5) != posOld;
+    }
+
+    return changed;
  }
  
  }
  
-bool wxWindowGTK::ScrollPages(int pages)
+bool wxWindowGTK::ScrollLines(int lines)
  {
  {
-    return
-        m_vAdjust != NULL &&
-        wxScrollAdjust(m_vAdjust, pages * m_vAdjust->page_increment);
+    return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
  }
  
  }
  
-void wxWindowGTK::SetVScrollAdjustment(GtkAdjustment* adj)
+bool wxWindowGTK::ScrollPages(int pages)
  {
  {
-    wxASSERT(m_vAdjust == NULL);
-    m_vAdjust = adj;
+    return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
  }
  
  }
  
-void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
+void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
+                          const wxRect *rect)
  {
      if (!m_widget)
          return;
  {
      if (!m_widget)
          return;
@@ -3744,6 +3431,8 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
  
      if (m_wxwindow)
      {
  
      if (m_wxwindow)
      {
+        if (m_wxwindow->window == NULL) return;
+
          GdkRectangle gdk_rect,
                      *p;
          if (rect)
          GdkRectangle gdk_rect,
                      *p;
          if (rect)
@@ -3752,6 +3441,9 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
              gdk_rect.y = rect->y;
              gdk_rect.width = rect->width;
              gdk_rect.height = rect->height;
              gdk_rect.y = rect->y;
              gdk_rect.width = rect->width;
              gdk_rect.height = rect->height;
+            if (GetLayoutDirection() == wxLayout_RightToLeft)
+                gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
+
              p = &gdk_rect;
          }
          else // invalidate everything
              p = &gdk_rect;
          }
          else // invalidate everything
@@ -3759,7 +3451,7 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
              p = NULL;
          }
  
              p = NULL;
          }
  
-        gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
+        gdk_window_invalidate_rect(m_wxwindow->window, p, true);
      }
  }
  
      }
  }
  
@@ -3776,8 +3468,10 @@ void wxWindowGTK::Update()
  
  void wxWindowGTK::GtkUpdate()
  {
  
  void wxWindowGTK::GtkUpdate()
  {
-    if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
-        gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
+    if (m_wxwindow && m_wxwindow->window)
+        gdk_window_process_updates(m_wxwindow->window, false);
+    if (m_widget && m_widget->window && (m_wxwindow != m_widget))
+        gdk_window_process_updates( m_widget->window, FALSE );
  
      // for consistency with other platforms (and also because it's convenient
      // to be able to update an entire TLW by calling Update() only once), we
  
      // for consistency with other platforms (and also because it's convenient
      // to be able to update an entire TLW by calling Update() only once), we
@@ -3790,6 +3484,20 @@ void wxWindowGTK::GtkUpdate()
      }
  }
  
      }
  }
  
+bool wxWindowGTK::DoIsExposed( int x, int y ) const
+{
+    return m_updateRegion.Contains(x, y) != wxOutRegion;
+}
+
+
+bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
+{
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+        return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
+    else
+        return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
+}
+
  void wxWindowGTK::GtkSendPaintEvents()
  {
      if (!m_wxwindow)
  void wxWindowGTK::GtkSendPaintEvents()
  {
      if (!m_wxwindow)
@@ -3801,8 +3509,31 @@ void wxWindowGTK::GtkSendPaintEvents()
      // Clip to paint region in wxClientDC
      m_clipPaintRegion = true;
  
      // Clip to paint region in wxClientDC
      m_clipPaintRegion = true;
  
-    // widget to draw on
-    GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
+    m_nativeUpdateRegion = m_updateRegion;
+
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+    {
+        // Transform m_updateRegion under RTL
+        m_updateRegion.Clear();
+
+        gint width;
+        gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
+
+        wxRegionIterator upd( m_nativeUpdateRegion );
+        while (upd)
+        {
+            wxRect rect;
+            rect.x = upd.GetX();
+            rect.y = upd.GetY();
+            rect.width = upd.GetWidth();
+            rect.height = upd.GetHeight();
+
+            rect.x = width - rect.x - rect.width;
+            m_updateRegion.Union( rect );
+
+            ++upd;
+        }
+    }
  
      if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
      {
  
      if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
      {
@@ -3813,7 +3544,7 @@ void wxWindowGTK::GtkSendPaintEvents()
  
          if (GTK_WIDGET_MAPPED(parent->m_widget))
          {
  
          if (GTK_WIDGET_MAPPED(parent->m_widget))
          {
-            wxRegionIterator upd( m_updateRegion );
+            wxRegionIterator upd( m_nativeUpdateRegion );
              while (upd)
              {
                  GdkRectangle rect;
              while (upd)
              {
                  GdkRectangle rect;
@@ -3823,7 +3554,7 @@ void wxWindowGTK::GtkSendPaintEvents()
                  rect.height = upd.GetHeight();
  
                  gtk_paint_flat_box( parent->m_widget->style,
                  rect.height = upd.GetHeight();
  
                  gtk_paint_flat_box( parent->m_widget->style,
-                            pizza->bin_window,
+                            m_wxwindow->window,
                              (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
                              GTK_SHADOW_NONE,
                              &rect,
                              (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
                              GTK_SHADOW_NONE,
                              &rect,
@@ -3836,28 +3567,49 @@ void wxWindowGTK::GtkSendPaintEvents()
          }
      }
      else
          }
      }
      else
-
      {
          wxWindowDC dc( (wxWindow*)this );
          dc.SetClippingRegion( m_updateRegion );
  
      {
          wxWindowDC dc( (wxWindow*)this );
          dc.SetClippingRegion( m_updateRegion );
  
+        // Work around gtk-qt <= 0.60 bug whereby the window colour
+        // remains grey
+        if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
+        {
+            dc.SetBackground(wxBrush(GetBackgroundColour()));
+            dc.Clear();
+        }
+
          wxEraseEvent erase_event( GetId(), &dc );
          erase_event.SetEventObject( this );
  
          wxEraseEvent erase_event( GetId(), &dc );
          erase_event.SetEventObject( this );
  
-        GetEventHandler()->ProcessEvent(erase_event);
+        HandleWindowEvent(erase_event);
      }
  
      wxNcPaintEvent nc_paint_event( GetId() );
      nc_paint_event.SetEventObject( this );
      }
  
      wxNcPaintEvent nc_paint_event( GetId() );
      nc_paint_event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( nc_paint_event );
+    HandleWindowEvent( nc_paint_event );
  
      wxPaintEvent paint_event( GetId() );
      paint_event.SetEventObject( this );
  
      wxPaintEvent paint_event( GetId() );
      paint_event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( paint_event );
+    HandleWindowEvent( paint_event );
  
      m_clipPaintRegion = false;
  
      m_updateRegion.Clear();
  
      m_clipPaintRegion = false;
  
      m_updateRegion.Clear();
+    m_nativeUpdateRegion.Clear();
+}
+
+void wxWindowGTK::SetDoubleBuffered( bool on )
+{
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+    if ( m_wxwindow )
+        gtk_widget_set_double_buffered( m_wxwindow, on );
+}
+
+bool wxWindowGTK::IsDoubleBuffered() const
+{
+    return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
  }
  
  void wxWindowGTK::ClearBackground()
  }
  
  void wxWindowGTK::ClearBackground()
@@ -3874,10 +3626,9 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
          m_tooltip->Apply( (wxWindow *)this );
  }
  
          m_tooltip->Apply( (wxWindow *)this );
  }
  
-void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
+void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip )
  {
  {
-    wxString tmp( tip );
-    gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
+    gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
  }
  #endif // wxUSE_TOOLTIPS
  
  }
  #endif // wxUSE_TOOLTIPS
  
@@ -3947,45 +3698,54 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
              pango_font_description_copy( m_font.GetNativeFontInfo()->description );
      }
  
              pango_font_description_copy( m_font.GetNativeFontInfo()->description );
      }
  
+    int flagsNormal = 0,
+        flagsPrelight = 0,
+        flagsActive = 0,
+        flagsInsensitive = 0;
+
      if ( m_foregroundColour.Ok() )
      {
      if ( m_foregroundColour.Ok() )
      {
-        GdkColor *fg = m_foregroundColour.GetColor();
+        const GdkColor *fg = m_foregroundColour.GetColor();
  
  
-        style->fg[GTK_STATE_NORMAL] = *fg;
-        style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG;
+        style->fg[GTK_STATE_NORMAL] =
+        style->text[GTK_STATE_NORMAL] = *fg;
+        flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
  
  
-        style->fg[GTK_STATE_PRELIGHT] = *fg;
-        style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG;
+        style->fg[GTK_STATE_PRELIGHT] =
+        style->text[GTK_STATE_PRELIGHT] = *fg;
+        flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
  
  
-        style->fg[GTK_STATE_ACTIVE] = *fg;
-        style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG;
+        style->fg[GTK_STATE_ACTIVE] =
+        style->text[GTK_STATE_ACTIVE] = *fg;
+        flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
      }
  
      if ( m_backgroundColour.Ok() )
      {
      }
  
      if ( m_backgroundColour.Ok() )
      {
-        GdkColor *bg = m_backgroundColour.GetColor();
+        const GdkColor *bg = m_backgroundColour.GetColor();
  
  
-        style->bg[GTK_STATE_NORMAL] = *bg;
+        style->bg[GTK_STATE_NORMAL] =
          style->base[GTK_STATE_NORMAL] = *bg;
          style->base[GTK_STATE_NORMAL] = *bg;
-        style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)
-            (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE);
+        flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
  
  
-        style->bg[GTK_STATE_PRELIGHT] = *bg;
+        style->bg[GTK_STATE_PRELIGHT] =
          style->base[GTK_STATE_PRELIGHT] = *bg;
          style->base[GTK_STATE_PRELIGHT] = *bg;
-        style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)
-            (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE);
+        flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
  
  
-        style->bg[GTK_STATE_ACTIVE] = *bg;
+        style->bg[GTK_STATE_ACTIVE] =
          style->base[GTK_STATE_ACTIVE] = *bg;
          style->base[GTK_STATE_ACTIVE] = *bg;
-        style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)
-            (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE);
+        flagsActive |= GTK_RC_BG | GTK_RC_BASE;
  
  
-        style->bg[GTK_STATE_INSENSITIVE] = *bg;
+        style->bg[GTK_STATE_INSENSITIVE] =
          style->base[GTK_STATE_INSENSITIVE] = *bg;
          style->base[GTK_STATE_INSENSITIVE] = *bg;
-        style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)
-            (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE);
+        flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
      }
  
      }
  
+    style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
+    style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
+    style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
+    style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
+
      return style;
  }
  
      return style;
  }
  
@@ -4004,6 +3764,8 @@ void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
  
  void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
  {
  
  void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
  {
+    wxSuspendStyleEvents s(static_cast<wxWindow*>(this));
+
      if (m_wxwindow)
          gtk_widget_modify_style(m_wxwindow, style);
      else
      if (m_wxwindow)
          gtk_widget_modify_style(m_wxwindow, style);
      else
@@ -4016,11 +3778,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
  
      if (style == wxBG_STYLE_CUSTOM)
      {
  
      if (style == wxBG_STYLE_CUSTOM)
      {
-        GdkWindow *window = (GdkWindow*) NULL;
-        if (m_wxwindow)
-            window = GTK_PIZZA(m_wxwindow)->bin_window;
+        GdkWindow *window;
+        if ( m_wxwindow )
+        {
+            window = m_wxwindow->window;
+        }
          else
          else
-            window = GetConnectWidget()->window;
+        {
+            GtkWidget * const w = GetConnectWidget();
+            window = w ? w->window : NULL;
+        }
  
          if (window)
          {
  
          if (window)
          {
@@ -4033,9 +3800,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
  #endif
              m_needsStyleChange = false;
          }
  #endif
              m_needsStyleChange = false;
          }
-        else
+        else // window not realized yet
+        {
              // Do in OnIdle, because the window is not yet available
              m_needsStyleChange = true;
              // Do in OnIdle, because the window is not yet available
              m_needsStyleChange = true;
+        }
  
          // Don't apply widget style, or we get a grey background
      }
  
          // Don't apply widget style, or we get a grey background
      }
@@ -4048,6 +3817,103 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
      return true;
  }
  
      return true;
  }
  
+// ----------------------------------------------------------------------------
+// Pop-up menu stuff
+// ----------------------------------------------------------------------------
+
+#if wxUSE_MENUS_NATIVE
+
+static void SetInvokingWindow( wxMenu *menu, wxWindow* win )
+{
+    menu->SetInvokingWindow( win );
+
+    wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
+    while (node)
+    {
+        wxMenuItem *menuitem = node->GetData();
+        if (menuitem->IsSubMenu())
+        {
+            SetInvokingWindow( menuitem->GetSubMenu(), win );
+        }
+
+        node = node->GetNext();
+    }
+}
+
+extern "C" {
+static
+void wxPopupMenuPositionCallback( GtkMenu *menu,
+                                  gint *x, gint *y,
+                                  gboolean * WXUNUSED(whatever),
+                                  gpointer user_data )
+{
+    // ensure that the menu appears entirely on screen
+    GtkRequisition req;
+    gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
+
+    wxSize sizeScreen = wxGetDisplaySize();
+    wxPoint *pos = (wxPoint*)user_data;
+
+    gint xmax = sizeScreen.x - req.width,
+         ymax = sizeScreen.y - req.height;
+
+    *x = pos->x < xmax ? pos->x : xmax;
+    *y = pos->y < ymax ? pos->y : ymax;
+}
+}
+
+void wxWindowGTK::DoPopupMenuUpdateUI(wxMenu* menu)
+{
+    menu->UpdateUI();
+}
+
+bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
+{
+    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
+
+    wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
+
+    SetInvokingWindow( menu, this );
+
+    DoPopupMenuUpdateUI(menu);
+
+    wxPoint pos;
+    gpointer userdata;
+    GtkMenuPositionFunc posfunc;
+    if ( x == -1 && y == -1 )
+    {
+        // use GTK's default positioning algorithm
+        userdata = NULL;
+        posfunc = NULL;
+    }
+    else
+    {
+        pos = ClientToScreen(wxPoint(x, y));
+        userdata = &pos;
+        posfunc = wxPopupMenuPositionCallback;
+    }
+
+    menu->m_popupShown = true;
+    gtk_menu_popup(
+                  GTK_MENU(menu->m_menu),
+                  (GtkWidget *) NULL,           // parent menu shell
+                  (GtkWidget *) NULL,           // parent menu item
+                  posfunc,                      // function to position it
+                  userdata,                     // client data
+                  0,                            // button used to activate it
+                  gtk_get_current_event_time()
+                );
+
+    while (menu->m_popupShown)
+    {
+        gtk_main_iteration();
+    }
+
+    return true;
+}
+
+#endif // wxUSE_MENUS_NATIVE
+
  #if wxUSE_DRAG_AND_DROP
  
  void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
  #if wxUSE_DRAG_AND_DROP
  
  void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
@@ -4074,12 +3940,18 @@ GtkWidget* wxWindowGTK::GetConnectWidget()
      return connect_widget;
  }
  
      return connect_widget;
  }
  
-bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
+bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
  {
  {
-    if (m_wxwindow)
-        return (window == GTK_PIZZA(m_wxwindow)->bin_window);
+    wxArrayGdkWindows windowsThis;
+    GdkWindow * const winThis = GTKGetWindow(windowsThis);
+
+    return winThis ? window == winThis
+                   : windowsThis.Index(window) != wxNOT_FOUND;
+}
  
  
-    return (window == m_widget->window);
+GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
+{
+    return m_wxwindow ? m_wxwindow->window : m_widget->window;
  }
  
  bool wxWindowGTK::SetFont( const wxFont &font )
  }
  
  bool wxWindowGTK::SetFont( const wxFont &font )
@@ -4102,13 +3974,13 @@ void wxWindowGTK::DoCaptureMouse()
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
      else
          window = GetConnectWidget()->window;
  
      wxCHECK_RET( window, _T("CaptureMouse() failed") );
  
      else
          window = GetConnectWidget()->window;
  
      wxCHECK_RET( window, _T("CaptureMouse() failed") );
  
-    wxCursor* cursor = & m_cursor;
+    const wxCursor* cursor = &m_cursor;
      if (!cursor->Ok())
          cursor = wxSTANDARD_CURSOR;
  
      if (!cursor->Ok())
          cursor = wxSTANDARD_CURSOR;
  
@@ -4135,7 +4007,7 @@ void wxWindowGTK::DoReleaseMouse()
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
  
      GdkWindow *window = (GdkWindow*) NULL;
      if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
      else
          window = GetConnectWidget()->window;
  
      else
          window = GetConnectWidget()->window;
  
@@ -4145,6 +4017,14 @@ void wxWindowGTK::DoReleaseMouse()
      gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
  }
  
      gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
  }
  
+void wxWindowGTK::GTKReleaseMouseAndNotify()
+{
+    DoReleaseMouse();
+    wxMouseCaptureLostEvent evt(GetId());
+    evt.SetEventObject( this );
+    HandleWindowEvent( evt );
+}
+
  /* static */
  wxWindow *wxWindowBase::GetCapture()
  {
  /* static */
  wxWindow *wxWindowBase::GetCapture()
  {
@@ -4156,139 +4036,134 @@ bool wxWindowGTK::IsRetained() const
      return false;
  }
  
      return false;
  }
  
-void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
-      int range, bool refresh )
+void wxWindowGTK::SetScrollbar(int orient,
+                               int pos,
+                               int thumbVisible,
+                               int range,
+                               bool WXUNUSED(update))
  {
  {
-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+    const int dir = ScrollDirFromOrient(orient);
+    GtkRange* const sb = m_scrollBar[dir];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );
  
  
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+    if (range <= 0)
+    {
+        // GtkRange requires upper > lower
+        range =
+        thumbVisible = 1;
+    }
  
  
-    m_hasScrolling = true;
+    GtkAdjustment * const adj = sb->adjustment;
+    adj->step_increment = 1;
+    adj->page_increment =
+    adj->page_size = thumbVisible;
+    adj->value = pos;
  
  
-    if (orient == wxHORIZONTAL)
-    {
-        float fpos = (float)pos;
-        float frange = (float)range;
-        float fthumb = (float)thumbVisible;
-        if (fpos > frange-fthumb) fpos = frange-fthumb;
-        if (fpos < 0.0) fpos = 0.0;
+    g_signal_handlers_block_by_func(
+        sb, (void*)gtk_scrollbar_value_changed, this);
  
  
-        if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
-            (fabs(fthumb-m_hAdjust->page_size) < 0.2))
-        {
-            SetScrollPos( orient, pos, refresh );
-            return;
-        }
+    gtk_range_set_range(sb, 0, range);
+    m_scrollPos[dir] = sb->adjustment->value;
  
  
-        m_oldHorizontalPos = fpos;
+    g_signal_handlers_unblock_by_func(
+        sb, (void*)gtk_scrollbar_value_changed, this);
+}
  
  
-        m_hAdjust->lower = 0.0;
-        m_hAdjust->upper = frange;
-        m_hAdjust->value = fpos;
-        m_hAdjust->step_increment = 1.0;
-        m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
-        m_hAdjust->page_size = fthumb;
-    }
-    else
-    {
-        float fpos = (float)pos;
-        float frange = (float)range;
-        float fthumb = (float)thumbVisible;
-        if (fpos > frange-fthumb) fpos = frange-fthumb;
-        if (fpos < 0.0) fpos = 0.0;
+void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
+{
+    const int dir = ScrollDirFromOrient(orient);
+    GtkRange * const sb = m_scrollBar[dir];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );
  
  
-        if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
-            (fabs(fthumb-m_vAdjust->page_size) < 0.2))
-        {
-            SetScrollPos( orient, pos, refresh );
-            return;
-        }
+    // This check is more than an optimization. Without it, the slider
+    //   will not move smoothly while tracking when using wxScrollHelper.
+    if (GetScrollPos(orient) != pos)
+    {
+        g_signal_handlers_block_by_func(
+            sb, (void*)gtk_scrollbar_value_changed, this);
  
  
-        m_oldVerticalPos = fpos;
+        gtk_range_set_value(sb, pos);
+        m_scrollPos[dir] = sb->adjustment->value;
  
  
-        m_vAdjust->lower = 0.0;
-        m_vAdjust->upper = frange;
-        m_vAdjust->value = fpos;
-        m_vAdjust->step_increment = 1.0;
-        m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
-        m_vAdjust->page_size = fthumb;
+        g_signal_handlers_unblock_by_func(
+            sb, (void*)gtk_scrollbar_value_changed, this);
      }
      }
-
-    if (orient == wxHORIZONTAL)
-        g_signal_emit_by_name (m_hAdjust, "changed");
-    else
-        g_signal_emit_by_name (m_vAdjust, "changed");
  }
  
  }
  
-void wxWindowGTK::GtkUpdateScrollbar(int orient)
+int wxWindowGTK::GetScrollThumb(int orient) const
  {
  {
-    GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust;
-    gpointer fn = orient == wxHORIZONTAL
-            ? (gpointer) gtk_window_hscroll_callback
-            : (gpointer) gtk_window_vscroll_callback;
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
  
  
-    g_signal_handlers_disconnect_by_func (adj, fn, this);
-    g_signal_emit_by_name (adj, "value_changed");
-    g_signal_connect (adj, "value_changed", G_CALLBACK (fn), this);
+    return int(sb->adjustment->page_size);
  }
  
  }
  
-void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
+int wxWindowGTK::GetScrollPos( int orient ) const
  {
  {
-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
  
  
-    GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust;
-
-    float fpos = (float)pos;
-    if (fpos > adj->upper - adj->page_size)
-        fpos = adj->upper - adj->page_size;
-    if (fpos < 0.0)
-        fpos = 0.0;
-    *(orient == wxHORIZONTAL ? &m_oldHorizontalPos : &m_oldVerticalPos) = fpos;
-
-    if (fabs(fpos-adj->value) < 0.2)
-        return;
-    adj->value = fpos;
-
-    if ( m_wxwindow->window )
-    {
-    }
+    return int(sb->adjustment->value + 0.5);
  }
  
  }
  
-int wxWindowGTK::GetScrollThumb( int orient ) const
+int wxWindowGTK::GetScrollRange( int orient ) const
  {
  {
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
  
  
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    return int(sb->adjustment->upper);
+}
  
  
-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->page_size+0.5);
-    else
-        return (int)(m_vAdjust->page_size+0.5);
+// Determine if increment is the same as +/-x, allowing for some small
+//   difference due to possible inexactness in floating point arithmetic
+static inline bool IsScrollIncrement(double increment, double x)
+{
+    wxASSERT(increment > 0);
+    const double tolerance = 1.0 / 1024;
+    return fabs(increment - fabs(x)) < tolerance;
  }
  
  }
  
-int wxWindowGTK::GetScrollPos( int orient ) const
+wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
  {
  {
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
+    wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
  
  
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    const int barIndex = range == m_scrollBar[1];
+    GtkAdjustment* adj = range->adjustment;
  
  
-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->value+0.5);
-    else
-        return (int)(m_vAdjust->value+0.5);
-}
+    const int value = int(adj->value + 0.5);
  
  
-int wxWindowGTK::GetScrollRange( int orient ) const
-{
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
+    // save previous position
+    const double oldPos = m_scrollPos[barIndex];
+    // update current position
+    m_scrollPos[barIndex] = adj->value;
+    // If event should be ignored, or integral position has not changed
+    if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))
+    {
+        return wxEVT_NULL;
+    }
  
  
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
+    if (!m_isScrolling)
+    {
+        // Difference from last change event
+        const double diff = adj->value - oldPos;
+        const bool isDown = diff > 0;
  
  
-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->upper+0.5);
-    else
-        return (int)(m_vAdjust->upper+0.5);
+        if (IsScrollIncrement(adj->step_increment, diff))
+        {
+            eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
+        }
+        else if (IsScrollIncrement(adj->page_increment, diff))
+        {
+            eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
+        }
+        else if (m_mouseButtonDown)
+        {
+            // Assume track event
+            m_isScrolling = true;
+        }
+    }
+    return eventType;
  }
  
  void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
  }
  
  void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
@@ -4302,9 +4177,57 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
  
      m_clipPaintRegion = true;
  
  
      m_clipPaintRegion = true;
  
-    gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+    WX_PIZZA(m_wxwindow)->scroll(dx, dy);
  
      m_clipPaintRegion = false;
  
      m_clipPaintRegion = false;
+
+#if wxUSE_CARET
+    bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
+    if (restoreCaret)
+    {
+        wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
+        if (dx > 0)
+            caretRect.width += dx;
+        else
+        {
+            caretRect.x += dx; caretRect.width -= dx;
+        }
+        if (dy > 0)
+            caretRect.height += dy;
+        else
+        {
+            caretRect.y += dy; caretRect.height -= dy;
+        }
+
+        RefreshRect(caretRect);
+    }
+#endif // wxUSE_CARET
+}
+
+void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
+{
+    //RN: Note that static controls usually have no border on gtk, so maybe
+    //it makes sense to treat that as simply no border at the wx level
+    //as well...
+    if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
+    {
+        GtkShadowType gtkstyle;
+
+        if(wxstyle & wxBORDER_RAISED)
+            gtkstyle = GTK_SHADOW_OUT;
+        else if (wxstyle & wxBORDER_SUNKEN)
+            gtkstyle = GTK_SHADOW_IN;
+#if 0
+        // Now obsolete
+        else if (wxstyle & wxBORDER_DOUBLE)
+            gtkstyle = GTK_SHADOW_ETCHED_IN;
+#endif
+        else //default
+            gtkstyle = GTK_SHADOW_IN;
+
+        gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
+                                             gtkstyle );
+    }
  }
  
  void wxWindowGTK::SetWindowStyleFlag( long style )
  }
  
  void wxWindowGTK::SetWindowStyleFlag( long style )
@@ -4352,44 +4275,92 @@ wxPoint wxGetMousePosition()
  
  }
  
  
  }
  
-// Needed for implementing e.g. combobox on wxGTK within a modal dialog.
-void wxAddGrab(wxWindow* window)
+GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
  {
  {
-    gtk_grab_add( (GtkWidget*) window->GetHandle() );
+    GdkWindow* window = NULL;
+    if (m_wxwindow)
+        window = m_wxwindow->window;
+    return window;
  }
  
  }
  
-void wxRemoveGrab(wxWindow* window)
+// ----------------------------------------------------------------------------
+// freeze/thaw
+// ----------------------------------------------------------------------------
+
+extern "C"
+{
+
+// this is called if we attempted to freeze unrealized widget when it finally
+// is realized (and so can be frozen):
+static void wx_frozen_widget_realize(GtkWidget* w, void* WXUNUSED(data))
  {
  {
-    gtk_grab_remove( (GtkWidget*) window->GetHandle() );
+    wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
+    wxASSERT( GTK_WIDGET_REALIZED(w) );
+
+    g_signal_handlers_disconnect_by_func
+    (
+        w,
+        (void*)wx_frozen_widget_realize,
+        NULL
+    );
+
+    gdk_window_freeze_updates(w->window);
  }
  
  }
  
-// ----------------------------------------------------------------------------
-// wxWinModule
-// ----------------------------------------------------------------------------
+} // extern "C"
  
  
-class wxWinModule : public wxModule
+void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
  {
  {
-public:
-    bool OnInit();
-    void OnExit();
+    if ( !w || GTK_WIDGET_NO_WINDOW(w) )
+        return; // window-less widget, cannot be frozen
  
  
-private:
-    DECLARE_DYNAMIC_CLASS(wxWinModule)
-};
+    if ( !GTK_WIDGET_REALIZED(w) )
+    {
+        // we can't thaw unrealized widgets because they don't have GdkWindow,
+        // so set it up to be done immediately after realization:
+        g_signal_connect_after
+        (
+            w,
+            "realize",
+            G_CALLBACK(wx_frozen_widget_realize),
+            NULL
+        );
+        return;
+    }
  
  
-IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
+    gdk_window_freeze_updates(w->window);
+}
  
  
-bool wxWinModule::OnInit()
+void wxWindowGTK::GTKThawWidget(GtkWidget *w)
  {
  {
-    // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
-    // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
+    if ( !w || GTK_WIDGET_NO_WINDOW(w) )
+        return; // window-less widget, cannot be frozen
  
  
-    return true;
+    if ( !GTK_WIDGET_REALIZED(w) )
+    {
+        // the widget wasn't realized yet, no need to thaw
+        g_signal_handlers_disconnect_by_func
+        (
+            w,
+            (void*)wx_frozen_widget_realize,
+            NULL
+        );
+        return;
+    }
+
+    gdk_window_thaw_updates(w->window);
  }
  
  }
  
-void wxWinModule::OnExit()
+void wxWindowGTK::DoFreeze()
  {
  {
-    if (g_eraseGC)
-        gdk_gc_unref( g_eraseGC );
+    GTKFreezeWidget(m_widget);
+    if ( m_wxwindow && m_widget != m_wxwindow )
+        GTKFreezeWidget(m_wxwindow);
  }
  
  }
  
+void wxWindowGTK::DoThaw()
+{
+    GTKThawWidget(m_widget);
+    if ( m_wxwindow && m_widget != m_wxwindow )
+        GTKThawWidget(m_wxwindow);
+}