incomplete paste error

[wxWidgets.git] / src / gtk / window.cpp

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 4f9ce50f42ab0413d954e277e9f1db3c03cb7cd9..e6d8aeba8ab5ee75587771f11ded2a00fd5385c1 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -32,12 +32,18 @@
 #include "wx/caret.h"
 #include "wx/fontutil.h"
 #include "wx/sysopt.h"
 #include "wx/caret.h"
 #include "wx/fontutil.h"
 #include "wx/sysopt.h"

+#ifdef __WXGTK3__
+    #include "wx/gtk/dc.h"
+#endif

 
 #include <ctype.h>
 
 
 #include <ctype.h>
 

+#include <gtk/gtk.h>

 #include "wx/gtk/private.h"
 #include "wx/gtk/private.h"

-#include "wx/gtk/private/win_gtk.h"
+#include "wx/gtk/private/gtk2-compat.h"

 #include "wx/gtk/private/event.h"
 #include "wx/gtk/private/event.h"

+#include "wx/gtk/private/win_gtk.h"
+#include "wx/private/textmeasure.h"

 using namespace wxGTKImpl;
 
 #ifdef GDK_WINDOWING_X11
 using namespace wxGTKImpl;
 
 #ifdef GDK_WINDOWING_X11


@@ -48,7 +54,7 @@ typedef guint KeySym;
 #endif
 
 #include <gdk/gdkkeysyms.h>
 #endif
 
 #include <gdk/gdkkeysyms.h>

-#if GTK_CHECK_VERSION(3,0,0)
+#ifdef __WXGTK3__

 #include <gdk/gdkkeysyms-compat.h>
 #endif
 
 #include <gdk/gdkkeysyms-compat.h>
 #endif
 


@@ -221,36 +227,59 @@ int          g_lastButtonNumber = 0;
 // the trace mask used for the focus debugging messages
 #define TRACE_FOCUS wxT("focus")
 
 // the trace mask used for the focus debugging messages
 #define TRACE_FOCUS wxT("focus")
 

+// A handy function to run from under gdb to show information about the given
+// GtkWidget. Right now it only shows its type, we could enhance it to show
+// more information later but this is already pretty useful.
+const char* wxDumpGtkWidget(GtkWidget* w)
+{
+    static wxString s;
+    s.Printf("GtkWidget %p, type \"%s\"", w, G_OBJECT_TYPE_NAME(w));
+
+    return s.c_str();
+}
+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// "expose_event" of m_wxwindow
+// "expose_event"/"draw" from m_wxwindow

 //-----------------------------------------------------------------------------
 
 extern "C" {
 //-----------------------------------------------------------------------------
 
 extern "C" {

-static gboolean
-gtk_window_expose_callback( GtkWidget*,
-                            GdkEventExpose *gdk_event,
-                            wxWindow *win )
+#ifdef __WXGTK3__
+static gboolean draw(GtkWidget*, cairo_t* cr, wxWindow* win)
+{
+    if (gtk_cairo_should_draw_window(cr, win->GTKGetDrawingWindow()))
+        win->GTKSendPaintEvents(cr);
+
+    return false;
+}
+#else // !__WXGTK3__
+static gboolean expose_event(GtkWidget*, GdkEventExpose* gdk_event, wxWindow* win)

 {
     if (gdk_event->window == win->GTKGetDrawingWindow())
 {
     if (gdk_event->window == win->GTKGetDrawingWindow())

-    {
-        win->GetUpdateRegion() = wxRegion( gdk_event->region );
-        win->GtkSendPaintEvents();
-    }
-    // Let parent window draw window-less widgets
-    return FALSE;
+        win->GTKSendPaintEvents(gdk_event->region);
+
+    return false;

 }
 }

+#endif // !__WXGTK3__

 }
 
 #ifndef __WXUNIVERSAL__
 //-----------------------------------------------------------------------------
 }
 
 #ifndef __WXUNIVERSAL__
 //-----------------------------------------------------------------------------

-// "expose_event" from m_wxwindow->parent, for drawing border
+// "expose_event"/"draw" from m_wxwindow->parent, for drawing border

 //-----------------------------------------------------------------------------
 
 extern "C" {
 static gboolean
 //-----------------------------------------------------------------------------
 
 extern "C" {
 static gboolean

-expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+#ifdef __WXGTK3__
+draw_border(GtkWidget*, cairo_t* cr, wxWindow* win)
+#else
+draw_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+#endif

 {
 {

+#ifdef __WXGTK3__
+    if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_parent_window(win->m_wxwindow)))
+#else

     if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))
     if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))

+#endif

         return false;
 
     if (!win->IsShown())
         return false;
 
     if (!win->IsShown())


@@ -268,30 +297,55 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
 
     if (win->HasFlag(wxBORDER_SIMPLE))
     {
 
     if (win->HasFlag(wxBORDER_SIMPLE))
     {

+#ifdef __WXGTK3__
+        GtkStyleContext* sc = gtk_widget_get_style_context(win->m_wxwindow);
+        GdkRGBA c;
+        gtk_style_context_get_border_color(sc, GTK_STATE_FLAG_NORMAL, &c);
+        gdk_cairo_set_source_rgba(cr, &c);
+        cairo_set_line_width(cr, 1);
+        cairo_rectangle(cr, x + 0.5, y + 0.5, w - 1, h - 1);
+        cairo_stroke(cr);
+#else

         gdk_draw_rectangle(gdk_event->window,
             gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1);
         gdk_draw_rectangle(gdk_event->window,
             gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1);

+#endif

     }
     }

-    else
+    else if (win->HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))

     {
     {

+#ifdef __WXGTK3__
+        //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN
+        GtkStyleContext* sc;
+        if (win->HasFlag(wxHSCROLL | wxVSCROLL))
+            sc = gtk_widget_get_style_context(wxGTKPrivate::GetTreeWidget());
+        else
+            sc = gtk_widget_get_style_context(wxGTKPrivate::GetEntryWidget());
+
+        gtk_render_frame(sc, cr, x, y, w, h);
+#else // !__WXGTK3__

         GtkShadowType shadow = GTK_SHADOW_IN;
         if (win->HasFlag(wxBORDER_RAISED))
             shadow = GTK_SHADOW_OUT;
 
         GtkShadowType shadow = GTK_SHADOW_IN;
         if (win->HasFlag(wxBORDER_RAISED))
             shadow = GTK_SHADOW_OUT;
 

-        // Style detail to use
+        GtkStyle* style;

         const char* detail;
         const char* detail;

-        if (win->m_widget == win->m_wxwindow)
-            // for non-scrollable wxWindows
-            detail = "entry";
-        else
-            // for scrollable ones
+        if (win->HasFlag(wxHSCROLL | wxVSCROLL))
+        {
+            style = gtk_widget_get_style(wxGTKPrivate::GetTreeWidget());

             detail = "viewport";
             detail = "viewport";

+        }
+        else
+        {
+            style = gtk_widget_get_style(wxGTKPrivate::GetEntryWidget());
+            detail = "entry";
+        }

 
         // clip rect is required to avoid painting background
         // over upper left (w,h) of parent window
         GdkRectangle clipRect = { x, y, w, h };
         gtk_paint_shadow(
 
         // clip rect is required to avoid painting background
         // over upper left (w,h) of parent window
         GdkRectangle clipRect = { x, y, w, h };
         gtk_paint_shadow(

-           gtk_widget_get_style(win->m_wxwindow), gdk_event->window, GTK_STATE_NORMAL,
-           shadow, &clipRect, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
+           style, gdk_event->window, GTK_STATE_NORMAL,
+           shadow, &clipRect, widget, detail, x, y, w, h);
+#endif // !__WXGTK3__

     }
     return false;
 }
     }
     return false;
 }


@@ -308,13 +362,16 @@ parent_set(GtkWidget* widget, GtkWidget* old_parent, wxWindow* win)
     if (old_parent)
     {
         g_signal_handlers_disconnect_by_func(
     if (old_parent)
     {
         g_signal_handlers_disconnect_by_func(

-            old_parent, (void*)expose_event_border, win);
+            old_parent, (void*)draw_border, win);

     }
     GtkWidget* parent = gtk_widget_get_parent(widget);
     if (parent)
     {
     }
     GtkWidget* parent = gtk_widget_get_parent(widget);
     if (parent)
     {

-        g_signal_connect_after(parent, "expose_event",
-            G_CALLBACK(expose_event_border), win);
+#ifdef __WXGTK3__
+        g_signal_connect_after(parent, "draw", G_CALLBACK(draw_border), win);
+#else
+        g_signal_connect_after(parent, "expose_event", G_CALLBACK(draw_border), win);
+#endif

     }
 }
 }
     }
 }
 }


@@ -621,6 +678,16 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event,
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
     event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
 
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
     event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
 

+    // At least with current Linux systems, MOD5 corresponds to AltGr key and
+    // we represent it, for consistency with Windows, which really allows to
+    // use Ctrl+Alt as a replacement for AltGr if this key is not present, as a
+    // combination of these two modifiers.
+    if ( gdk_event->state & GDK_MOD5_MASK )
+    {
+        event.m_controlDown =
+        event.m_altDown = true;
+    }
+

     // Normally we take the state of modifiers directly from the low level GDK
     // event but unfortunately GDK uses a different convention from MSW for the
     // key events corresponding to the modifier keys themselves: in it, when
     // Normally we take the state of modifiers directly from the low level GDK
     // event but unfortunately GDK uses a different convention from MSW for the
     // key events corresponding to the modifier keys themselves: in it, when


@@ -666,8 +733,6 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event,
     event.m_rawCode = (wxUint32) gdk_event->keyval;
     event.m_rawFlags = gdk_event->hardware_keycode;
 
     event.m_rawCode = (wxUint32) gdk_event->keyval;
     event.m_rawFlags = gdk_event->hardware_keycode;
 

-    wxGetMousePosition(&event.m_x, &event.m_y);
-    win->ScreenToClient(&event.m_x, &event.m_y);

     event.SetEventObject( win );
 }
 
     event.SetEventObject( win );
 }
 


@@ -777,7 +842,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
     event.m_keyCode = key_code;
 
 #if wxUSE_UNICODE
     event.m_keyCode = key_code;
 
 #if wxUSE_UNICODE

-    event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym);
+    event.m_uniChar = gdk_keyval_to_unicode(key_code);

     if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE )
     {
         // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
     if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE )
     {
         // Set Unicode key code to the ASCII equivalent for compatibility. E.g.


@@ -794,22 +859,6 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
 }
 
 
 }
 
 

