]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk/window.cpp
Upport hint window improvement using custom GTK+ code
[wxWidgets.git] / src / gtk / window.cpp
index 583b46987799019d7767c99e7f7928cb354a24d0..030666ca70341079d988f8c560d593bb65d54e99 100644 (file)
 #include "wx/window.h"
 
 #ifndef WX_PRECOMP
-    #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/app.h"
-    #include "wx/utils.h"
-    #include "wx/frame.h"
+    #include "wx/toplevel.h"
     #include "wx/dcclient.h"
     #include "wx/menu.h"
-    #include "wx/dialog.h"
     #include "wx/settings.h"
     #include "wx/msgdlg.h"
-    #include "wx/textctrl.h"
-    #include "wx/toolbar.h"
-    #include "wx/combobox.h"
-    #include "wx/layout.h"
-    #include "wx/statusbr.h"
     #include "wx/math.h"
-    #include "wx/module.h"
 #endif
 
-#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
-
+#include "wx/dnd.h"
+#include "wx/tooltip.h"
+#include "wx/caret.h"
 #include "wx/fontutil.h"
+#include "wx/sysopt.h"
 
 #ifdef __WXDEBUG__
     #include "wx/thread.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
+    #undef GTK_DISABLE_DEPRECATED
+    #include <gtk/gtkcombo.h>
+    #define GTK_DISABLE_DEPRECATED
 #endif
 
 #include "wx/gtk/private.h"
-#include <gdk/gdkprivate.h>
+#include "wx/gtk/win_gtk.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
 //-----------------------------------------------------------------------------
@@ -140,19 +112,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
-   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 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-
-   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-
@@ -166,10 +138,10 @@ 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()
-   which actually moves the window and its sub-windows. 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
-   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)
 
@@ -214,8 +186,10 @@ extern GtkContainerClass *pizza_parent_class;
 // data
 //-----------------------------------------------------------------------------
 
-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;
 
 // mouse capture state: the window which has it and if the mouse is currently
@@ -234,6 +208,11 @@ wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
 // yet, defer setting the focus to idle time.
 wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
 
+// global variables because GTK+ DnD want to have the
+// mouse event that caused it
+GdkEvent    *g_lastMouseEvent = (GdkEvent*) NULL;
+int          g_lastButtonNumber = 0;
+
 extern bool g_mainThreadLocked;
 
 //-----------------------------------------------------------------------------
@@ -333,96 +312,15 @@ static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h)
     }
 }
 
-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)
-    {
-        GetScrollbarWidth(widget, dw, dh);
-    }
-
-    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 );
-        g_object_unref (gc);
-        return;
-    }
-#endif // __WXUNIVERSAL__
-}
-
-//-----------------------------------------------------------------------------
-// "expose_event" of m_widget
-//-----------------------------------------------------------------------------
-
-extern "C" {
-static gboolean
-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
 //-----------------------------------------------------------------------------
 
 // 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,
-                                        wxWindow *win)
+                                        wxWindow * win)
 {
     int w, h;
     win->GetSize( &w, &h );
@@ -436,11 +334,13 @@ void wxgtk_window_size_request_callback(GtkWidget *widget,
 }
 }
 
+#if wxUSE_COMBOBOX
+
 extern "C" {
 static
-void wxgtk_combo_size_request_callback(GtkWidget *widget,
+void wxgtk_combo_size_request_callback(GtkWidget * WXUNUSED(widget),
                                        GtkRequisition *requisition,
-                                       wxComboBox *win)
+                                       wxWindow* win)
 {
     // This callback is actually hooked into the text entry
     // of the combo box, not the GtkHBox.
@@ -457,14 +357,22 @@ void wxgtk_combo_size_request_callback(GtkWidget *widget,
     GtkRequisition entry_req;
     entry_req.width = 2;
     entry_req.height = 2;
+    (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->entry) )->size_request )
+        (gcombo->entry, &entry_req );
+
+    GtkRequisition button_req;
+    button_req.width = 2;
+    button_req.height = 2;
     (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request )
-        (gcombo->button, &entry_req );
+        (gcombo->button, &button_req );
 
-    requisition->width = w - entry_req.width;
+    requisition->width = w - button_req.width;
     requisition->height = entry_req.height;
 }
 }
 
+#endif // wxUSE_COMBOBOX
+
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
@@ -477,15 +385,9 @@ gtk_window_expose_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
-    // This callback gets called in drawing-idle time under
-    // GTK 2.0, so we don't need to defer anything to idle
-    // time anymore.
-
-    GtkPizza *pizza = GTK_PIZZA( widget );
-    if (gdk_event->window != pizza->bin_window) return FALSE;
-
+    // if this event is for the border-only GdkWindow
+    if (gdk_event->window != widget->window)
+        return false;
 
 #if 0
     if (win->GetName())
@@ -517,12 +419,57 @@ gtk_window_expose_callback( GtkWidget *widget,
     win->GtkSendPaintEvents();
 
     // Let parent window draw window-less widgets
-    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
-
     return FALSE;
 }
 }
 
+//-----------------------------------------------------------------------------
+// "expose_event" from m_widget, for drawing border
+//-----------------------------------------------------------------------------
+
+#ifndef __WXUNIVERSAL__
+extern "C" {
+static gboolean
+expose_event_border(GtkWidget* widget, GdkEventExpose* event, wxWindow* win)
+{
+    // if this event is not for the GdkWindow the border is drawn on
+    if (win->m_wxwindow == win->m_widget && event->window == widget->window)
+        return false;
+
+    int x = 0;
+    int y = 0;
+    // GtkScrolledWindow is GTK_NO_WINDOW
+    if (GTK_WIDGET_NO_WINDOW(widget))
+    {
+        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;
+        gc = gdk_gc_new(event->window);
+        gdk_gc_set_foreground(gc, &widget->style->black);
+        gdk_draw_rectangle(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;
+        gtk_paint_shadow(
+            widget->style, event->window, GTK_STATE_NORMAL,
+            shadow, &event->area, widget, NULL, x, y, w, h);
+    }
+
+    // no further painting is needed for border-only GdkWindow
+    return win->m_wxwindow == win->m_widget;
+}
+}
+#endif // !__WXUNIVERSAL__
+
 //-----------------------------------------------------------------------------
 // "key_press_event" from any window
 //-----------------------------------------------------------------------------
@@ -987,13 +934,16 @@ gtk_window_key_press_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     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;
@@ -1011,18 +961,7 @@ gtk_window_key_press_callback( GtkWidget *widget,
         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.
@@ -1119,37 +1058,13 @@ gtk_window_key_press_callback( GtkWidget *widget,
         }
     }
 
-    // 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 );
-    }
-
     return ret;
 }
 }
 
 extern "C" {
 static void
-gtk_wxwindow_commit_cb (GtkIMContext *context,
+gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
                         const gchar  *str,
                         wxWindow     *window)
 {
@@ -1162,9 +1077,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
         wxFillOtherKeyEventFields(event,
                                   window, window->m_imData->lastKeyEvent);
     }
+    else
+    {
+        event.SetEventObject( window );
+    }
 
-    const wxWxCharBuffer data(wxGTK_CONV_BACK(str));
-    if( !data )
+    const wxString data(wxGTK_CONV_BACK_SYS(str));
+    if( data.empty() )
         return;
 
     bool ret = false;
@@ -1174,7 +1093,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
     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;
@@ -1182,7 +1101,7 @@ 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;
+        event.m_keyCode = (char)*pstr;
 #endif  // wxUSE_UNICODE
 
         // To conform to the docs we need to translate Ctrl-alpha
@@ -1223,14 +1142,12 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
 
 extern "C" {
 static gboolean
-gtk_window_key_release_callback( GtkWidget *widget,
+gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
                                  GdkEventKey *gdk_event,
                                  wxWindowGTK *win )
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     if (!win->m_hasVMT)
         return FALSE;
 
@@ -1262,33 +1179,25 @@ template<typename T> void InitMouseEvent(wxWindowGTK *win,
                                          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;
-    
+
     if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
     {
         // origin in the upper right corner
-        int virtual_width = win->GetVirtualSize().x;
-        int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) );
-        event.m_x = wxMax( virtual_width, window_width ) - event.m_x;
+        int window_width = win->m_wxwindow->allocation.width;
+        event.m_x = window_width - event.m_x;
     }
 
     event.SetEventObject( win );
@@ -1337,9 +1246,9 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
 
     if (win->m_wxwindow)
     {
-        GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
-        xx += gtk_pizza_get_xoffset( pizza );
-        yy += gtk_pizza_get_yoffset( pizza );
+        wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
+        xx += pizza->m_scroll_x;
+        yy += pizza->m_scroll_y;
     }
 
     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
@@ -1408,8 +1317,6 @@ int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     if (!m_hasVMT)
         return FALSE;
     if (g_blockEventsOnDrag)
@@ -1473,15 +1380,12 @@ gtk_window_button_press_callback( GtkWidget *widget,
 {
     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
 
-    if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
-    {
-        gtk_widget_grab_focus( win->m_wxwindow );
-    }
+    g_lastButtonNumber = gdk_event->button;
 
     // GDK sends surplus button down events
     // before a double click event. We
     // need to filter these out.
-    if (gdk_event->type == GDK_BUTTON_PRESS)
+    if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
     {
         GdkEvent *peek_event = gdk_event_peek();
         if (peek_event)
@@ -1501,10 +1405,7 @@ gtk_window_button_press_callback( GtkWidget *widget,
 
     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 &&
-            !gtk_check_version(2,2,0) &&
             gdk_event->button >= 1 && gdk_event->button <= 3 )
     {
         // Reset GDK internal timestamp variables in order to disable GDK
@@ -1514,7 +1415,6 @@ gtk_window_button_press_callback( GtkWidget *widget,
         display->button_click_time[1] = 0;
         display->button_click_time[0] = 0;
     }
-#endif // GTK 2+
 
     if (gdk_event->button == 1)
     {
@@ -1575,13 +1475,6 @@ 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 )
     {
@@ -1589,6 +1482,8 @@ gtk_window_button_press_callback( GtkWidget *widget,
         return FALSE;
     }
 
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
+
     wxMouseEvent event( event_type );
     InitMouseEvent( win, event, gdk_event );
 
@@ -1608,9 +1503,15 @@ gtk_window_button_press_callback( GtkWidget *widget,
     event.SetEventObject( win );
     event.SetId( win->GetId() );
 
-    if (win->GTKProcessEvent( event ))
-    {
+    bool ret = win->GTKProcessEvent( event );
+    g_lastMouseEvent = NULL;
+    if ( ret )
         return TRUE;
+
+    if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
+        (g_focusWindow != win) /* && win->IsFocusable() */)
+    {
+        win->SetFocus();
     }
 
     if (event_type == wxEVT_RIGHT_DOWN)
@@ -1644,6 +1545,8 @@ gtk_window_button_release_callback( GtkWidget *widget,
 {
     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
 
+    g_lastButtonNumber = 0;
+
     wxEventType event_type = wxEVT_NULL;
 
     switch (gdk_event->button)
@@ -1665,6 +1568,8 @@ gtk_window_button_release_callback( GtkWidget *widget,
             return FALSE;
     }
 
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
+
     wxMouseEvent event( event_type );
     InitMouseEvent( win, event, gdk_event );
 
@@ -1680,7 +1585,11 @@ gtk_window_button_release_callback( GtkWidget *widget,
     event.SetEventObject( win );
     event.SetId( win->GetId() );
 
-    return win->GTKProcessEvent(event);
+    bool ret = win->GTKProcessEvent(event);
+
+    g_lastMouseEvent = NULL;
+
+    return ret;
 }
 
 //-----------------------------------------------------------------------------
@@ -1688,7 +1597,7 @@ gtk_window_button_release_callback( GtkWidget *widget,
 //-----------------------------------------------------------------------------
 
 static gboolean
-gtk_window_motion_notify_callback( GtkWidget *widget,
+gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
                                    GdkEventMotion *gdk_event,
                                    wxWindowGTK *win )
 {
@@ -1704,6 +1613,8 @@ gtk_window_motion_notify_callback( GtkWidget *widget,
         gdk_event->y = y;
     }
 
+    g_lastMouseEvent = (GdkEvent*) gdk_event;
+
     wxMouseEvent event( wxEVT_MOTION );
     InitMouseEvent(win, event, gdk_event);
 
@@ -1746,11 +1657,15 @@ gtk_window_motion_notify_callback( GtkWidget *widget,
         }
     }
 
-    return win->GTKProcessEvent(event);
+    bool ret = win->GTKProcessEvent(event);
+
+    g_lastMouseEvent = NULL;
+
+    return ret;
 }
 
 //-----------------------------------------------------------------------------
-// "scroll_event", (mouse wheel event)
+// "scroll_event" (mouse wheel event)
 //-----------------------------------------------------------------------------
 
 static gboolean
@@ -1758,8 +1673,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     if (gdk_event->direction != GDK_SCROLL_UP &&
         gdk_event->direction != GDK_SCROLL_DOWN)
     {
@@ -1767,15 +1680,7 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
     }
 
     wxMouseEvent event(wxEVT_MOUSEWHEEL);
-    // 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);
+    InitMouseEvent(win, event, gdk_event);
     event.m_linesPerAction = 3;
     event.m_wheelDelta = 120;
     if (gdk_event->direction == GDK_SCROLL_UP)
@@ -1783,14 +1688,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
     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 );
-
     return win->GTKProcessEvent(event);
 }
 
@@ -1810,14 +1707,12 @@ static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
 //-----------------------------------------------------------------------------
 
 static gboolean
-gtk_window_focus_in_callback( GtkWidget *widget,
+gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
                               GdkEventFocus *WXUNUSED(event),
                               wxWindow *win )
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     if (win->m_imData)
         gtk_im_context_focus_in(win->m_imData->context);
 
@@ -1827,11 +1722,6 @@ gtk_window_focus_in_callback( GtkWidget *widget,
     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();
@@ -1867,14 +1757,12 @@ gtk_window_focus_in_callback( GtkWidget *widget,
 //-----------------------------------------------------------------------------
 
 static gboolean
-gtk_window_focus_out_callback( GtkWidget *widget,
-                               GdkEventFocus *gdk_event,
+gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
+                               GdkEventFocus * WXUNUSED(gdk_event),
                                wxWindowGTK *win )
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     if (win->m_imData)
         gtk_im_context_focus_out(win->m_imData->context);
 
@@ -1888,11 +1776,6 @@ gtk_window_focus_out_callback( GtkWidget *widget,
 
     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();
@@ -1902,12 +1785,14 @@ gtk_window_focus_out_callback( GtkWidget *widget,
     }
 #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 )
     {
+        // the event handler might delete the window when it loses focus, so
+        // check whether this is a custom window before calling it
+        const bool has_wxwindow = win->m_wxwindow != NULL;
+
         win->m_hasFocus = false;
 
         wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
@@ -1915,14 +1800,31 @@ gtk_window_focus_out_callback( GtkWidget *widget,
 
         (void)win->GTKProcessEvent( event );
 
-        ret = TRUE;
+        // Disable default focus handling for custom windows
+        // since the default GTK+ handler issues a repaint
+        if ( has_wxwindow )
+            return TRUE;
     }
 
-    // Disable default focus handling for custom windows
-    // since the default GTK+ handler issues a repaint
-    if (win->m_wxwindow)
-        return ret;
+    // continue with normal processing
+    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;
 }
 
@@ -1979,8 +1881,6 @@ gtk_window_leave_callback( GtkWidget *widget,
     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
-    event.SetTimestamp( gdk_event->time );
-    event.SetEventObject( win );
 
     int x = 0;
     int y = 0;
@@ -1988,17 +1888,7 @@ gtk_window_leave_callback( GtkWidget *widget,
 
     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;
+    InitMouseEvent(win, event, gdk_event);
 
     return win->GTKProcessEvent(event);
 }
@@ -2020,13 +1910,11 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
         wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
 
         // generate the corresponding wx event
-        const int orient = win->OrientFromScrollDir(dir);
+        const int orient = wxWindow::OrientFromScrollDir(dir);
         wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
         event.SetEventObject(win);
 
-        win->m_blockValueChanged[dir] = true;
         win->GTKProcessEvent(event);
-        win->m_blockValueChanged[dir] = false;
     }
 }
 
@@ -2039,8 +1927,6 @@ gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
 {
     DEBUG_MAIN_THREAD
 
-    // don't need to install idle handler, its done from "event" signal
-
     g_blockEventsOnScroll = true;
     win->m_mouseButtonDown = true;
 
@@ -2058,11 +1944,12 @@ gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
     {
         g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
 
-        const int orient = win->OrientFromScrollDir(
+        const int orient = wxWindow::OrientFromScrollDir(
                                         win->ScrollDirFromRange(range));
-        wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient);
-        event.SetEventObject(win);
-        win->GTKProcessEvent(event);
+        wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
+                                win->GetScrollPos(orient), orient);
+        evt.SetEventObject(win);
+        win->GTKProcessEvent(evt);
     }
 }
 
@@ -2094,22 +1981,25 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 
-/* We cannot set colours and fonts before the widget has
-   been realized, so we do this directly after realization. */
-
 static void
-gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
+gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
 {
     DEBUG_MAIN_THREAD
 
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
     if (win->m_imData)
     {
-        GtkPizza *pizza = GTK_PIZZA( m_widget );
         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 );
@@ -2118,171 +2008,119 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
 }
 
 //-----------------------------------------------------------------------------
-// "size_allocate"
+// "size_allocate" from m_wxwindow or m_widget
 //-----------------------------------------------------------------------------
 
-static
-void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
-                               GtkAllocation *alloc,
-                               wxWindow *win )
+static void
+size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
 {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    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;
-
-#if 0
-        wxPrintf( wxT("size_allocate ") );
-        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-            wxPrintf( win->GetClassInfo()->GetClassName() );
-        wxPrintf( wxT(" %d %d %d %d\n"),
-                alloc->x,
-                alloc->y,
-                alloc->width,
-                alloc->height );
-#endif
-                
-    GTK_PIZZA(win->m_wxwindow)->m_width = alloc->width;
-
-    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->GTKProcessEvent( 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);
+        }
     }
 }
 
+//-----------------------------------------------------------------------------
+// "grab_broken"
+//-----------------------------------------------------------------------------
 
-#ifdef HAVE_XIM
-    #define WXUNUSED_UNLESS_XIM(param)  param
-#else
-    #define WXUNUSED_UNLESS_XIM(param)  WXUNUSED(param)
-#endif
-
-/* Resize XIM window */
-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_drawable_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->GetEventHandler()->ProcessEvent( evt );
     }
-#endif // HAVE_XIM
+    return false;
 }
+#endif
 
 //-----------------------------------------------------------------------------
-// "realize" from m_wxwindow
+// "style_set"
 //-----------------------------------------------------------------------------
 
-/* Initialize XIM support */
-
-static void
-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;
-    if (!widget) return;
-    if (!gdk_im_ready()) return;
-
-    win->m_icattr = gdk_ic_attr_new();
-    if (!win->m_icattr) return;
-
-    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 (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
-        supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
-
-    attr->style = style = gdk_im_decide_style (supported_style);
-    attr->client_window = widget->window;
-
-    if ((colormap = gtk_widget_get_colormap (widget)) !=
-            gtk_widget_get_default_colormap ())
-    {
-        attrmask |= GDK_IC_PREEDIT_COLORMAP;
-        attr->preedit_colormap = colormap;
-    }
-
-    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)
+    //wxLogDebug(wxT("gtk_window_style_set_callback"));
+    if (win && previous_style)
     {
-        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_drawable_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;
+        wxString name(win->GetName());
+        //wxLogDebug(wxT("gtk_window_style_set_callback %s"), name.c_str());
+        wxSysColourChangedEvent event;
+        event.SetEventObject(win);
 
-            break;
+        win->GTKProcessEvent( event );
     }
+}
+
+} // extern "C"
 
-      win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
+// Connect/disconnect style-set
 
-      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);
+void wxConnectStyleSet(wxWindow* win)
+{
+    if (win->m_wxwindow)
+        g_signal_connect (win->m_wxwindow, "style_set",
+                              G_CALLBACK (gtk_window_style_set_callback), win);
+}
 