-struct wxGtkIMData
-{
-    GtkIMContext *context;
-    GdkEventKey  *lastKeyEvent;
-
-    wxGtkIMData()
-    {
-        context = gtk_im_multicontext_new();
-        lastKeyEvent = NULL;
-    }
-    ~wxGtkIMData()
-    {
-        g_object_unref (context);
-    }
-};
-

 namespace
 {
 
 namespace
 {
 


@@ -886,8 +935,6 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
                                GdkEventKey *gdk_event,
                                wxWindow *win )
 {
                                GdkEventKey *gdk_event,
                                wxWindow *win )
 {

-    if (!win->m_hasVMT)
-        return FALSE;

     if (g_blockEventsOnDrag)
         return FALSE;
 
     if (g_blockEventsOnDrag)
         return FALSE;
 


@@ -906,45 +953,15 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
             return TRUE;
         }
 
             return TRUE;
         }
 

-        // Emit KEY_DOWN event
-        ret = win->HandleWindowEvent( event );
-    }
-    else
-    {
-        // Return after IM processing as we cannot do
-        // anything with it anyhow.
-        return_after_IM = true;
-    }
-
-    if (!ret && win->m_imData)
-    {
-        win->m_imData->lastKeyEvent = gdk_event;
-
-        // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
-        // docs, if IM filter returns true, no further processing should be done.
-        // we should send the key_down event anyway.
-        bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
-        win->m_imData->lastKeyEvent = NULL;
-        if (intercepted_by_IM)
-        {
-            wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
-            return TRUE;
-        }
-    }
-
-    if (return_after_IM)
-        return FALSE;
-
+        // Next check for accelerators.

 #if wxUSE_ACCEL
 #if wxUSE_ACCEL

-    if (!ret)
-    {

         wxWindowGTK *ancestor = win;
         while (ancestor)
         {
             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
             if (command != -1)
             {
         wxWindowGTK *ancestor = win;
         while (ancestor)
         {
             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
             if (command != -1)
             {

-                wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
+                wxCommandEvent menu_event( wxEVT_MENU, command );

                 ret = ancestor->HandleWindowEvent( menu_event );
 
                 if ( !ret )
                 ret = ancestor->HandleWindowEvent( menu_event );
 
                 if ( !ret )


@@ -952,7 +969,7 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
                     // if the accelerator wasn't handled as menu event, try
                     // it as button click (for compatibility with other
                     // platforms):
                     // if the accelerator wasn't handled as menu event, try
                     // it as button click (for compatibility with other
                     // platforms):

-                    wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
+                    wxCommandEvent button_event( wxEVT_BUTTON, command );

                     ret = ancestor->HandleWindowEvent( button_event );
                 }
 
                     ret = ancestor->HandleWindowEvent( button_event );
                 }
 


@@ -962,17 +979,50 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
                 break;
             ancestor = ancestor->GetParent();
         }
                 break;
             ancestor = ancestor->GetParent();
         }

-    }

 #endif // wxUSE_ACCEL
 
 #endif // wxUSE_ACCEL
 

+        // If not an accelerator, then emit KEY_DOWN event
+        if ( !ret )
+            ret = win->HandleWindowEvent( event );
+    }
+    else
+    {
+        // Return after IM processing as we cannot do
+        // anything with it anyhow.
+        return_after_IM = true;
+    }
+
+    if ( !ret )
+    {
+        // Indicate that IM handling is in process by setting this pointer
+        // (which will remain valid for all the code called during IM key
+        // handling).
+        win->m_imKeyEvent = gdk_event;
+
+        // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
+        // docs, if IM filter returns true, no further processing should be done.
+        // we should send the key_down event anyway.
+        const int intercepted_by_IM = win->GTKIMFilterKeypress(gdk_event);
+
+        win->m_imKeyEvent = NULL;
+
+        if ( intercepted_by_IM )
+        {
+            wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
+            return TRUE;
+        }
+    }
+
+    if (return_after_IM)
+        return FALSE;
+

     // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
     // will only be sent if it is not in an accelerator table.
     if (!ret)
     {
     // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
     // will only be sent if it is not in an accelerator table.
     if (!ret)
     {

-        long key_code;

         KeySym keysym = gdk_event->keyval;
         // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
         KeySym keysym = gdk_event->keyval;
         // Find key code for EVT_CHAR and EVT_CHAR_HOOK events

-        key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
+        long key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);

         if ( !key_code )
         {
             if ( wxIsAsciiKeysym(keysym) )
         if ( !key_code )
         {
             if ( wxIsAsciiKeysym(keysym) )


@@ -994,6 +1044,9 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
             wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
 
             eventChar.m_keyCode = key_code;
             wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
 
             eventChar.m_keyCode = key_code;

+#if wxUSE_UNICODE
+            eventChar.m_uniChar = gdk_keyval_to_unicode(key_code);
+#endif // wxUSE_UNICODE

 
             AdjustCharEventKeyCodes(eventChar);
 
 
             AdjustCharEventKeyCodes(eventChar);
 


@@ -1005,30 +1058,43 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
 }
 }
 
 }
 }
 

+int wxWindowGTK::GTKIMFilterKeypress(GdkEventKey* event) const
+{
+    return m_imContext ? gtk_im_context_filter_keypress(m_imContext, event)
+                       : FALSE;
+}
+

 extern "C" {
 static void
 gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
                         const gchar  *str,
                         wxWindow     *window)
 extern "C" {
 static void
 gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
                         const gchar  *str,
                         wxWindow     *window)

+{
+    // Ignore the return value here, it doesn't matter for the "commit" signal.
+    window->GTKDoInsertTextFromIM(str);
+}
+}
+
+bool wxWindowGTK::GTKDoInsertTextFromIM(const char* str)

 {
     wxKeyEvent event( wxEVT_CHAR );
 
     // take modifiers, cursor position, timestamp etc. from the last
     // key_press_event that was fed into Input Method:
 {
     wxKeyEvent event( wxEVT_CHAR );
 
     // take modifiers, cursor position, timestamp etc. from the last
     // key_press_event that was fed into Input Method:

-    if (window->m_imData->lastKeyEvent)
+    if ( m_imKeyEvent )

     {
     {

-        wxFillOtherKeyEventFields(event,
-                                  window, window->m_imData->lastKeyEvent);
+        wxFillOtherKeyEventFields(event, this, m_imKeyEvent);

     }
     else
     {
     }
     else
     {

-        event.SetEventObject( window );
+        event.SetEventObject(this);

     }
 
     const wxString data(wxGTK_CONV_BACK_SYS(str));
     if( data.empty() )
     }
 
     const wxString data(wxGTK_CONV_BACK_SYS(str));
     if( data.empty() )

-        return;
+        return false;

 
 

+    bool processed = false;

     for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
     {
 #if wxUSE_UNICODE
     for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
     {
 #if wxUSE_UNICODE


@@ -1042,9 +1108,22 @@ gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
 
         AdjustCharEventKeyCodes(event);
 
 
         AdjustCharEventKeyCodes(event);
 

-        window->HandleWindowEvent(event);
+        if ( HandleWindowEvent(event) )
+            processed = true;

     }
     }

+
+    return processed;

 }
 }

+
+bool wxWindowGTK::GTKOnInsertText(const char* text)
+{
+    if ( !m_imKeyEvent )
+    {
+        // We're not inside IM key handling at all.
+        return false;
+    }
+
+    return GTKDoInsertTextFromIM(text);

 }
 
 
 }
 
 