-          if (GTK_WIDGET_HAS_FOCUS(widget))
-              gdk_im_begin (win->m_ic, widget->window);
-      }
-#endif // HAVE_XIM
+void wxDisconnectStyleSet(wxWindow* win)
+{
+  if (win->m_wxwindow)
+      g_signal_handlers_disconnect_by_func (win->m_wxwindow,
+                                          (gpointer) gtk_window_style_set_callback,
+                                              win);
 }
 
-} // extern "C"
+// Helper to suspend colour change event event processing while we change a widget's style
+class wxSuspendStyleEvents
+{
+public:
+  wxSuspendStyleEvents(wxWindow* win)
+  {
+    m_win = win;
+    if (win->IsTopLevel())
+      wxDisconnectStyleSet(win);
+  }
+  ~wxSuspendStyleEvents()
+  {
+    if (m_win->IsTopLevel())
+      wxConnectStyleSet(m_win);
+  }
+
+  wxWindow* m_win;
+};
 
 // ----------------------------------------------------------------------------
 // this wxWindowBase function is implemented here (in platform-specific file)
@@ -2310,16 +2148,14 @@ static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
 {
     /* the window might have been scrolled already, do we
        have to adapt the position */
-    GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
-    child->m_x += gtk_pizza_get_xoffset( pizza );
-    child->m_y += gtk_pizza_get_yoffset( pizza );
+    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);
 }
 
 //-----------------------------------------------------------------------------
@@ -2347,6 +2183,8 @@ wxMouseState wxGetMouseState()
     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);
@@ -2381,9 +2219,7 @@ void wxWindowGTK::Init()
     m_width = 0;
     m_height = 0;
 
-    m_sizeSet = false;
     m_hasVMT = false;
-    m_needParent = true;
     m_isBeingDeleted = false;
 
     m_showOnIdle= false;
@@ -2394,24 +2230,19 @@ void wxWindowGTK::Init()
     m_hasScrolling = false;
     m_isScrolling = false;
     m_mouseButtonDown = false;
-    m_blockScrollEvent = false;
 
     // initialize scrolling stuff
     for ( int dir = 0; dir < ScrollDir_Max; dir++ )
     {
         m_scrollBar[dir] = NULL;
         m_scrollPos[dir] = 0;
-        m_blockValueChanged[dir] = false;
     }
 
     m_oldClientWidth =
     m_oldClientHeight = 0;
 
-    m_resizing = false;
-
-    m_insertCallback = (wxInsertChildFunction) NULL;
+    m_insertCallback = wxInsertChildInWindow;
 
-    m_acceptsFocus = false;
     m_hasFocus = false;
 
     m_clipPaintRegion = false;
@@ -2455,70 +2286,77 @@ bool wxWindowGTK::Create( wxWindow *parent,
         return false;
     }
 