@@ -1058,9 +1137,6 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
                                  GdkEventKey *gdk_event,
                                  wxWindowGTK *win )
 {
                                  GdkEventKey *gdk_event,
                                  wxWindowGTK *win )
 {

-    if (!win->m_hasVMT)
-        return FALSE;
-

     if (g_blockEventsOnDrag)
         return FALSE;
 
     if (g_blockEventsOnDrag)
         return FALSE;
 


@@ -1210,13 +1286,11 @@ bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
 
 bool wxWindowGTK::GTKShouldIgnoreEvent() const
 {
 
 bool wxWindowGTK::GTKShouldIgnoreEvent() const
 {

-    return !m_hasVMT || g_blockEventsOnDrag;
+    return g_blockEventsOnDrag;

 }
 
 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
 {
 }
 
 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
 {

-    if (!m_hasVMT)
-        return FALSE;

     if (g_blockEventsOnDrag)
         return TRUE;
     if (g_blockEventsOnScroll)
     if (g_blockEventsOnDrag)
         return TRUE;
     if (g_blockEventsOnScroll)


@@ -1257,7 +1331,7 @@ extern "C"
 //-----------------------------------------------------------------------------
 
 static gboolean
 //-----------------------------------------------------------------------------
 
 static gboolean

-gtk_window_button_press_callback( GtkWidget *widget,
+gtk_window_button_press_callback( GtkWidget* WXUNUSED_IN_GTK3(widget),

                                   GdkEventButton *gdk_event,
                                   wxWindowGTK *win )
 {
                                   GdkEventButton *gdk_event,
                                   wxWindowGTK *win )
 {


@@ -1267,140 +1341,79 @@ gtk_window_button_press_callback( GtkWidget *widget,
 
     g_lastButtonNumber = gdk_event->button;
 
 
     g_lastButtonNumber = gdk_event->button;
 

-    // GDK sends surplus button down events
-    // before a double click event. We
-    // need to filter these out.
-    if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
+    wxEventType event_type;
+    wxEventType down;
+    wxEventType dclick;
+    switch (gdk_event->button)

     {
     {

-        GdkEvent *peek_event = gdk_event_peek();
-        if (peek_event)
-        {
-            if ((peek_event->type == GDK_2BUTTON_PRESS) ||
-                (peek_event->type == GDK_3BUTTON_PRESS))
+        case 1:
+            down = wxEVT_LEFT_DOWN;
+            dclick = wxEVT_LEFT_DCLICK;
+            break;
+        case 2:
+            down = wxEVT_MIDDLE_DOWN;
+            dclick = wxEVT_MIDDLE_DCLICK;
+            break;
+        case 3:
+            down = wxEVT_RIGHT_DOWN;
+            dclick = wxEVT_RIGHT_DCLICK;
+            break;
+        case 8:
+            down = wxEVT_AUX1_DOWN;
+            dclick = wxEVT_AUX1_DCLICK;
+            break;
+        case 9:
+            down = wxEVT_AUX2_DOWN;
+            dclick = wxEVT_AUX2_DCLICK;
+            break;
+        default:
+            return false;
+    }
+    switch (gdk_event->type)
+    {
+        case GDK_BUTTON_PRESS:
+            event_type = down;
+            // GDK sends surplus button down events
+            // before a double click event. We
+            // need to filter these out.
+            if (win->m_wxwindow)

             {
             {

-                gdk_event_free( peek_event );
-                return TRUE;
+                GdkEvent* peek_event = gdk_event_peek();
+                if (peek_event)
+                {
+                    const GdkEventType peek_event_type = peek_event->type;
+                    gdk_event_free(peek_event);
+                    if (peek_event_type == GDK_2BUTTON_PRESS ||
+                        peek_event_type == GDK_3BUTTON_PRESS)
+                    {
+                        return true;
+                    }
+                }

             }
             }

-            else
+            break;
+        case GDK_2BUTTON_PRESS:
+            event_type = dclick;
+#ifndef __WXGTK3__
+            if (gdk_event->button >= 1 && gdk_event->button <= 3)

             {
             {

-                gdk_event_free( peek_event );
+                // Reset GDK internal timestamp variables in order to disable GDK
+                // triple click events. GDK will then next time believe no button has
+                // been clicked just before, and send a normal button click event.
+                GdkDisplay* display = gtk_widget_get_display(widget);
+                display->button_click_time[1] = 0;
+                display->button_click_time[0] = 0;

             }
             }

-        }
-    }
-
-    wxEventType event_type = wxEVT_NULL;
-
-    if ( gdk_event->type == GDK_2BUTTON_PRESS &&
-            gdk_event->button >= 1 && gdk_event->button <= 3 )
-    {
-        // Reset GDK internal timestamp variables in order to disable GDK
-        // triple click events. GDK will then next time believe no button has
-        // been clicked just before, and send a normal button click event.
-        GdkDisplay* display = gtk_widget_get_display (widget);
-        display->button_click_time[1] = 0;
-        display->button_click_time[0] = 0;
-    }
-
-    if (gdk_event->button == 1)
-    {
-        // note that GDK generates triple click events which are not supported
-        // by wxWidgets but still have to be passed to the app as otherwise
-        // clicks would simply go missing
-        switch (gdk_event->type)
-        {
-            // we shouldn't get triple clicks at all for GTK2 because we
-            // suppress them artificially using the code above but we still
-            // should map them to something for GTK1 and not just ignore them
-            // as this would lose clicks
-            case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_LEFT_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_LEFT_DCLICK;
-                break;
-
-            default:
-                // just to silence gcc warnings
-                ;
-        }
-    }
-    else if (gdk_event->button == 2)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_MIDDLE_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_MIDDLE_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-    else if (gdk_event->button == 3)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_RIGHT_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_RIGHT_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-
-    else if (gdk_event->button == 8)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_AUX1_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_AUX1_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-
-    else if (gdk_event->button == 9)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_3BUTTON_PRESS:
-            case GDK_BUTTON_PRESS:
-                event_type = wxEVT_AUX2_DOWN;
-                break;
-
-            case GDK_2BUTTON_PRESS:
-                event_type = wxEVT_AUX2_DCLICK;
-                break;
-
-            default:
-                ;
-        }
-    }
-
-    if ( event_type == wxEVT_NULL )
-    {
-        // unknown mouse button or click type
-        return FALSE;
+#endif // !__WXGTK3__
+            break;
+        // we shouldn't get triple clicks at all for GTK2 because we
+        // suppress them artificially using the code above but we still
+        // should map them to something for GTK3 and not just ignore them
+        // as this would lose clicks
+        case GDK_3BUTTON_PRESS:
+            event_type = down;
+            break;
+        default:
+            return false;

     }
 
     g_lastMouseEvent = (GdkEvent*) gdk_event;
     }
 
     g_lastMouseEvent = (GdkEvent*) gdk_event;


@@ -1533,8 +1546,11 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
     {
         int x = 0;
         int y = 0;
     {
         int x = 0;
         int y = 0;

-        GdkModifierType state;
-        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+#ifdef __WXGTK3__
+        gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
+#else
+        gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
+#endif

         gdk_event->x = x;
         gdk_event->y = y;
     }
         gdk_event->x = x;
         gdk_event->y = y;
     }


@@ -1547,7 +1563,12 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
     if ( g_captureWindow )
     {
         // synthesise a mouse enter or leave event if needed
     if ( g_captureWindow )
     {
         // synthesise a mouse enter or leave event if needed

-        GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+        GdkWindow* winUnderMouse =
+#ifdef __WXGTK3__
+            gdk_device_get_window_at_position(gdk_event->device, NULL, NULL);
+#else
+            gdk_window_at_pointer(NULL, NULL);
+#endif

         // This seems to be necessary and actually been added to
         // GDK itself in version 2.0.X
         gdk_flush();
         // This seems to be necessary and actually been added to
         // GDK itself in version 2.0.X
         gdk_flush();


@@ -1628,6 +1649,7 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
 
     // FIXME: Get these values from GTK or GDK
     event.m_linesPerAction = 3;
 
     // FIXME: Get these values from GTK or GDK
     event.m_linesPerAction = 3;

+    event.m_columnsPerAction = 3;

     event.m_wheelDelta = 120;
 
     // Determine the scroll direction.
     event.m_wheelDelta = 120;
 
     // Determine the scroll direction.


@@ -1642,7 +1664,10 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
         case GDK_SCROLL_LEFT:
             event.m_wheelRotation = -120;
             break;
         case GDK_SCROLL_LEFT:
             event.m_wheelRotation = -120;
             break;

-
+#if GTK_CHECK_VERSION(3,4,0)
+        case GDK_SCROLL_SMOOTH:
+            // TODO
+#endif

         default:
             return false;  // Unknown/unhandled direction
     }
         default:
             return false;  // Unknown/unhandled direction
     }


@@ -1659,6 +1684,11 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
         case GDK_SCROLL_RIGHT:
             event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL;
             break;
         case GDK_SCROLL_RIGHT:
             event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL;
             break;

+#if GTK_CHECK_VERSION(3,4,0)
+        case GDK_SCROLL_SMOOTH:
+            // TODO
+            break;
+#endif

     }
 
     if (win->GTKProcessEvent(event))
     }
 
     if (win->GTKProcessEvent(event))


@@ -1743,7 +1773,7 @@ wx_window_focus_callback(GtkWidget *widget,
 //-----------------------------------------------------------------------------
 
 static gboolean
 //-----------------------------------------------------------------------------
 
 static gboolean

-gtk_window_enter_callback( GtkWidget *widget,
+gtk_window_enter_callback( GtkWidget*,

                            GdkEventCrossing *gdk_event,
                            wxWindowGTK *win )
 {
                            GdkEventCrossing *gdk_event,
                            wxWindowGTK *win )
 {


@@ -1752,17 +1782,8 @@ gtk_window_enter_callback( GtkWidget *widget,
     // Event was emitted after a grab
     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
 
     // Event was emitted after a grab
     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
 

-    int x = 0;
-    int y = 0;
-    GdkModifierType state = (GdkModifierType)0;
-
-    gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
-

     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     InitMouseEvent(win, event, gdk_event);
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     InitMouseEvent(win, event, gdk_event);

-    wxPoint pt = win->GetClientAreaOrigin();
-    event.m_x = x + pt.x;
-    event.m_y = y + pt.y;

 
     if ( !g_captureWindow )
     {
 
     if ( !g_captureWindow )
     {


@@ -1781,7 +1802,7 @@ gtk_window_enter_callback( GtkWidget *widget,
 //-----------------------------------------------------------------------------
 
 static gboolean
 //-----------------------------------------------------------------------------
 
 static gboolean

-gtk_window_leave_callback( GtkWidget *widget,
+gtk_window_leave_callback( GtkWidget*,

                            GdkEventCrossing *gdk_event,
                            wxWindowGTK *win )
 {
                            GdkEventCrossing *gdk_event,
                            wxWindowGTK *win )
 {


@@ -1791,13 +1812,6 @@ gtk_window_leave_callback( GtkWidget *widget,
     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );

-
-    int x = 0;
-    int y = 0;
-    GdkModifierType state = (GdkModifierType)0;
-
-    gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
-

     InitMouseEvent(win, event, gdk_event);
 
     return win->GTKProcessEvent(event);
     InitMouseEvent(win, event, gdk_event);
 
     return win->GTKProcessEvent(event);


@@ -1893,16 +1907,6 @@ gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win)
     win->GTKHandleRealized();
 }
 
     win->GTKHandleRealized();
 }
 

-//-----------------------------------------------------------------------------
-// "unrealize" from m_wxwindow
-//-----------------------------------------------------------------------------
-
-static void unrealize(GtkWidget*, wxWindowGTK* win)
-{
-    if (win->m_imData)
-        gtk_im_context_set_client_window(win->m_imData->context, NULL);
-}
-

 //-----------------------------------------------------------------------------
 // "size_allocate" from m_wxwindow or m_widget
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "size_allocate" from m_wxwindow or m_widget
 //-----------------------------------------------------------------------------


@@ -1914,21 +1918,26 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
     int h = alloc->height;
     if (win->m_wxwindow)
     {
     int h = alloc->height;
     if (win->m_wxwindow)
     {

-        int border_x, border_y;
-        WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
-        w -= 2 * border_x;
-        h -= 2 * border_y;
+        GtkBorder border;
+        WX_PIZZA(win->m_wxwindow)->get_border(border);
+        w -= border.left + border.right;
+        h -= border.top + border.bottom;

         if (w < 0) w = 0;
         if (h < 0) h = 0;
     }
         if (w < 0) w = 0;
         if (h < 0) h = 0;
     }

-    if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
-    {
-        win->m_oldClientWidth  = w;
-        win->m_oldClientHeight = h;
+    GtkAllocation a;
+    gtk_widget_get_allocation(win->m_widget, &a);
+    // update position for widgets in native containers, such as wxToolBar
+    // (for widgets in a wxPizza, the values should already be the same)
+    win->m_x = a.x;
+    win->m_y = a.y;
+    win->m_useCachedClientSize = true;
+    if (win->m_clientWidth != w || win->m_clientHeight != h)
+    {
+        win->m_clientWidth  = w;
+        win->m_clientHeight = h;

         // this callback can be connected to m_wxwindow,
         // so always get size from m_widget->allocation
         // this callback can be connected to m_wxwindow,
         // so always get size from m_widget->allocation

-        GtkAllocation a;
-        gtk_widget_get_allocation(win->m_widget, &a);

         win->m_width  = a.width;
         win->m_height = a.height;
         if (!win->m_nativeSizeEvent)
         win->m_width  = a.width;
         win->m_height = a.height;
         if (!win->m_nativeSizeEvent)


@@ -1962,41 +1971,44 @@ gtk_window_grab_broken( GtkWidget*,
 #endif
 
 //-----------------------------------------------------------------------------
 #endif
 
 //-----------------------------------------------------------------------------

-// "style_set"
+// "style_set"/"style_updated"

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-static
-void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
-                               GtkStyle *previous_style,
-                               wxWindow* win )
+#ifdef __WXGTK3__
+static void style_updated(GtkWidget*, wxWindow* win)
+#else
+static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win)
+#endif

 {
 {

-    if (win && previous_style)
-    {
-        if (win->IsTopLevel())
-        {
-            wxSysColourChangedEvent event;
-            event.SetEventObject(win);
-            win->GTKProcessEvent(event);
-        }
-        else
-        {
-            // Border width could change, which will change client size.
-            // Make sure size event occurs for this
-            win->m_oldClientWidth = 0;
-        }
-    }
+    wxSysColourChangedEvent event;
+    event.SetEventObject(win);
+    win->GTKProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// "unrealize"
+//-----------------------------------------------------------------------------
+
+static void unrealize(GtkWidget*, wxWindow* win)
+{
+    win->GTKHandleUnrealize();

 }
 
 } // extern "C"
 
 void wxWindowGTK::GTKHandleRealized()
 {
 }
 
 } // extern "C"
 
 void wxWindowGTK::GTKHandleRealized()
 {

-    if (m_imData)
+    if (IsFrozen())
+        DoFreeze();
+
+    GdkWindow* const window = GTKGetDrawingWindow();
+
+    if (m_imContext)

     {
         gtk_im_context_set_client_window
         (
     {
         gtk_im_context_set_client_window
         (

-            m_imData->context,
-            m_wxwindow ? GTKGetDrawingWindow()
+            m_imContext,
+            window ? window

                        : gtk_widget_get_window(m_widget)
         );
     }
                        : gtk_widget_get_window(m_widget)
         );
     }


@@ -2007,7 +2019,6 @@ void wxWindowGTK::GTKHandleRealized()
 #if wxGTK_HAS_COMPOSITING_SUPPORT
         if (IsTransparentBackgroundSupported())
         {
 #if wxGTK_HAS_COMPOSITING_SUPPORT
         if (IsTransparentBackgroundSupported())
         {

-            GdkWindow* const window = GTKGetDrawingWindow();

             if (window)
                 gdk_window_set_composited(window, true);
         }
             if (window)
                 gdk_window_set_composited(window, true);
         }


@@ -2019,22 +2030,55 @@ void wxWindowGTK::GTKHandleRealized()
         }
     }
 
         }
     }
 

-
-    // We cannot set colours and fonts before the widget
-    // been realized, so we do this directly after realization
-    // or otherwise in idle time
-
-    if (m_needsStyleChange)
+#ifndef __WXGTK3__
+    if (window && (
+        m_backgroundStyle == wxBG_STYLE_PAINT ||
+        m_backgroundStyle == wxBG_STYLE_TRANSPARENT))

     {
     {

-        SetBackgroundStyle(GetBackgroundStyle());
-        m_needsStyleChange = false;
+        gdk_window_set_back_pixmap(window, NULL, false);

     }
     }

+#endif

 
     wxWindowCreateEvent event(static_cast<wxWindow*>(this));
     event.SetEventObject( this );
     GTKProcessEvent( event );
 
     GTKUpdateCursor(true, false);
 
     wxWindowCreateEvent event(static_cast<wxWindow*>(this));
     event.SetEventObject( this );
     GTKProcessEvent( event );
 
     GTKUpdateCursor(true, false);

+
+    if (m_wxwindow && IsTopLevel())
+    {
+        // attaching to style changed signal after realization avoids initial
+        // changes we don't care about
+        const gchar *detailed_signal =
+#ifdef __WXGTK3__
+            "style_updated";
+#else
+            "style_set";
+#endif
+        g_signal_connect(m_wxwindow,
+            detailed_signal,
+            G_CALLBACK(style_updated), this);
+    }
+}
+
+void wxWindowGTK::GTKHandleUnrealize()
+{
+    // unrealizing a frozen window seems to have some lingering effect
+    // preventing updates to the affected area
+    if (IsFrozen())
+        DoThaw();
+
+    if (m_wxwindow)
+    {
+        if (m_imContext)
+            gtk_im_context_set_client_window(m_imContext, NULL);
+
+        if (IsTopLevel())
+        {
+            g_signal_handlers_disconnect_by_func(
+                m_wxwindow, (void*)style_updated, this);
+        }
+    }

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -2080,6 +2124,29 @@ wxWindow *wxGetActiveWindow()
 }
 
 
 }
 
 

+// Under Unix this is implemented using X11 functions in utilsx11.cpp but we
+// need to have this function under Windows too, so provide at least a stub.
+#ifndef GDK_WINDOWING_X11
+bool wxGetKeyState(wxKeyCode WXUNUSED(key))
+{
+    wxFAIL_MSG(wxS("Not implemented under Windows"));
+    return false;
+}
+#endif // __WINDOWS__
+
+static GdkDisplay* GetDisplay()
+{
+    wxWindow* tlw = NULL;
+    if (!wxTopLevelWindows.empty())
+        tlw = wxTopLevelWindows.front();
+    GdkDisplay* display;
+    if (tlw && tlw->m_widget)
+        display = gtk_widget_get_display(tlw->m_widget);
+    else
+        display = gdk_display_get_default();
+    return display;
+}
+

 wxMouseState wxGetMouseState()
 {
     wxMouseState ms;
 wxMouseState wxGetMouseState()
 {
     wxMouseState ms;


@@ -2088,7 +2155,17 @@ wxMouseState wxGetMouseState()
     gint y;
     GdkModifierType mask;
 
     gint y;
     GdkModifierType mask;
 

-    gdk_window_get_pointer(NULL, &x, &y, &mask);
+    GdkDisplay* display = GetDisplay();
+#ifdef __WXGTK3__
+    GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+    GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+    GdkScreen* screen;
+    gdk_device_get_position(device, &screen, &x, &y);
+    GdkWindow* window = gdk_screen_get_root_window(screen);
+    gdk_device_get_state(device, window, NULL, &mask);
+#else
+    gdk_display_get_pointer(display, NULL, &x, &y, &mask);
+#endif

 
     ms.SetX(x);
     ms.SetY(y);
 
     ms.SetX(x);
     ms.SetY(y);


@@ -2130,12 +2207,14 @@ void wxWindowGTK::Init()
     m_width = 0;
     m_height = 0;
 
     m_width = 0;
     m_height = 0;
 

-    m_hasVMT = false;
-

     m_showOnIdle = false;
 
     m_noExpose = false;
     m_nativeSizeEvent = false;
     m_showOnIdle = false;
 
     m_noExpose = false;
     m_nativeSizeEvent = false;

+#ifdef __WXGTK3__
+    m_paintContext = NULL;
+    m_styleProvider = NULL;
+#endif

 
     m_isScrolling = false;
     m_mouseButtonDown = false;
 
     m_isScrolling = false;
     m_mouseButtonDown = false;


@@ -2147,16 +2226,17 @@ void wxWindowGTK::Init()
         m_scrollPos[dir] = 0;
     }
 
         m_scrollPos[dir] = 0;
     }
 

-    m_oldClientWidth =
-    m_oldClientHeight = 0;
+    m_clientWidth =
+    m_clientHeight = 0;
+    m_useCachedClientSize = false;

 
     m_clipPaintRegion = false;
 
 
     m_clipPaintRegion = false;
 

-    m_needsStyleChange = false;
-

     m_cursor = *wxSTANDARD_CURSOR;
 
     m_cursor = *wxSTANDARD_CURSOR;
 

-    m_imData = NULL;
+    m_imContext = NULL;
+    m_imKeyEvent = NULL;
+

     m_dirtyTabOrder = false;
 }
 
     m_dirtyTabOrder = false;
 }
 


@@ -2165,16 +2245,87 @@ wxWindowGTK::wxWindowGTK()
     Init();
 }
 
     Init();
 }
 