-    m_insertCallback = wxInsertChildInWindow;
-
-    m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
-    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-
-    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;
+    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 );
+        gtk_container_set_resize_mode(GTK_CONTAINER(m_widget), GTK_RESIZE_QUEUE);
 
-    gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
 
-    m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
-    m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
+        scroll_class->scrollbar_spacing = 0;
 
-    m_wxwindow = gtk_pizza_new();
+        // 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);
+            }
+        }
 
-#ifndef __WXUNIVERSAL__
-    GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+        if (HasFlag(wxALWAYS_SHOW_SB))
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
 
-    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 );
-    }
-    else
-    {
-        gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
-    }
-#endif // __WXUNIVERSAL__
+            scrolledWindow->hscrollbar_visible = TRUE;
+            scrolledWindow->vscrollbar_visible = TRUE;
+        }
+        else
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        }
 
-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+        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 );
 
-    GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-    m_acceptsFocus = true;
+        gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
-    // 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",
+        // 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_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",
+            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);
+            g_signal_handler_block(m_scrollBar[dir], handler_id);
 
-        // these handlers get notified when scrollbar slider moves
-        g_signal_connect(m_scrollBar[dir], "value_changed",
+            // 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 );
+        gtk_widget_show( m_wxwindow );
+    }
 
     if (m_parent)
         m_parent->DoAddChild( this );
@@ -2561,17 +2399,10 @@ wxWindowGTK::~wxWindowGTK()
     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;
 
-    if (m_wxwindow)
+    if (m_wxwindow && (m_wxwindow != m_widget))
     {
         gtk_widget_destroy( m_wxwindow );
         m_wxwindow = (GtkWidget*) NULL;
@@ -2586,7 +2417,10 @@ wxWindowGTK::~wxWindowGTK()
 
 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.
@@ -2609,13 +2443,11 @@ void wxWindowGTK::PostCreation()
         {
             // 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);
 
             if (GetLayoutDirection() == wxLayout_LeftToRight)
-                gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
+                gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
         }
 
         // Create input method handler
@@ -2627,9 +2459,14 @@ void wxWindowGTK::PostCreation()
         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(wxBORDER_SIMPLE | wxBORDER_RAISED | wxBORDER_SUNKEN))
+        {
+            g_signal_connect(m_widget, "expose_event",
+                G_CALLBACK(expose_event_border), this);
+        }
+#endif
     }
 
     // focus handling
@@ -2655,6 +2492,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();
@@ -2666,21 +2511,37 @@ void wxWindowGTK::PostCreation()
     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);
+        g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
+            G_CALLBACK(size_allocate), this);
+    }
 
-        // Initialize XIM support
-        g_signal_connect (m_wxwindow, "realize",
-                          G_CALLBACK (gtk_wxwindow_realized_callback), this);
+    if (m_wxwindow)
+    {
+#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
+    }
 
-        // And resize XIM window
-        g_signal_connect (m_wxwindow, "size_allocate",
-                          G_CALLBACK (gtk_wxwindow_size_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
     }
 
+#if wxUSE_COMBOBOX
     if (GTK_IS_COMBO(m_widget))
     {
         GtkCombo *gcombo = GTK_COMBO(m_widget);
@@ -2688,17 +2549,18 @@ void wxWindowGTK::PostCreation()
         g_signal_connect (gcombo->entry, "size_request",
                           G_CALLBACK (wxgtk_combo_size_request_callback),
                           this);
-    }
+    } else
+#endif // wxUSE_COMBOBOX
 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
-    else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
+    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
-    else
+    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
@@ -2741,6 +2603,10 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
                       G_CALLBACK (gtk_window_enter_callback), this);
     g_signal_connect (widget, "leave_notify_event",
                       G_CALLBACK (gtk_window_leave_callback), this);
+
+    if (IsTopLevel() && m_wxwindow)
+        g_signal_connect (m_wxwindow, "style_set",
+                              G_CALLBACK (gtk_window_style_set_callback), this);
 }
 
 bool wxWindowGTK::Destroy()
@@ -2754,9 +2620,26 @@ bool wxWindowGTK::Destroy()
 
 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
 {
+    gtk_widget_set_size_request(m_widget, width, height);
     // inform the parent to perform the move
-    gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
-    
+    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 )
@@ -2764,13 +2647,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") );
 
-/*
-    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))
@@ -2790,51 +2666,19 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
             height = sizeBest.y;
     }
 
+    const wxSize oldSize(m_width, m_height);
     if (width != -1)
         m_width = width;
     if (height != -1)
         m_height = height;
 
-    int minWidth  = GetMinWidth(),
-        minHeight = GetMinHeight(),
-        maxWidth  = GetMaxWidth(),
-        maxHeight = GetMaxHeight();
+    ConstrainSize();
 
-    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 wxUSE_TOOLBAR_NATIVE
-    if (wxDynamicCast(GetParent(), wxToolBar))
-    {
-       // don't take the x,y values, they're wrong because toolbar sets them
-       GtkWidget  *widget = GTK_WIDGET(m_widget);
-       gtk_widget_set_size_request (widget, m_width, m_height);
-    }
-    else
-#endif
-    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+    if (m_parent->m_wxwindow)
     {
-        // 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;
-    }
-    else
-    {
-        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
-        if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
-        {
-            if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
-            if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );
-        }
-        else
-        {
-            m_x = x + gtk_pizza_get_xoffset( pizza );
-            m_y = y + gtk_pizza_get_yoffset( pizza );
-        }
+        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;
@@ -2852,42 +2696,30 @@ 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;
-                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 );
     }
 
-    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 );
-    }
-
-/*
-    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 );
-*/
 
-    if (!m_nativeSizeEvent)
-    {
-        wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-        event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent( event );
+        gtk_widget_queue_resize(m_widget);
+        if (!m_nativeSizeEvent)
+        {
+            wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+        }
     }
-
-    m_resizing = false;
 }
 
 bool wxWindowGTK::GtkShowFromOnIdle()
@@ -2940,9 +2772,9 @@ void wxWindowGTK::OnInternalIdle()
            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() );
 
@@ -2962,7 +2794,7 @@ void wxWindowGTK::OnInternalIdle()
         }
     }
 
-    if (wxUpdateUIEvent::CanUpdate(this))
+    if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
 }
 
@@ -2978,36 +2810,9 @@ void wxWindowGTK::DoSetClientSize( int width, int height )
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
-    if (m_wxwindow)
-    {
-        int dw = 0;
-        int dh = 0;
-
-        if (m_hasScrolling)
-        {
-            GetScrollbarWidth(m_widget, dw, dh);
-        }
-
-#ifndef __WXUNIVERSAL__
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            // shadow border size is 2
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
-        {
-            // simple border size is 1
-            dw += 1 * 2;
-            dh += 1 * 2;
-        }
-#endif // __WXUNIVERSAL__
-
-        width += dw;
-        height += dh;
-    }
-
-    SetSize(width, height);
+    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
@@ -3023,24 +2828,12 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
         int dh = 0;
 
         if (m_hasScrolling)
-        {
             GetScrollbarWidth(m_widget, dw, dh);
-        }
 
-#ifndef __WXUNIVERSAL__
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            // shadow border size is 2
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
-        {
-            // simple border size is 1
-            dw += 1 * 2;
-            dh += 1 * 2;
-        }
-#endif // __WXUNIVERSAL__
+        int border_x, border_y;
+        WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
+        dw += 2 * border_x;
+        dh += 2 * border_y;
 
         w -= dw;
         h -= dh;
@@ -3060,11 +2853,33 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const
 
     int dx = 0;
     int dy = 0;
-    if (m_parent && m_parent->m_wxwindow)
+    if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
     {
-        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
-        dx = gtk_pizza_get_xoffset( pizza );
-        dy = gtk_pizza_get_yoffset( pizza );
+        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)
+    {
+        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;
@@ -3079,7 +2894,7 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
-        source = GTK_PIZZA(m_wxwindow)->bin_window;
+        source = m_wxwindow->window;
     else
         source = m_widget->window;
 
@@ -3096,7 +2911,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;
 }
 
@@ -3108,7 +2931,7 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
-        source = GTK_PIZZA(m_wxwindow)->bin_window;
+        source = m_wxwindow->window;
     else
         source = m_widget->window;
 
@@ -3125,7 +2948,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;
 }
 
@@ -3160,40 +2989,13 @@ bool wxWindowGTK::Show( bool show )
     return true;
 }
 
-static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
+void wxWindowGTK::DoEnable( 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);
-    }
-}
-
-bool wxWindowGTK::Enable( 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 );
-    if ( m_wxwindow )
+    if (m_wxwindow && (m_wxwindow != m_widget))
         gtk_widget_set_sensitive( m_wxwindow, enable );
-
-    wxWindowNotifyEnable(this, enable);
-
-    return true;
 }
 
 int wxWindowGTK::GetCharHeight() const
@@ -3203,9 +3005,7 @@ int wxWindowGTK::GetCharHeight() const
     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;
@@ -3231,9 +3031,7 @@ int wxWindowGTK::GetCharWidth() const
     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;
@@ -3334,15 +3132,31 @@ void wxWindowGTK::SetFocus()
 
     if (m_wxwindow)
     {
+        // wxWindow::SetFocus() should really set the focus to
+        // this control, whatever the flags are
+        if (!GTK_WIDGET_CAN_FOCUS(m_wxwindow))
+            GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+
         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
         {
             gtk_widget_grab_focus (m_wxwindow);
         }
     }
-    else if (m_widget)
+    else
     {
+        // wxWindow::SetFocus() should really set the focus to
+        // this control, whatever the flags are
+        if (!GTK_WIDGET_CAN_FOCUS(m_widget))
+            GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
+
         if (GTK_IS_CONTAINER(m_widget))
         {
+            if (GTK_IS_RADIO_BUTTON(m_widget))
+            {
+                gtk_widget_grab_focus (m_widget);
+                return;
+            }
+
             gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
         }
         else
@@ -3378,9 +3192,20 @@ void wxWindowGTK::SetFocus()
     }
 }
 
-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 )
@@ -3430,11 +3255,8 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
-
     wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
 
-    wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
-
     /* add to list */
     AddChild( child );
 
@@ -3446,22 +3268,20 @@ void wxWindowGTK::AddChild(wxWindowBase *child)
 {
     wxWindowBase::AddChild(child);
     m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();
 }
 
 void wxWindowGTK::RemoveChild(wxWindowBase *child)
 {
     wxWindowBase::RemoveChild(child);
     m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();
 }
 
 /* static */
 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
 {
-    return gtk_widget_get_direction(GTK_WIDGET(widget)) == GTK_TEXT_DIR_RTL
+    return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
                 ? wxLayout_RightToLeft
                 : wxLayout_LeftToRight;
 }
@@ -3471,7 +3291,7 @@ void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
 {
     wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
 
-    gtk_widget_set_direction(GTK_WIDGET(widget),
+    gtk_widget_set_direction(widget,
                              dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
                                                          : GTK_TEXT_DIR_LTR);
 }
@@ -3501,8 +3321,8 @@ void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
         return;
 
     GTKSetLayout(m_widget, dir);
-    
-    if (m_wxwindow)
+
+    if (m_wxwindow && (m_wxwindow != m_widget))
         GTKSetLayout(m_wxwindow, dir);
 }
 