-wxWindowGTK::wxWindowGTK( wxWindow *parent,
-                          wxWindowID id,
-                          const wxPoint &pos,
-                          const wxSize &size,
-                          long style,
-                          const wxString &name  )
-{
-    Init();
+wxWindowGTK::wxWindowGTK( wxWindow *parent,
+                          wxWindowID id,
+                          const wxPoint &pos,
+                          const wxSize &size,
+                          long style,
+                          const wxString &name  )
+{
+    Init();
+
+    Create( parent, id, pos, size, style, name );
+}
+
+void wxWindowGTK::GTKCreateScrolledWindowWith(GtkWidget* view)
+{
+    wxASSERT_MSG( HasFlag(wxHSCROLL) || HasFlag(wxVSCROLL),
+                  wxS("Must not be called if scrolling is not needed.") );
+
+    m_widget = gtk_scrolled_window_new( NULL, NULL );
+
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+
+    // 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);
+        }
+    }
+
+    // If wx[HV]SCROLL is not given, the corresponding scrollbar is not shown
+    // at all. Otherwise it may be shown only on demand (default) or always, if
+    // the wxALWAYS_SHOW_SB is specified.
+    GtkPolicyType horzPolicy = HasFlag(wxHSCROLL)
+                                ? HasFlag(wxALWAYS_SHOW_SB)
+                                    ? GTK_POLICY_ALWAYS
+                                    : GTK_POLICY_AUTOMATIC
+                                : GTK_POLICY_NEVER;
+    GtkPolicyType vertPolicy = HasFlag(wxVSCROLL)
+                                ? HasFlag(wxALWAYS_SHOW_SB)
+                                    ? GTK_POLICY_ALWAYS
+                                    : GTK_POLICY_AUTOMATIC
+                                : GTK_POLICY_NEVER;
+    gtk_scrolled_window_set_policy( scrolledWindow, horzPolicy, vertPolicy );
+
+    m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
+    m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+        gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
+
+    gtk_container_add( GTK_CONTAINER(m_widget), view );
+
+    // connect various scroll-related events
+    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+    {
+        // these handlers block mouse events to any window during scrolling
+        // such as motion events and prevent GTK and wxWidgets from fighting
+        // over where the slider should be
+        g_signal_connect(m_scrollBar[dir], "button_press_event",
+                     G_CALLBACK(gtk_scrollbar_button_press_event), this);
+        g_signal_connect(m_scrollBar[dir], "button_release_event",
+                     G_CALLBACK(gtk_scrollbar_button_release_event), this);
+
+        gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
+                            G_CALLBACK(gtk_scrollbar_event_after), this);
+        g_signal_handler_block(m_scrollBar[dir], handler_id);

 
 

-    Create( parent, id, pos, size, style, name );
+        // 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( view );

 }
 
 bool wxWindowGTK::Create( wxWindow *parent,
 }
 
 bool wxWindowGTK::Create( wxWindow *parent,


@@ -2215,66 +2366,7 @@ bool wxWindowGTK::Create( wxWindow *parent,
     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
         m_widget = m_wxwindow;
     else
     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
         m_widget = m_wxwindow;
     else

-    {
-        m_widget = gtk_scrolled_window_new( NULL, NULL );
-
-        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
-
-        // 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);
-            }
-        }
-
-        if (HasFlag(wxALWAYS_SHOW_SB))
-        {
-            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
-        }
-        else
-        {
-            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-        }
-
-        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
-        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
-        if (GetLayoutDirection() == wxLayout_RightToLeft)
-            gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
-
-        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",
-                         G_CALLBACK(gtk_scrollbar_button_press_event), this);
-            g_signal_connect(m_scrollBar[dir], "button_release_event",
-                         G_CALLBACK(gtk_scrollbar_button_release_event), this);
-
-            gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
-                                G_CALLBACK(gtk_scrollbar_event_after), this);
-            g_signal_handler_block(m_scrollBar[dir], handler_id);
-
-            // these handlers get notified when scrollbar slider moves
-            g_signal_connect_after(m_scrollBar[dir], "value_changed",
-                         G_CALLBACK(gtk_scrollbar_value_changed), this);
-        }
-
-        gtk_widget_show( m_wxwindow );
-    }
+        GTKCreateScrolledWindowWith(m_wxwindow);

     g_object_ref(m_widget);
 
     if (m_parent)
     g_object_ref(m_widget);
 
     if (m_parent)