@@ -3511,7 +3331,7 @@ wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
                                       wxCoord WXUNUSED(width),
                                       wxCoord WXUNUSED(widthTotal)) const
 {
-    // We now mirrors the coordinates of RTL windows in GtkPizza
+    // We now mirror the coordinates of RTL windows in wxPizza
     return x;
 }
 
@@ -3519,8 +3339,31 @@ void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
 {
     wxWindowBase::DoMoveInTabOrder(win, move);
     m_dirtyTabOrder = true;
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();
+}
+
+bool wxWindowGTK::DoNavigateIn(int flags)
+{
+    if ( flags & wxNavigationKeyEvent::WinChange )
+    {
+        wxFAIL_MSG( _T("not implemented") );
+
+        return false;
+    }
+    else // navigate inside the container
+    {
+        wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
+        wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
+
+        GtkDirectionType dir;
+        dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
+                                                      : GTK_DIR_TAB_BACKWARD;
+
+        gboolean rc;
+        g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
+
+        return rc == TRUE;
+    }
 }
 
 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
@@ -3671,7 +3514,7 @@ void wxWindowGTK::WarpPointer( int x, int y )
 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
     else
         window = GetConnectWidget()->window;
 
@@ -3722,7 +3565,8 @@ bool wxWindowGTK::ScrollPages(int pages)
     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;
@@ -3731,7 +3575,7 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
 
     if (m_wxwindow)
     {
-        if (!GTK_PIZZA(m_wxwindow)->bin_window) return;
+        if (m_wxwindow->window == NULL) return;
 
         GdkRectangle gdk_rect,
                     *p;
@@ -3741,16 +3585,17 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
             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 = NULL;
         }
-        
-        p = NULL;
 
-        gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
+        gdk_window_invalidate_rect(m_wxwindow->window, p, true);
     }
 }
 
@@ -3767,9 +3612,9 @@ void wxWindowGTK::Update()
 
 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_widget && m_widget->window)
+    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
@@ -3808,18 +3653,17 @@ void wxWindowGTK::GtkSendPaintEvents()
     // Clip to paint region in wxClientDC
     m_clipPaintRegion = true;
 
-    wxRegion maybe_rtl_region = m_updateRegion;
-    
-#if 0
+    m_nativeUpdateRegion = m_updateRegion;
+
     if (GetLayoutDirection() == wxLayout_RightToLeft)
     {
-        maybe_rtl_region.Clear();
-        
+        // Transform m_updateRegion under RTL
+        m_updateRegion.Clear();
+
         gint width;
-        gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window,
-                                 NULL, NULL, &width, NULL, NULL );
-        
-        wxRegionIterator upd( m_updateRegion );
+        gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
+
+        wxRegionIterator upd( m_nativeUpdateRegion );
         while (upd)
         {
             wxRect rect;
@@ -3827,17 +3671,13 @@ void wxWindowGTK::GtkSendPaintEvents()
             rect.y = upd.GetY();
             rect.width = upd.GetWidth();
             rect.height = upd.GetHeight();
-            
+
             rect.x = width - rect.x - rect.width;
-            maybe_rtl_region.Union( rect );
-            
+            m_updateRegion.Union( rect );
+
             ++upd;
         }
     }
-#endif
-    
-    // widget to draw on
-    GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
 
     if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
     {
@@ -3848,7 +3688,7 @@ void wxWindowGTK::GtkSendPaintEvents()
 
         if (GTK_WIDGET_MAPPED(parent->m_widget))
         {
-            wxRegionIterator upd( m_updateRegion );
+            wxRegionIterator upd( m_nativeUpdateRegion );
             while (upd)
             {
                 GdkRectangle rect;
@@ -3858,7 +3698,7 @@ void wxWindowGTK::GtkSendPaintEvents()
                 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,
@@ -3872,19 +3712,23 @@ void wxWindowGTK::GtkSendPaintEvents()
     }
     else
     {
-        m_updateRegion = maybe_rtl_region;
-    
         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 );
 
         GetEventHandler()->ProcessEvent(erase_event);
     }
 
-    m_updateRegion = maybe_rtl_region;
-        
     wxNcPaintEvent nc_paint_event( GetId() );
     nc_paint_event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( nc_paint_event );
@@ -3896,6 +3740,7 @@ void wxWindowGTK::GtkSendPaintEvents()
     m_clipPaintRegion = false;
 
     m_updateRegion.Clear();
+    m_nativeUpdateRegion.Clear();
 }
 
 void wxWindowGTK::SetDoubleBuffered( bool on )
@@ -3906,6 +3751,11 @@ void wxWindowGTK::SetDoubleBuffered( bool on )
         gtk_widget_set_double_buffered( m_wxwindow, on );
 }
 
+bool wxWindowGTK::IsDoubleBuffered() const
+{
+    return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
+}
+
 void wxWindowGTK::ClearBackground()
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3920,10 +3770,9 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
         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
 
@@ -3993,45 +3842,54 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
             pango_font_description_copy( m_font.GetNativeFontInfo()->description );
     }
 
+    int flagsNormal = 0,
+        flagsPrelight = 0,
+        flagsActive = 0,
+        flagsInsensitive = 0;
+
     if ( m_foregroundColour.Ok() )
     {
         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() )
     {
         const GdkColor *bg = m_backgroundColour.GetColor();
 
-        style->bg[GTK_STATE_NORMAL] = *bg;
+        style->bg[GTK_STATE_NORMAL] =
         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->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->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->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;
 }
 
@@ -4050,6 +3908,8 @@ void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
 
 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
 {
+    wxSuspendStyleEvents s(static_cast<wxWindow*>(this));
+
     if (m_wxwindow)
         gtk_widget_modify_style(m_wxwindow, style);
     else
@@ -4062,11 +3922,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
 
     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
-            window = GetConnectWidget()->window;
+        {
+            GtkWidget * const w = GetConnectWidget();
+            window = w ? w->window : NULL;
+        }
 
         if (window)
         {
@@ -4079,9 +3944,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
 #endif
             m_needsStyleChange = false;
         }
-        else
+        else // window not realized yet
+        {
             // Do in OnIdle, because the window is not yet available
             m_needsStyleChange = true;
+        }
 
         // Don't apply widget style, or we get a grey background
     }