@@ -2289,6 +2381,12 @@ bool wxWindowGTK::Create( wxWindow *parent,
     return true;
 }
 
     return true;
 }
 

+void wxWindowGTK::GTKDisconnect(void* instance)
+{
+    g_signal_handlers_disconnect_matched(instance,
+        GSignalMatchType(G_SIGNAL_MATCH_DATA), 0, 0, NULL, NULL, this);
+}
+

 wxWindowGTK::~wxWindowGTK()
 {
     SendDestroyEvent();
 wxWindowGTK::~wxWindowGTK()
 {
     SendDestroyEvent();


@@ -2301,35 +2399,49 @@ wxWindowGTK::~wxWindowGTK()
     if ( gs_deferredFocusOut == this )
         gs_deferredFocusOut = NULL;
 
     if ( gs_deferredFocusOut == this )
         gs_deferredFocusOut = NULL;
 

-    m_hasVMT = false;
-
-    // destroy children before destroying this window itself
-    DestroyChildren();
+    // Unlike the above cases, which can happen in normal circumstances, a
+    // window shouldn't be destroyed while it still has capture, so even though
+    // we still reset the global pointer to avoid leaving it dangling and
+    // crashing afterwards, also complain about it.
+    if ( g_captureWindow == this )
+    {
+        wxFAIL_MSG( wxS("Destroying window with mouse capture") );
+        g_captureWindow = NULL;
+    }

 
 

-    // unhook focus handlers to prevent stray events being
-    // propagated to this (soon to be) dead object
-    if (m_focusWidget != NULL)
+    if (m_wxwindow)

     {
     {

-        g_signal_handlers_disconnect_by_func (m_focusWidget,
-                                              (gpointer) gtk_window_focus_in_callback,
-                                              this);
-        g_signal_handlers_disconnect_by_func (m_focusWidget,
-                                              (gpointer) gtk_window_focus_out_callback,
-                                              this);
+        GTKDisconnect(m_wxwindow);
+        GtkWidget* parent = gtk_widget_get_parent(m_wxwindow);
+        if (parent)
+            GTKDisconnect(parent);

     }
     }

+    if (m_widget && m_widget != m_wxwindow)
+        GTKDisconnect(m_widget);
+
+    // destroy children before destroying this window itself
+    DestroyChildren();

 
     if (m_widget)
         Show( false );
 
     // delete before the widgets to avoid a crash on solaris
 
     if (m_widget)
         Show( false );
 
     // delete before the widgets to avoid a crash on solaris

-    delete m_imData;
-    m_imData = NULL;
+    if ( m_imContext )
+    {
+        g_object_unref(m_imContext);
+        m_imContext = NULL;
+    }

 
     // avoid problem with GTK+ 2.18 where a frozen window causes the whole
     // TLW to be frozen, and if the window is then destroyed, nothing ever
     // gets painted again
 
     // avoid problem with GTK+ 2.18 where a frozen window causes the whole
     // TLW to be frozen, and if the window is then destroyed, nothing ever
     // gets painted again

-    if (IsFrozen())
-        DoThaw();
+    while (IsFrozen())
+        Thaw();
+
+#ifdef __WXGTK3__
+    if (m_styleProvider)
+        g_object_unref(m_styleProvider);
+#endif

 
     if (m_widget)
     {
 
     if (m_widget)
     {


@@ -2376,11 +2488,14 @@ void wxWindowGTK::PostCreation()
             IsTransparentBackgroundSupported() )
     {
         GdkScreen *screen = gtk_widget_get_screen (m_widget);
             IsTransparentBackgroundSupported() )
     {
         GdkScreen *screen = gtk_widget_get_screen (m_widget);

-
+#ifdef __WXGTK3__
+        gtk_widget_set_visual(m_widget, gdk_screen_get_rgba_visual(screen));
+#else

         GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen);
 
         if (rgba_colormap)
             gtk_widget_set_colormap(m_widget, rgba_colormap);
         GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen);
 
         if (rgba_colormap)
             gtk_widget_set_colormap(m_widget, rgba_colormap);

+#endif

     }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
 
     }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
 


@@ -2389,23 +2504,24 @@ void wxWindowGTK::PostCreation()
         if (!m_noExpose)
         {
             // these get reported to wxWidgets -> wxPaintEvent
         if (!m_noExpose)
         {
             // these get reported to wxWidgets -> wxPaintEvent

-
-            g_signal_connect (m_wxwindow, "expose_event",
-                              G_CALLBACK (gtk_window_expose_callback), this);
+#ifdef __WXGTK3__
+            g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this);
+#else
+            g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(expose_event), this);
+#endif

 
             if (GetLayoutDirection() == wxLayout_LeftToRight)
                 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
         }
 
         // Create input method handler
 
             if (GetLayoutDirection() == wxLayout_LeftToRight)
                 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
         }
 
         // Create input method handler

-        m_imData = new wxGtkIMData;
+        m_imContext = gtk_im_multicontext_new();

 
         // Cannot handle drawing preedited text yet
 
         // Cannot handle drawing preedited text yet

-        gtk_im_context_set_use_preedit( m_imData->context, FALSE );
+        gtk_im_context_set_use_preedit( m_imContext, FALSE );

 
 

-        g_signal_connect (m_imData->context, "commit",
+        g_signal_connect (m_imContext, "commit",

                           G_CALLBACK (gtk_wxwindow_commit_cb), this);
                           G_CALLBACK (gtk_wxwindow_commit_cb), this);

-        g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this);

     }
 
     // focus handling
     }
 
     // focus handling


@@ -2450,13 +2566,14 @@ void wxWindowGTK::PostCreation()
     // was in fact realized already.
     if ( gtk_widget_get_realized(connect_widget) )
     {
     // was in fact realized already.
     if ( gtk_widget_get_realized(connect_widget) )
     {

-        gtk_window_realized_callback(connect_widget, this);
+        GTKHandleRealized();

     }
     else
     {
         g_signal_connect (connect_widget, "realize",
                           G_CALLBACK (gtk_window_realized_callback), this);
     }
     }
     else
     {
         g_signal_connect (connect_widget, "realize",
                           G_CALLBACK (gtk_window_realized_callback), this);
     }

+    g_signal_connect(connect_widget, "unrealize", G_CALLBACK(unrealize), this);

 
     if (!IsTopLevel())
     {
 
     if (!IsTopLevel())
     {


@@ -2465,7 +2582,9 @@ void wxWindowGTK::PostCreation()
     }
 
 #if GTK_CHECK_VERSION(2, 8, 0)
     }
 
 #if GTK_CHECK_VERSION(2, 8, 0)

+#ifndef __WXGTK3__

     if ( gtk_check_version(2,8,0) == NULL )
     if ( gtk_check_version(2,8,0) == NULL )

+#endif

     {
         // Make sure we can notify the app when mouse capture is lost
         if ( m_wxwindow )
     {
         // Make sure we can notify the app when mouse capture is lost
         if ( m_wxwindow )


@@ -2485,9 +2604,10 @@ void wxWindowGTK::PostCreation()
     if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
         gtk_widget_set_size_request(m_widget, m_width, m_height);
 
     if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
         gtk_widget_set_size_request(m_widget, m_width, m_height);
 

-    InheritAttributes();
+    // apply any font or color changes made before creation
+    GTKApplyWidgetStyle();

 
 

-    m_hasVMT = true;
+    InheritAttributes();

 
     SetLayoutDirection(wxLayout_Default);
 
 
     SetLayoutDirection(wxLayout_Default);
 


@@ -2531,17 +2651,6 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
                       G_CALLBACK (gtk_window_enter_callback), this);
     g_signal_connect (widget, "leave_notify_event",
                       G_CALLBACK (gtk_window_leave_callback), this);
                       G_CALLBACK (gtk_window_enter_callback), this);
     g_signal_connect (widget, "leave_notify_event",
                       G_CALLBACK (gtk_window_leave_callback), this);

-
-    if (m_wxwindow && (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)))
-        g_signal_connect (m_wxwindow, "style_set",
-                              G_CALLBACK (gtk_window_style_set_callback), this);
-}
-
-bool wxWindowGTK::Destroy()
-{
-    m_hasVMT = false;
-
-    return wxWindowBase::Destroy();

 }
 
 static GSList* gs_queueResizeList;
 }
 
 static GSList* gs_queueResizeList;


@@ -2641,6 +2750,10 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
         height = m_height;
 
     const bool sizeChange = m_width != width || m_height != height;
         height = m_height;
 
     const bool sizeChange = m_width != width || m_height != height;

+
+    if (sizeChange)
+        m_useCachedClientSize = false;
+

     if (sizeChange || m_x != x || m_y != y)
     {
         m_x = x;
     if (sizeChange || m_x != x || m_y != y)
     {
         m_x = x;


@@ -2670,7 +2783,7 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
     {
         // update these variables to keep size_allocate handler
         // from sending another size event for this change
     {
         // update these variables to keep size_allocate handler
         // from sending another size event for this change

-        GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
+        DoGetClientSize(&m_clientWidth, &m_clientHeight);

 
         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
         event.SetEventObject( this );
 
         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
         event.SetEventObject( this );


@@ -2735,6 +2848,13 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 

+    if (m_useCachedClientSize)
+    {
+        if (width)  *width  = m_clientWidth;
+        if (height) *height = m_clientHeight;
+        return;
+    }
+

     int w = m_width;
     int h = m_height;
 
     int w = m_width;
     int h = m_height;
 


@@ -2748,6 +2868,16 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
                                            &policy[ScrollDir_Horz],
                                            &policy[ScrollDir_Vert]);
 
                                            &policy[ScrollDir_Horz],
                                            &policy[ScrollDir_Vert]);
 

+            // get scrollbar spacing the same way the GTK-private function
+            // _gtk_scrolled_window_get_scrollbar_spacing() does it
+            int scrollbar_spacing =
+                GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing;
+            if (scrollbar_spacing < 0)
+            {
+                gtk_widget_style_get(
+                    m_widget, "scrollbar-spacing", &scrollbar_spacing, NULL);
+            }
+

             for ( int i = 0; i < ScrollDir_Max; i++ )
             {
                 // don't account for the scrollbars we don't have
             for ( int i = 0; i < ScrollDir_Max; i++ )
             {
                 // don't account for the scrollbars we don't have


@@ -2773,15 +2903,32 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
                             continue;
                 }
 
                             continue;
                 }
 

-                GtkScrolledWindowClass *scroll_class =
-                    GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-

                 GtkRequisition req;
                 GtkRequisition req;

+#ifdef __WXGTK3__
+                GtkWidget* widget = GTK_WIDGET(range);
+                if (i == ScrollDir_Horz)
+                {
+                    if (height)
+                    {
+                        gtk_widget_get_preferred_height(widget, NULL, &req.height);
+                        h -= req.height + scrollbar_spacing;
+                    }
+                }
+                else
+                {
+                    if (width)
+                    {
+                        gtk_widget_get_preferred_width(widget, NULL, &req.width);
+                        w -= req.width + scrollbar_spacing;
+                    }
+                }
+#else // !__WXGTK3__

                 gtk_widget_size_request(GTK_WIDGET(range), &req);
                 if (i == ScrollDir_Horz)
                 gtk_widget_size_request(GTK_WIDGET(range), &req);
                 if (i == ScrollDir_Horz)

-                    h -= req.height + scroll_class->scrollbar_spacing;
+                    h -= req.height + scrollbar_spacing;

                 else
                 else

-                    w -= req.width + scroll_class->scrollbar_spacing;
+                    w -= req.width + scrollbar_spacing;
+#endif // !__WXGTK3__

             }
         }
 
             }
         }
 


@@ -2804,10 +2951,9 @@ wxSize wxWindowGTK::DoGetBorderSize() const
     if ( !m_wxwindow )
         return wxWindowBase::DoGetBorderSize();
 
     if ( !m_wxwindow )
         return wxWindowBase::DoGetBorderSize();
 

-    int x, y;
-    WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
-
-    return 2*wxSize(x, y);
+    GtkBorder border;
+    WX_PIZZA(m_wxwindow)->get_border(border);
+    return wxSize(border.left + border.right, border.top + border.bottom);

 }
 
 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
 }
 
 void wxWindowGTK::DoGetPosition( int *x, int *y ) const


@@ -3010,52 +3156,18 @@ void wxWindowGTK::DoGetTextExtent( const wxString& string,
                                    int *externalLeading,
                                    const wxFont *theFont ) const
 {
                                    int *externalLeading,
                                    const wxFont *theFont ) const
 {

-    wxFont fontToUse = theFont ? *theFont : GetFont();
+    // ensure we work with a valid font
+    wxFont fontToUse;
+    if ( !theFont || !theFont->IsOk() )
+        fontToUse = GetFont();
+    else
+        fontToUse = *theFont;

 
     wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
 
 
     wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
 

-    if (string.empty())
-    {
-        if (x) (*x) = 0;
-        if (y) (*y) = 0;
-        return;
-    }
-
-    PangoContext *context = NULL;
-    if (m_widget)
-        context = gtk_widget_get_pango_context( m_widget );
-
-    if (!context)
-    {
-        if (x) (*x) = 0;
-        if (y) (*y) = 0;
-        return;
-    }
-
-    PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
-    PangoLayout *layout = pango_layout_new(context);
-    pango_layout_set_font_description(layout, desc);
-    {
-        const wxCharBuffer data = wxGTK_CONV( string );
-        if ( data )
-            pango_layout_set_text(layout, data, strlen(data));
-    }
-
-    PangoRectangle rect;
-    pango_layout_get_extents(layout, NULL, &rect);
-
-    if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
-    if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
-    if (descent)
-    {
-        PangoLayoutIter *iter = pango_layout_get_iter(layout);
-        int baseline = pango_layout_iter_get_baseline(iter);
-        pango_layout_iter_free(iter);
-        *descent = *y - PANGO_PIXELS(baseline);
-    }
-    if (externalLeading) (*externalLeading) = 0;  // ??
-
-    g_object_unref (layout);
+    const wxWindow* win = static_cast<const wxWindow*>(this);
+    wxTextMeasure txm(win, &fontToUse);
+    txm.GetTextExtent(string, x, y, descent, externalLeading);

 }
 
 void wxWindowGTK::GTKDisableFocusOutEvent()
 }
 
 void wxWindowGTK::GTKDisableFocusOutEvent()


@@ -3106,8 +3218,8 @@ bool wxWindowGTK::GTKHandleFocusIn()
                "handling focus_in event for %s(%p, %s)",
                GetClassInfo()->GetClassName(), this, GetLabel());
 
                "handling focus_in event for %s(%p, %s)",
                GetClassInfo()->GetClassName(), this, GetLabel());
 

-    if (m_imData)
-        gtk_im_context_focus_in(m_imData->context);
+    if (m_imContext)
+        gtk_im_context_focus_in(m_imContext);

 
     gs_currentFocus = this;
     gs_pendingFocus = NULL;
 
     gs_currentFocus = this;
     gs_pendingFocus = NULL;


@@ -3169,8 +3281,8 @@ void wxWindowGTK::GTKHandleFocusOutNoDeferring()
                "handling focus_out event for %s(%p, %s)",
                GetClassInfo()->GetClassName(), this, GetLabel());
 
                "handling focus_out event for %s(%p, %s)",
                GetClassInfo()->GetClassName(), this, GetLabel());
 

-    if (m_imData)
-        gtk_im_context_focus_out(m_imData->context);
+    if (m_imContext)
+        gtk_im_context_focus_out(m_imContext);

 
     if ( gs_currentFocus != this )
     {
 
     if ( gs_currentFocus != this )
     {


@@ -3417,7 +3529,7 @@ bool wxWindowGTK::DoNavigateIn(int flags)
         gboolean rc;
         g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
 
         gboolean rc;
         g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
 

-        return rc == TRUE;
+        return rc != 0;

     }
 }
 
     }
 }
 


@@ -3577,7 +3689,7 @@ void wxWindowGTK::WarpPointer( int x, int y )
     ClientToScreen(&x, &y);
     GdkDisplay* display = gtk_widget_get_display(m_widget);
     GdkScreen* screen = gtk_widget_get_screen(m_widget);
     ClientToScreen(&x, &y);
     GdkDisplay* display = gtk_widget_get_display(m_widget);
     GdkScreen* screen = gtk_widget_get_screen(m_widget);

-#ifdef __WXGTK30__
+#ifdef __WXGTK3__

     GdkDeviceManager* manager = gdk_display_get_device_manager(display);
     gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
 #else
     GdkDeviceManager* manager = gdk_display_get_device_manager(display);
     gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
 #else


@@ -3696,16 +3808,23 @@ bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
         return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 }
 
         return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 }
 

-void wxWindowGTK::GtkSendPaintEvents()
+#ifdef __WXGTK3__
+void wxWindowGTK::GTKSendPaintEvents(cairo_t* cr)
+#else
+void wxWindowGTK::GTKSendPaintEvents(const GdkRegion* region)
+#endif

 {
 {

-    if (!m_wxwindow)
-    {
-        m_updateRegion.Clear();
-        return;
-    }
+#ifdef __WXGTK3__
+    m_paintContext = cr;
+    double x1, y1, x2, y2;
+    cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
+    m_updateRegion = wxRegion(int(x1), int(y1), int(x2 - x1), int(y2 - y1));
+#else // !__WXGTK3__
+    m_updateRegion = wxRegion(region);

 #if wxGTK_HAS_COMPOSITING_SUPPORT
     cairo_t* cr = NULL;
 #endif
 #if wxGTK_HAS_COMPOSITING_SUPPORT
     cairo_t* cr = NULL;
 #endif

+#endif // !__WXGTK3__

     // Clip to paint region in wxClientDC
     m_clipPaintRegion = true;
 
     // Clip to paint region in wxClientDC
     m_clipPaintRegion = true;
 


@@ -3716,8 +3835,7 @@ void wxWindowGTK::GtkSendPaintEvents()
         // Transform m_updateRegion under RTL
         m_updateRegion.Clear();
 
         // Transform m_updateRegion under RTL
         m_updateRegion.Clear();
 

-        gint width;
-        gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL);
+        const int width = gdk_window_get_width(GTKGetDrawingWindow());

 
         wxRegionIterator upd( m_nativeUpdateRegion );
         while (upd)
 
         wxRegionIterator upd( m_nativeUpdateRegion );
         while (upd)


@@ -3746,20 +3864,26 @@ void wxWindowGTK::GtkSendPaintEvents()
                 // explicitly paint.
                 // NB: it works also for top level windows (but this is the
                 // windows manager which then does the compositing job)
                 // explicitly paint.
                 // NB: it works also for top level windows (but this is the
                 // windows manager which then does the compositing job)

+#ifndef __WXGTK3__

                 cr = gdk_cairo_create(m_wxwindow->window);
                 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
                 cairo_clip(cr);
                 cr = gdk_cairo_create(m_wxwindow->window);
                 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
                 cairo_clip(cr);

-
+#endif

                 cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
                 cairo_paint(cr);
                 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
                 cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
                 cairo_paint(cr);
                 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);

+#ifndef __WXGTK3__

                 cairo_surface_flush(cairo_get_target(cr));
                 cairo_surface_flush(cairo_get_target(cr));

+#endif

             }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
             break;
 
         case wxBG_STYLE_ERASE:
             {
             }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
             break;
 
         case wxBG_STYLE_ERASE:
             {

+#ifdef __WXGTK3__
+                wxGTKCairoDC dc(cr);
+#else

                 wxWindowDC dc( (wxWindow*)this );
                 dc.SetDeviceClippingRegion( m_updateRegion );
 
                 wxWindowDC dc( (wxWindow*)this );
                 dc.SetDeviceClippingRegion( m_updateRegion );
 


@@ -3772,7 +3896,7 @@ void wxWindowGTK::GtkSendPaintEvents()
                     dc.SetBackground(GetBackgroundColour());
                     dc.Clear();
                 }
                     dc.SetBackground(GetBackgroundColour());
                     dc.Clear();
                 }

-
+#endif // !__WXGTK3__

                 wxEraseEvent erase_event( GetId(), &dc );
                 erase_event.SetEventObject( this );
 
                 wxEraseEvent erase_event( GetId(), &dc );
                 erase_event.SetEventObject( this );
 