@@ -4131,7 +3998,7 @@ bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
 
 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 {
-    return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window;
+    return m_wxwindow ? m_wxwindow->window : m_widget->window;
 }
 
 bool wxWindowGTK::SetFont( const wxFont &font )
@@ -4154,7 +4021,7 @@ void wxWindowGTK::DoCaptureMouse()
 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
     else
         window = GetConnectWidget()->window;
 
@@ -4187,7 +4054,7 @@ void wxWindowGTK::DoReleaseMouse()
 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
-        window = GTK_PIZZA(m_wxwindow)->bin_window;
+        window = m_wxwindow->window;
     else
         window = GetConnectWidget()->window;
 
@@ -4197,6 +4064,14 @@ void wxWindowGTK::DoReleaseMouse()
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
 }
 
+void wxWindowGTK::GTKReleaseMouseAndNotify()
+{
+    DoReleaseMouse();
+    wxMouseCaptureLostEvent evt(GetId());
+    evt.SetEventObject( this );
+    GetEventHandler()->ProcessEvent( evt );
+}
+
 /* static */
 wxWindow *wxWindowBase::GetCapture()
 {
@@ -4208,26 +4083,15 @@ bool wxWindowGTK::IsRetained() const
     return false;
 }
 
-void wxWindowGTK::BlockScrollEvent()
-{
-    wxASSERT(!m_blockScrollEvent);
-    m_blockScrollEvent = true;
-}
-
-void wxWindowGTK::UnblockScrollEvent()
-{
-    wxASSERT(m_blockScrollEvent);
-    m_blockScrollEvent = false;
-}
-
 void wxWindowGTK::SetScrollbar(int orient,
                                int pos,
                                int thumbVisible,
                                int range,
                                bool WXUNUSED(update))
 {
-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+    const int dir = ScrollDirFromOrient(orient);
+    GtkRange* const sb = m_scrollBar[dir];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );
 
     if (range > 0)
     {
@@ -4240,67 +4104,65 @@ void wxWindowGTK::SetScrollbar(int orient,
         thumbVisible = 1;
     }
 
-    if (pos > range - thumbVisible)
-        pos = range - thumbVisible;
-    if (pos < 0)
-        pos = 0;
-    GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment;
+    GtkAdjustment * const adj = sb->adjustment;
     adj->step_increment = 1;
     adj->page_increment =
     adj->page_size = thumbVisible;
-    adj->upper = range;
-    SetScrollPos(orient, pos);
-    gtk_adjustment_changed(adj);
+    adj->value = pos;
+
+    g_signal_handlers_block_by_func(
+        sb, (void*)gtk_scrollbar_value_changed, this);
+
+    gtk_range_set_range(sb, 0, range);
+    m_scrollPos[dir] = sb->adjustment->value;
+
+    g_signal_handlers_unblock_by_func(
+        sb, (void*)gtk_scrollbar_value_changed, this);
 }
 
 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
 {
-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+    const int dir = ScrollDirFromOrient(orient);
+    GtkRange * const sb = m_scrollBar[dir];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );
 
     // This check is more than an optimization. Without it, the slider
     //   will not move smoothly while tracking when using wxScrollHelper.
     if (GetScrollPos(orient) != pos)
     {
-        const int dir = ScrollDirFromOrient(orient);
-        GtkAdjustment* adj = m_scrollBar[dir]->adjustment;
-        const int max = int(adj->upper - adj->page_size);
-        if (pos > max)
-            pos = max;
-        if (pos < 0)
-            pos = 0;
-        m_scrollPos[dir] =
-        adj->value = pos;
-        // If a "value_changed" signal emission is not already in progress
-        if (!m_blockValueChanged[dir])
-        {
-            gtk_adjustment_value_changed(adj);
-        }
+        g_signal_handlers_block_by_func(
+            sb, (void*)gtk_scrollbar_value_changed, this);
+
+        gtk_range_set_value(sb, pos);
+        m_scrollPos[dir] = sb->adjustment->value;
+
+        g_signal_handlers_unblock_by_func(
+            sb, (void*)gtk_scrollbar_value_changed, this);
     }
 }
 
 int wxWindowGTK::GetScrollThumb(int orient) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
 
-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size);
+    return int(sb->adjustment->page_size);
 }
 
 int wxWindowGTK::GetScrollPos( int orient ) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
 
-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->value + 0.5);
+    return int(sb->adjustment->value + 0.5);
 }
 
 int wxWindowGTK::GetScrollRange( int orient ) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
 
-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper);
+    return int(sb->adjustment->upper);
 }
 
 // Determine if increment is the same as +/-x, allowing for some small
@@ -4316,14 +4178,13 @@ wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
 {
     DEBUG_MAIN_THREAD
 
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
     wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
 
     const int barIndex = range == m_scrollBar[1];
     GtkAdjustment* adj = range->adjustment;
+
     const int value = int(adj->value + 0.5);
+
     // save previous position
     const double oldPos = m_scrollPos[barIndex];
     // update current position
@@ -4369,9 +4230,31 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
     m_clipPaintRegion = true;
 
-    gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+    WX_PIZZA(m_wxwindow)->scroll(dx, dy);
 
     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)
@@ -4387,8 +4270,11 @@ void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
             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;
 
@@ -4452,3 +4338,11 @@ void wxRemoveGrab(wxWindow* window)
 {
     gtk_grab_remove( (GtkWidget*) window->GetHandle() );
 }
+
+GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
+{
+    GdkWindow* window = NULL;
+    if (m_wxwindow)
+        window = m_wxwindow->window;
+    return window;
+}