@@ -3787,34 +3911,28 @@ void wxWindowGTK::GtkSendPaintEvents()
         case wxBG_STYLE_SYSTEM:
             if ( GetThemeEnabled() )
             {
         case wxBG_STYLE_SYSTEM:
             if ( GetThemeEnabled() )
             {

+                GdkWindow* gdkWindow = GTKGetDrawingWindow();
+                const int w = gdk_window_get_width(gdkWindow);
+                const int h = gdk_window_get_height(gdkWindow);
+#ifdef __WXGTK3__
+                GtkStyleContext* sc = gtk_widget_get_style_context(m_wxwindow);
+                gtk_render_background(sc, cr, 0, 0, w, h);
+#else

                 // find ancestor from which to steal background
                 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
                 if (!parent)
                     parent = (wxWindow*)this;
                 // find ancestor from which to steal background
                 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
                 if (!parent)
                     parent = (wxWindow*)this;

-
-                if (gtk_widget_get_mapped(parent->m_widget))
-                {
-                    wxRegionIterator upd( m_nativeUpdateRegion );
-                    while (upd)
-                    {
-                        GdkRectangle rect;
-                        rect.x = upd.GetX();
-                        rect.y = upd.GetY();
-                        rect.width = upd.GetWidth();
-                        rect.height = upd.GetHeight();
-
-                        gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
-                                    GTKGetDrawingWindow(),
+                GdkRectangle rect;
+                m_nativeUpdateRegion.GetBox(rect.x, rect.y, rect.width, rect.height);
+                gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
+                                    gdkWindow,

                                     gtk_widget_get_state(m_wxwindow),
                                     GTK_SHADOW_NONE,
                                     &rect,
                                     parent->m_widget,
                                     (char *)"base",
                                     gtk_widget_get_state(m_wxwindow),
                                     GTK_SHADOW_NONE,
                                     &rect,
                                     parent->m_widget,
                                     (char *)"base",

-                                    0, 0, -1, -1 );
-
-                        ++upd;
-                    }
-                }
+                                    0, 0, w, h);
+#endif // !__WXGTK3__

             }
             break;
 
             }
             break;
 


@@ -3844,13 +3962,14 @@ void wxWindowGTK::GtkSendPaintEvents()
             wxWindow *compositeChild = node->GetData();
             if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT)
             {
             wxWindow *compositeChild = node->GetData();
             if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT)
             {

+#ifndef __WXGTK3__

                 if (cr == NULL)
                 {
                     cr = gdk_cairo_create(m_wxwindow->window);
                     gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
                     cairo_clip(cr);
                 }
                 if (cr == NULL)
                 {
                     cr = gdk_cairo_create(m_wxwindow->window);
                     gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
                     cairo_clip(cr);
                 }

-
+#endif // !__WXGTK3__

                 GtkWidget *child = compositeChild->m_wxwindow;
                 GtkAllocation alloc;
                 gtk_widget_get_allocation(child, &alloc);
                 GtkWidget *child = compositeChild->m_wxwindow;
                 GtkAllocation alloc;
                 gtk_widget_get_allocation(child, &alloc);


@@ -3862,13 +3981,17 @@ void wxWindowGTK::GtkSendPaintEvents()
                 cairo_paint(cr);
             }
         }
                 cairo_paint(cr);
             }
         }

+#ifndef __WXGTK3__

         if (cr)
             cairo_destroy(cr);
         if (cr)
             cairo_destroy(cr);

+#endif

     }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
 
     m_clipPaintRegion = false;
     }
 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
 
     m_clipPaintRegion = false;

-
+#ifdef __WXGTK3__
+    m_paintContext = NULL;
+#endif

     m_updateRegion.Clear();
     m_nativeUpdateRegion.Clear();
 }
     m_updateRegion.Clear();
     m_nativeUpdateRegion.Clear();
 }


@@ -3883,7 +4006,7 @@ void wxWindowGTK::SetDoubleBuffered( bool on )
 
 bool wxWindowGTK::IsDoubleBuffered() const
 {
 
 bool wxWindowGTK::IsDoubleBuffered() const
 {

-    return gtk_widget_get_double_buffered( m_wxwindow );
+    return gtk_widget_get_double_buffered( m_wxwindow ) != 0;

 }
 
 void wxWindowGTK::ClearBackground()
 }
 
 void wxWindowGTK::ClearBackground()


@@ -3913,42 +4036,46 @@ void wxWindowGTK::GTKApplyToolTip(const char* tip)
 
 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
 {
 
 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
 {

-    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-

     if (!wxWindowBase::SetBackgroundColour(colour))
         return false;
 
     if (!wxWindowBase::SetBackgroundColour(colour))
         return false;
 

-    if (colour.IsOk())
+    if (m_widget)

     {
     {

-        // We need the pixel value e.g. for background clearing.
-        m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
-    }
+#ifndef __WXGTK3__
+        if (colour.IsOk())
+        {
+            // We need the pixel value e.g. for background clearing.
+            m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
+        }
+#endif

 
 

-    // apply style change (forceStyle=true so that new style is applied
-    // even if the bg colour changed from valid to wxNullColour)
-    GTKApplyWidgetStyle(true);
+        // apply style change (forceStyle=true so that new style is applied
+        // even if the bg colour changed from valid to wxNullColour)
+        GTKApplyWidgetStyle(true);
+    }

 
     return true;
 }
 
 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
 {
 
     return true;
 }
 
 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
 {

-    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-

     if (!wxWindowBase::SetForegroundColour(colour))
     if (!wxWindowBase::SetForegroundColour(colour))

-    {

         return false;
         return false;

-    }

 
 

-    if (colour.IsOk())
+    if (m_widget)

     {
     {

-        // We need the pixel value e.g. for background clearing.
-        m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
-    }
+#ifndef __WXGTK3__
+        if (colour.IsOk())
+        {
+            // We need the pixel value e.g. for background clearing.
+            m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
+        }
+#endif

 
 

-    // apply style change (forceStyle=true so that new style is applied
-    // even if the bg colour changed from valid to wxNullColour):
-    GTKApplyWidgetStyle(true);
+        // apply style change (forceStyle=true so that new style is applied
+        // even if the bg colour changed from valid to wxNullColour):
+        GTKApplyWidgetStyle(true);
+    }

 
     return true;
 }
 
     return true;
 }


@@ -3958,16 +4085,9 @@ PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
     return gtk_widget_get_pango_context( m_widget );
 }
 
     return gtk_widget_get_pango_context( m_widget );
 }
 

-GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
+#ifndef __WXGTK3__
+GtkRcStyle* wxWindowGTK::GTKCreateWidgetStyle()

 {
 {

-    // do we need to apply any changes at all?
-    if ( !forceStyle &&
-         !m_font.IsOk() &&
-         !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
-    {
-        return NULL;
-    }
-

     GtkRcStyle *style = gtk_rc_style_new();
 
     if ( m_font.IsOk() )
     GtkRcStyle *style = gtk_rc_style_new();
 
     if ( m_font.IsOk() )


@@ -4026,14 +4146,36 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
 
     return style;
 }
 
     return style;
 }

+#endif // !__WXGTK3__

 
 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
 {
 
 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
 {

-    GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
-    if ( style )
+    if (forceStyle || m_font.IsOk() ||
+        m_foregroundColour.IsOk() || m_backgroundColour.IsOk())

     {
     {

+#ifdef __WXGTK3__
+        if (m_backgroundColour.IsOk())
+        {
+            // create a GtkStyleProvider to override "background-image"
+            if (m_styleProvider == NULL)
+                m_styleProvider = GTK_STYLE_PROVIDER(gtk_css_provider_new());
+            const char css[] =
+                "*{background-image:-gtk-gradient(linear,0 0,0 1,"
+                "from(rgba(%u,%u,%u,%g)),to(rgba(%u,%u,%u,%g)))}";
+            char buf[sizeof(css) + 20];
+            const unsigned r = m_backgroundColour.Red();
+            const unsigned g = m_backgroundColour.Green();
+            const unsigned b = m_backgroundColour.Blue();
+            const double a = m_backgroundColour.Alpha() / 255.0;
+            g_snprintf(buf, sizeof(buf), css, r, g, b, a, r, g, b, a);
+            gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(m_styleProvider), buf, -1, NULL);
+        }
+        DoApplyWidgetStyle(NULL);
+#else
+        GtkRcStyle* style = GTKCreateWidgetStyle();

         DoApplyWidgetStyle(style);
         g_object_unref(style);
         DoApplyWidgetStyle(style);
         g_object_unref(style);

+#endif

     }
 
     // Style change may affect GTK+'s size calculation:
     }
 
     // Style change may affect GTK+'s size calculation:


@@ -4042,73 +4184,73 @@ void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
 
 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
 {
 
 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
 {

-    if ( m_wxwindow )
+    GtkWidget* widget = m_wxwindow ? m_wxwindow : m_widget;
+
+    // block the signal temporarily to avoid sending
+    // wxSysColourChangedEvents when we change the colours ourselves
+    bool unblock = false;
+    if (m_wxwindow && IsTopLevel())

     {
     {

-        // block the signal temporarily to avoid sending
-        // wxSysColourChangedEvents when we change the colours ourselves
-        bool unblock = false;
-        if ( IsTopLevel() )
-        {
-            unblock = true;
-            g_signal_handlers_block_by_func(
-                m_wxwindow, (void *)gtk_window_style_set_callback, this);
-        }
+        unblock = true;
+        g_signal_handlers_block_by_func(
+            m_wxwindow, (void*)style_updated, this);
+    }

 
 

-        gtk_widget_modify_style(m_wxwindow, style);
+    GTKApplyStyle(widget, style);

 
 

-        if ( unblock )
-        {
-            g_signal_handlers_unblock_by_func(
-                m_wxwindow, (void *)gtk_window_style_set_callback, this);
-        }
-    }
-    else
+    if (unblock)

     {
     {

-        gtk_widget_modify_style(m_widget, style);
+        g_signal_handlers_unblock_by_func(
+            m_wxwindow, (void*)style_updated, this);

     }
 }
 
     }
 }
 

-bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
+void wxWindowGTK::GTKApplyStyle(GtkWidget* widget, GtkRcStyle* WXUNUSED_IN_GTK3(style))

 {
 {

-    if (!wxWindowBase::SetBackgroundStyle(style))
-        return false;
+#ifdef __WXGTK3__
+    const PangoFontDescription* pfd = NULL;
+    if (m_font.IsOk())
+        pfd = pango_font_description_copy(m_font.GetNativeFontInfo()->description);
+    gtk_widget_override_font(widget, pfd);
+    gtk_widget_override_color(widget, GTK_STATE_FLAG_NORMAL, m_foregroundColour);
+    gtk_widget_override_background_color(widget, GTK_STATE_FLAG_NORMAL, m_backgroundColour);

 
 

-    GdkWindow *window;
-    if ( m_wxwindow )
+    // setting background color has no effect with some themes when the widget style
+    // has a "background-image" property, so we need to override that as well
+
+    GtkStyleContext* context = gtk_widget_get_style_context(widget);
+    if (m_styleProvider)
+        gtk_style_context_remove_provider(context, m_styleProvider);
+    cairo_pattern_t* pattern = NULL;
+    if (m_backgroundColour.IsOk())

     {
     {

-        window = GTKGetDrawingWindow();
+        gtk_style_context_get(context,
+            GTK_STATE_FLAG_NORMAL, "background-image", &pattern, NULL);

     }
     }

-    else
+    if (pattern)

     {
     {

-        GtkWidget * const w = GetConnectWidget();
-        window = w ? gtk_widget_get_window(w) : NULL;
+        cairo_pattern_destroy(pattern);
+        gtk_style_context_add_provider(context,
+            m_styleProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

     }
     }

+#else
+    gtk_widget_modify_style(widget, style);
+#endif
+}

 
 

-    bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT;
-
-    if ( wantNoBackPixmap )
-    {
-        if (window)
-        {
-            // Make sure GDK/X11 doesn't refresh the window
-            // automatically.
-            gdk_window_set_back_pixmap( window, NULL, FALSE );
-            m_needsStyleChange = false;
-        }
-        else // window not realized yet
-        {
-            // Do when window is realized
-            m_needsStyleChange = true;
-        }
+bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
+{
+    if (!wxWindowBase::SetBackgroundStyle(style))
+        return false;

 
 

-        // Don't apply widget style, or we get a grey background
-    }
-    else
+#ifndef __WXGTK3__
+    GdkWindow *window;
+    if ((style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT) &&
+        (window = GTKGetDrawingWindow()))

     {
     {

-        // apply style change (forceStyle=true so that new style is applied
-        // even if the bg colour changed from valid to wxNullColour):
-        GTKApplyWidgetStyle(true);
+        gdk_window_set_back_pixmap(window, NULL, false);

     }
     }

+#endif // !__WXGTK3__

 
     return true;
 }
 
     return true;
 }


@@ -4116,6 +4258,7 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
 {
 #if wxGTK_HAS_COMPOSITING_SUPPORT
 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
 {
 #if wxGTK_HAS_COMPOSITING_SUPPORT

+#ifndef __WXGTK3__

     if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL)
     {
         if (reason)
     if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL)
     {
         if (reason)


@@ -4127,6 +4270,7 @@ bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
 
         return false;
     }
 
         return false;
     }

+#endif // !__WXGTK3__

 
     // NB: We don't check here if the particular kind of widget supports
     // transparency, we check only if it would be possible for a generic window
 
     // NB: We don't check here if the particular kind of widget supports
     // transparency, we check only if it would be possible for a generic window


@@ -4171,7 +4315,11 @@ void wxPopupMenuPositionCallback( GtkMenu *menu,
 {
     // ensure that the menu appears entirely on screen
     GtkRequisition req;
 {
     // ensure that the menu appears entirely on screen
     GtkRequisition req;

+#ifdef __WXGTK3__
+    gtk_widget_get_preferred_size(GTK_WIDGET(menu), &req, NULL);
+#else

     gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
     gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);

+#endif

 
     wxSize sizeScreen = wxGetDisplaySize();
     wxPoint *pos = (wxPoint*)user_data;
 
     wxSize sizeScreen = wxGetDisplaySize();
     wxPoint *pos = (wxPoint*)user_data;


@@ -4269,14 +4417,15 @@ GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 
 bool wxWindowGTK::SetFont( const wxFont &font )
 {
 
 bool wxWindowGTK::SetFont( const wxFont &font )
 {

-    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-

     if (!wxWindowBase::SetFont(font))
         return false;
 
     if (!wxWindowBase::SetFont(font))
         return false;
 

-    // apply style change (forceStyle=true so that new style is applied
-    // even if the font changed from valid to wxNullFont):
-    GTKApplyWidgetStyle(true);
+    if (m_widget)
+    {
+        // apply style change (forceStyle=true so that new style is applied
+        // even if the font changed from valid to wxNullFont):
+        GTKApplyWidgetStyle(true);
+    }

 
     return true;
 }
 
     return true;
 }


@@ -4297,15 +4446,25 @@ void wxWindowGTK::DoCaptureMouse()
     if (!cursor->IsOk())
         cursor = wxSTANDARD_CURSOR;
 
     if (!cursor->IsOk())
         cursor = wxSTANDARD_CURSOR;
 

+    const GdkEventMask mask = GdkEventMask(
+        GDK_BUTTON_PRESS_MASK |
+        GDK_BUTTON_RELEASE_MASK |
+        GDK_POINTER_MOTION_HINT_MASK |
+        GDK_POINTER_MOTION_MASK);
+#ifdef __WXGTK3__
+    GdkDisplay* display = gdk_window_get_display(window);
+    GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+    GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+    gdk_device_grab(
+        device, window, GDK_OWNERSHIP_NONE, false, mask,
+        cursor->GetCursor(), unsigned(GDK_CURRENT_TIME));
+#else

     gdk_pointer_grab( window, FALSE,
     gdk_pointer_grab( window, FALSE,

-                      (GdkEventMask)
-                         (GDK_BUTTON_PRESS_MASK |
-                          GDK_BUTTON_RELEASE_MASK |
-                          GDK_POINTER_MOTION_HINT_MASK |
-                          GDK_POINTER_MOTION_MASK),
+                      mask,

                       NULL,
                       cursor->GetCursor(),
                       (guint32)GDK_CURRENT_TIME );
                       NULL,
                       cursor->GetCursor(),
                       (guint32)GDK_CURRENT_TIME );

+#endif

     g_captureWindow = this;
     g_captureWindowHasMouse = true;
 }
     g_captureWindow = this;
     g_captureWindowHasMouse = true;
 }


@@ -4327,7 +4486,14 @@ void wxWindowGTK::DoReleaseMouse()
     if (!window)
         return;
 
     if (!window)
         return;
 

+#ifdef __WXGTK3__
+    GdkDisplay* display = gdk_window_get_display(window);
+    GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+    GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+    gdk_device_ungrab(device, unsigned(GDK_CURRENT_TIME));
+#else

     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );

+#endif

 }
 
 void wxWindowGTK::GTKReleaseMouseAndNotify()
 }
 
 void wxWindowGTK::GTKReleaseMouseAndNotify()


@@ -4446,7 +4612,7 @@ wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
     // update current position
     m_scrollPos[barIndex] = value;
     // If event should be ignored, or integral position has not changed
     // update current position
     m_scrollPos[barIndex] = value;
     // If event should be ignored, or integral position has not changed

-    if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))
+    if (g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))

     {
         return wxEVT_NULL;
     }
     {
         return wxEVT_NULL;
     }


@@ -4550,20 +4716,23 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt)
 }
 
 // Get the current mouse position.
 }
 
 // Get the current mouse position.

-wxPoint wxGetMousePosition()
+void wxGetMousePosition(int* x, int* y)

 {
 {

-    wxWindow* tlw = NULL;
-    if (!wxTopLevelWindows.empty())
-        tlw = wxTopLevelWindows.front();
-    GdkDisplay* display;
-    if (tlw && tlw->m_widget)
-        display = gtk_widget_get_display(tlw->m_widget);
-    else
-        display = gdk_display_get_default();
+    GdkDisplay* display = GetDisplay();
+#ifdef __WXGTK3__
+    GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+    GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+    gdk_device_get_position(device, NULL, x, y);
+#else
+    gdk_display_get_pointer(display, NULL, x, y, NULL);
+#endif
+}

 
 

-    int x, y;
-    gdk_display_get_pointer(display, NULL, &x, &y, NULL);
-    return wxPoint(x, y);
+wxPoint wxGetMousePosition()
+{
+    wxPoint pt;
+    wxGetMousePosition(&pt.x, &pt.y);
+    return pt;

 }
 
 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
 }
 
 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const


@@ -4578,91 +4747,38 @@ GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
 // freeze/thaw
 // ----------------------------------------------------------------------------
 
 // freeze/thaw
 // ----------------------------------------------------------------------------
 

-extern "C"
-{
-
-// this is called if we attempted to freeze unrealized widget when it finally
-// is realized (and so can be frozen):
-static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
-{
-    wxASSERT( w && gtk_widget_get_has_window(w) );
-    wxASSERT( gtk_widget_get_realized(w) );
-
-    g_signal_handlers_disconnect_by_func
-    (
-        w,
-        (void*)wx_frozen_widget_realize,
-        win
-    );
-
-    GdkWindow* window;
-    if (w == win->m_wxwindow)
-        window = win->GTKGetDrawingWindow();
-    else
-        window = gtk_widget_get_window(w);
-    gdk_window_freeze_updates(window);
-}
-
-} // extern "C"
-
-void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
+void wxWindowGTK::GTKFreezeWidget(GtkWidget* widget)

 {
 {

-    if ( !w || !gtk_widget_get_has_window(w) )
-        return; // window-less widget, cannot be frozen
-
-    GdkWindow* window = gtk_widget_get_window(w);
-    if (window == NULL)
+    if (widget && gtk_widget_get_has_window(widget))

     {
     {

-        // we can't thaw unrealized widgets because they don't have GdkWindow,
-        // so set it up to be done immediately after realization:
-        g_signal_connect_after
-        (
-            w,
-            "realize",
-            G_CALLBACK(wx_frozen_widget_realize),
-            this
-        );
-        return;
+        GdkWindow* window = gtk_widget_get_window(widget);
+        if (window)
+            gdk_window_freeze_updates(window);

     }
     }

-
-    if (w == m_wxwindow)
-        window = GTKGetDrawingWindow();
-    gdk_window_freeze_updates(window);

 }
 
 }
 

-void wxWindowGTK::GTKThawWidget(GtkWidget *w)
+void wxWindowGTK::GTKThawWidget(GtkWidget* widget)

 {
 {

-    if ( !w || !gtk_widget_get_has_window(w) )
-        return; // window-less widget, cannot be frozen
-
-    GdkWindow* window = gtk_widget_get_window(w);
-    if (window == NULL)
+    if (widget && gtk_widget_get_has_window(widget))

     {
     {

-        // the widget wasn't realized yet, no need to thaw
-        g_signal_handlers_disconnect_by_func
-        (
-            w,
-            (void*)wx_frozen_widget_realize,
-            this
-        );
-        return;
+        GdkWindow* window = gtk_widget_get_window(widget);
+        if (window)
+            gdk_window_thaw_updates(window);

     }
     }

-
-    if (w == m_wxwindow)
-        window = GTKGetDrawingWindow();
-    gdk_window_thaw_updates(window);

 }
 
 void wxWindowGTK::DoFreeze()
 {
 }
 
 void wxWindowGTK::DoFreeze()
 {

-    GTKFreezeWidget(m_widget);
-    if ( m_wxwindow && m_widget != m_wxwindow )
-        GTKFreezeWidget(m_wxwindow);
+    GtkWidget* widget = m_wxwindow;
+    if (widget == NULL)
+        widget = m_widget;
+    GTKFreezeWidget(widget);

 }
 
 void wxWindowGTK::DoThaw()
 {
 }
 
 void wxWindowGTK::DoThaw()
 {

-    GTKThawWidget(m_widget);
-    if ( m_wxwindow && m_widget != m_wxwindow )
-        GTKThawWidget(m_wxwindow);
+    GtkWidget* widget = m_wxwindow;
+    if (widget == NULL)
+        widget = m_widget;
+    GTKThawWidget(widget);

 }
 }