update frm Ivan Masar

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 3dfbae632d4eedbff81c69d6a4cca5e030ffbf57..0cb6276a0dac881f2e7dd8297544fe00c477246b 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        window.cpp
+// Name:        src/gtk/window.cpp

 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$


@@ -7,44 +7,54 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 

-#ifdef __GNUG__
-    #pragma implementation "window.h"
+#ifdef __VMS
+#define XWarpPointer XWARPPOINTER

 #endif
 
 #endif
 

-#include "wx/defs.h"

 #include "wx/window.h"
 #include "wx/window.h"

-#include "wx/dc.h"
-#include "wx/frame.h"
-#include "wx/app.h"
-#include "wx/layout.h"
-#include "wx/utils.h"
-#include "wx/dialog.h"
-#include "wx/msgdlg.h"

 
 

-#if wxUSE_DRAG_AND_DROP
-    #include "wx/dnd.h"
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/frame.h"
+    #include "wx/dcclient.h"
+    #include "wx/menu.h"
+    #include "wx/settings.h"
+    #include "wx/msgdlg.h"
+    #include "wx/textctrl.h"
+    #include "wx/radiobut.h"
+    #include "wx/toolbar.h"
+    #include "wx/combobox.h"
+    #include "wx/layout.h"
+    #include "wx/math.h"

 #endif
 
 #endif
 

-#if wxUSE_TOOLTIPS
-    #include "wx/tooltip.h"
+#include "wx/dnd.h"
+#include "wx/tooltip.h"
+#include "wx/caret.h"
+#include "wx/fontutil.h"
+
+#ifdef __WXDEBUG__
+    #include "wx/thread.h"

 #endif
 
 #endif
 

-#include "wx/menu.h"
-#include "wx/statusbr.h"
-#include "wx/intl.h"
-#include "wx/settings.h"
-#include "wx/log.h"
+#include <ctype.h>

 
 

-#include <math.h>
+// FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
+#include <gtk/gtkversion.h>
+#if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
+    #undef GTK_DISABLE_DEPRECATED
+    #include <gtk/gtkcombo.h>
+    #define GTK_DISABLE_DEPRECATED
+#endif

 
 

-#include "gdk/gdk.h"
-#include "gtk/gtk.h"
-#include "gdk/gdkprivate.h"
-#include "gdk/gdkkeysyms.h"
+#include "wx/gtk/private.h"

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

-
-#include "gdk/gdkx.h"
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>

 
 //-----------------------------------------------------------------------------
 // documentation on internals
 
 //-----------------------------------------------------------------------------
 // documentation on internals


@@ -52,11 +62,13 @@
 
 /*
    I have been asked several times about writing some documentation about
 
 /*
    I have been asked several times about writing some documentation about

-   the GTK port of wxWindows, especially its internal structures. Obviously,
+   the GTK port of wxWidgets, especially its internal structures. Obviously,

    you cannot understand wxGTK without knowing a little about the GTK, but
    some more information about what the wxWindow, which is the base class
    for all other window classes, does seems required as well.
 
    you cannot understand wxGTK without knowing a little about the GTK, but
    some more information about what the wxWindow, which is the base class
    for all other window classes, does seems required as well.
 

+   I)
+

    What does wxWindow do? It contains the common interface for the following
    jobs of its descendants:
 
    What does wxWindow do? It contains the common interface for the following
    jobs of its descendants:
 


@@ -82,101 +94,149 @@
    5) A multitude of helper or extra methods for special purposes, such as
    Drag'n'Drop, managing validators etc.
 
    5) A multitude of helper or extra methods for special purposes, such as
    Drag'n'Drop, managing validators etc.
 

-   Normally one might expect, that one wxWindows window would always correspond
-   to one GTK widget. Under GTK, there is no such allround widget that has all
+   6) Display a border (sunken, raised, simple or none).
+
+   Normally one might expect, that one wxWidgets window would always correspond
+   to one GTK widget. Under GTK, there is no such all-round widget that has all

    the functionality. Moreover, the GTK defines a client area as a different
    widget from the actual widget you are handling. Last but not least some
    special classes (e.g. wxFrame) handle different categories of widgets and
    still have the possibility to draw something in the client area.
    It was therefore required to write a special purpose GTK widget, that would
    the functionality. Moreover, the GTK defines a client area as a different
    widget from the actual widget you are handling. Last but not least some
    special classes (e.g. wxFrame) handle different categories of widgets and
    still have the possibility to draw something in the client area.
    It was therefore required to write a special purpose GTK widget, that would

-   represent a client area in the sense of wxWindows capable to do the jobs
+   represent a client area in the sense of wxWidgets capable to do the jobs

    2), 3) and 4). I have written this class and it resides in win_gtk.c of
    this directory.
 
    All windows must have a widget, with which they interact with other under-
    lying GTK widgets. It is this widget, e.g. that has to be resized etc and
    2), 3) and 4). I have written this class and it resides in win_gtk.c of
    this directory.
 
    All windows must have a widget, with which they interact with other under-
    lying GTK widgets. It is this widget, e.g. that has to be resized etc and

-   thw wxWindow class has a member variable called m_widget which holds a
+   the wxWindow class has a member variable called m_widget which holds a

    pointer to this widget. When the window class represents a GTK native widget,
    this is (in most cases) the only GTK widget the class manages. E.g. the
    pointer to this widget. When the window class represents a GTK native widget,
    this is (in most cases) the only GTK widget the class manages. E.g. the

-   wxStatitText class handles only a GtkLabel widget a pointer to which you
+   wxStaticText class handles only a GtkLabel widget a pointer to which you

    can find in m_widget (defined in wxWindow)
 
    When the class has a client area for drawing into and for containing children
    can find in m_widget (defined in wxWindow)
 
    When the class has a client area for drawing into and for containing children

-   it has to handle the client area widget (of the type GtkMyFixed, defined in
+   it has to handle the client area widget (of the type GtkPizza, defined in

    win_gtk.c), but there could be any number of widgets, handled by a class
    The common rule for all windows is only, that the widget that interacts with
    the rest of GTK must be referenced in m_widget and all other widgets must be
    children of this widget on the GTK level. The top-most widget, which also
    represents the client area, must be in the m_wxwindow field and must be of
    win_gtk.c), but there could be any number of widgets, handled by a class
    The common rule for all windows is only, that the widget that interacts with
    the rest of GTK must be referenced in m_widget and all other widgets must be
    children of this widget on the GTK level. The top-most widget, which also
    represents the client area, must be in the m_wxwindow field and must be of

-   the type GtkMyFixed.
+   the type GtkPizza.

 
    As I said, the window classes that display a GTK native widget only have
    one widget, so in the case of e.g. the wxButton class m_widget holds a
    pointer to a GtkButton widget. But windows with client areas (for drawing
    and children) have a m_widget field that is a pointer to a GtkScrolled-
 
    As I said, the window classes that display a GTK native widget only have
    one widget, so in the case of e.g. the wxButton class m_widget holds a
    pointer to a GtkButton widget. But windows with client areas (for drawing
    and children) have a m_widget field that is a pointer to a GtkScrolled-

-   Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
+   Window and a m_wxwindow field that is pointer to a GtkPizza and this

    one is (in the GTK sense) a child of the GtkScrolledWindow.
 
    If the m_wxwindow field is set, then all input to this widget is inter-
    one is (in the GTK sense) a child of the GtkScrolledWindow.
 
    If the m_wxwindow field is set, then all input to this widget is inter-

-   cepted and sent to the wxWindows class. If not, all input to the widget
+   cepted and sent to the wxWidgets class. If not, all input to the widget

    that gets pointed to by m_widget gets intercepted and sent to the class.
 
    that gets pointed to by m_widget gets intercepted and sent to the class.
 

+   II)
+
+   The design of scrolling in wxWidgets is markedly different from that offered
+   by the GTK itself and therefore we cannot simply take it as it is. In GTK,
+   clicking on a scrollbar belonging to scrolled window will inevitably move
+   the window. In wxWidgets, the scrollbar will only emit an event, send this
+   to (normally) a wxScrolledWindow and that class will call ScrollWindow()
+   which actually moves the window and its sub-windows. Note that GtkPizza
+   memorizes how much it has been scrolled but that wxWidgets forgets this
+   so that the two coordinates systems have to be kept in synch. This is done
+   in various places using the pizza->xoffset and pizza->yoffset values.
+
+   III)
+
+   Singularly the most broken code in GTK is the code that is supposed to
+   inform subwindows (child windows) about new positions. Very often, duplicate
+   events are sent without changes in size or position, equally often no
+   events are sent at all (All this is due to a bug in the GtkContainer code
+   which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
+   GTK's own system and it simply waits for size events for toplevel windows
+   and then iterates down the respective size events to all window. This has
+   the disadvantage that windows might get size events before the GTK widget
+   actually has the reported size. This doesn't normally pose any problem, but
+   the OpenGL drawing routines rely on correct behaviour. Therefore, I have
+   added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
+   i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
+   window that is used for OpenGL output really has that size (as reported by
+   GTK).
+
+   IV)
+
+   If someone at some point of time feels the immense desire to have a look at,
+   change or attempt to optimise the Refresh() logic, this person will need an
+   intimate understanding of what "draw" and "expose" events are and what
+   they are used for, in particular when used in connection with GTK's
+   own windowless widgets. Beware.
+
+   V)
+
+   Cursors, too, have been a constant source of pleasure. The main difficulty
+   is that a GdkWindow inherits a cursor if the programmer sets a new cursor
+   for the parent. To prevent this from doing too much harm, I use idle time
+   to set the cursor over and over again, starting from the toplevel windows
+   and ending with the youngest generation (speaking of parent and child windows).
+   Also don't forget that cursors (like much else) are connected to GdkWindows,
+   not GtkWidgets and that the "window" field of a GtkWidget might very well
+   point to the GdkWindow of the parent widget (-> "window-less widget") and
+   that the two obviously have very different meanings.
+

 */
 
 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 
 */
 
 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 

-extern wxList     wxPendingDelete;
-extern bool       g_blockEventsOnDrag;
-extern bool       g_blockEventsOnScroll;
+// Don't allow event propagation during drag
+bool g_blockEventsOnDrag;
+// Don't allow mouse event propagation during scroll
+bool g_blockEventsOnScroll;

 extern wxCursor   g_globalCursor;
 extern wxCursor   g_globalCursor;

-static wxWindow  *g_captureWindow = (wxWindow*) NULL;
-       wxWindow  *g_focusWindow = (wxWindow*) NULL;
-
-/* hack: we need something to pass to gtk_menu_popup, so we store the time of
-   the last click here */
-static guint32 gs_timeLastClick = 0;

 
 

-//-----------------------------------------------------------------------------
-// debug
-//-----------------------------------------------------------------------------
+// mouse capture state: the window which has it and if the mouse is currently
+// inside it
+static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;
+static bool g_captureWindowHasMouse = false;

 
 

-#ifdef __WXDEBUG__
+wxWindowGTK  *g_focusWindow = (wxWindowGTK*) NULL;

 
 

-static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
-                                         GdkEvent *WXUNUSED(event),
-                                         const wxChar *WXUNUSED(name) )
-{
-/*
-    static bool s_done = FALSE;
-    if ( !s_done )
-    {
-        wxLog::AddTraceMask("focus");
-        s_done = TRUE;
-    }
-    wxLogTrace(wxT("FOCUS NOW AT: %s"), name);
-*/
+// the last window which had the focus - this is normally never NULL (except
+// if we never had focus at all) as even when g_focusWindow is NULL it still
+// keeps its previous value
+wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;

 
 

-    return FALSE;
-}
+// If a window get the focus set but has not been realized
+// yet, defer setting the focus to idle time.
+wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;

 
 

-void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
-{
-    wxString tmp = name;
-    tmp += wxT(" FROM ");
-    tmp += window;
+// global variables because GTK+ DnD want to have the
+// mouse event that caused it
+GdkEvent    *g_lastMouseEvent = (GdkEvent*) NULL;
+int          g_lastButtonNumber = 0;

 
 

-    wxChar *s = new wxChar[tmp.Length()+1];
+extern bool g_mainThreadLocked;

 
 

-    wxStrcpy( s, tmp );
+//-----------------------------------------------------------------------------
+// debug
+//-----------------------------------------------------------------------------

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
-      GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
-}
+#ifdef __WXDEBUG__

 
 

+#if wxUSE_THREADS
+#   define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
+#else
+#   define DEBUG_MAIN_THREAD
+#endif
+#else
+#define DEBUG_MAIN_THREAD

 #endif // Debug
 
 #endif // Debug
 

+// the trace mask used for the focus debugging messages
+#define TRACE_FOCUS _T("focus")
+

 //-----------------------------------------------------------------------------
 // missing gdk functions
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // missing gdk functions
 //-----------------------------------------------------------------------------


@@ -186,68 +246,82 @@ gdk_window_warp_pointer (GdkWindow      *window,
                          gint            x,
                          gint            y)
 {
                          gint            x,
                          gint            y)
 {

-  GdkWindowPrivate *priv;
-

   if (!window)
   if (!window)

-    window = (GdkWindow*) &gdk_root_parent;
+    window = gdk_get_default_root_window();

 
 

-  priv = (GdkWindowPrivate*) window;
-
-  if (!priv->destroyed)
+  if (!GDK_WINDOW_DESTROYED(window))

   {
   {

-      XWarpPointer (priv->xdisplay,
+      XWarpPointer (GDK_WINDOW_XDISPLAY(window),

                     None,              /* not source window -> move from anywhere */
                     None,              /* not source window -> move from anywhere */

-                    priv->xwindow,  /* dest window */
+                    GDK_WINDOW_XID(window),  /* dest window */

                     0, 0, 0, 0,        /* not source window -> move from anywhere */
                     x, y );
   }
 }
 
                     0, 0, 0, 0,        /* not source window -> move from anywhere */
                     x, y );
   }
 }
 

-//-----------------------------------------------------------------------------
-// idle system
-//-----------------------------------------------------------------------------
-
-extern void wxapp_install_idle_handler();
-extern bool g_isIdle;
-

 //-----------------------------------------------------------------------------
 // local code (see below)
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // local code (see below)
 //-----------------------------------------------------------------------------
 

-#if (GTK_MINOR_VERSION > 0)
-
-static void draw_frame( GtkWidget *widget, wxWindow *win )
+// returns the child of win which currently has focus or NULL if not found
+//
+// Note: can't be static, needed by textctrl.cpp.
+wxWindow *wxFindFocusedChild(wxWindowGTK *win)

 {
 {

-    if (!win->m_hasVMT)
-        return;
+    wxWindow *winFocus = wxWindowGTK::FindFocus();
+    if ( !winFocus )
+        return (wxWindow *)NULL;

 
 

-    int dw = 0;
-    int dh = 0;
+    if ( winFocus == win )
+        return (wxWindow *)win;

 
 

-    if (win->HasScrolling())
+    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

-        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
-        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
+        wxWindow *child = wxFindFocusedChild(node->GetData());
+        if ( child )
+            return child;
+    }

 
 

-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+    return (wxWindow *)NULL;
+}

 
 

-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
+static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h)
+{
+    GtkScrolledWindow* scroll_window = GTK_SCROLLED_WINDOW(widget);
+    GtkScrolledWindowClass* scroll_class = GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window));
+    GtkRequisition scroll_req;

 
 

-        if (scroll_window->vscrollbar_visible)
-        {
-            dw += 15;   /* dw += vscrollbar->allocation.width; */
-            dw += scroll_class->scrollbar_spacing;
-        }
+    w = 0;
+    if (scroll_window->vscrollbar_visible)
+    {
+        scroll_req.width = 2;
+        scroll_req.height = 2;
+        (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
+            (scroll_window->vscrollbar, &scroll_req );
+        w = scroll_req.width +
+            scroll_class->scrollbar_spacing;
+    }

 
 

-        if (scroll_window->hscrollbar_visible)
-        {
-            dh += 15;   /* dh += hscrollbar->allocation.height; */
-            dh += scroll_class->scrollbar_spacing;
-        }
+    h = 0;
+    if (scroll_window->hscrollbar_visible)
+    {
+        scroll_req.width = 2;
+        scroll_req.height = 2;
+        (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
+            (scroll_window->hscrollbar, &scroll_req );
+        h = scroll_req.height +
+            scroll_class->scrollbar_spacing;

     }
     }

+}
+
+static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
+{
+    // wxUniversal widgets draw the borders and scrollbars themselves
+#ifndef __WXUNIVERSAL__
+    if (!win->m_hasVMT)
+        return;

 
     int dx = 0;
     int dy = 0;
 
     int dx = 0;
     int dy = 0;


@@ -257,545 +331,711 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
         dy += widget->allocation.y;
     }
 
         dy += widget->allocation.y;
     }
 

+    int x = dx;
+    int y = dy;
+
+    int dw = 0;
+    int dh = 0;
+    if (win->m_hasScrolling)
+    {
+        GetScrollbarWidth(widget, dw, dh);
+
+        if (win->GetLayoutDirection() == wxLayout_RightToLeft)
+        {
+            // This is actually wrong for old GTK+ version
+            // which do not display the scrollbar on the
+            // left side in RTL
+            x += dw;
+        }
+    }
+
+    int w = widget->allocation.width-dw;
+    int h = widget->allocation.height-dh;
+

     if (win->HasFlag(wxRAISED_BORDER))
     {
     if (win->HasFlag(wxRAISED_BORDER))
     {

-        gtk_draw_shadow( widget->style,
-                         widget->window,
-                         GTK_STATE_NORMAL,
-                         GTK_SHADOW_OUT,
-                         dx, dy,
-                         win->m_width-dw, win->m_height-dh );
+        gtk_paint_shadow (widget->style,
+                          widget->window,
+                          GTK_STATE_NORMAL,
+                          GTK_SHADOW_OUT,
+                          NULL, NULL, NULL, // FIXME: No clipping?
+                          x, y, w, h );

         return;
     }
 
     if (win->HasFlag(wxSUNKEN_BORDER))
     {
         return;
     }
 
     if (win->HasFlag(wxSUNKEN_BORDER))
     {

-        gtk_draw_shadow( widget->style,
-                         widget->window,
-                         GTK_STATE_NORMAL,
-                         GTK_SHADOW_IN,
-                         dx, dy,
-                         win->m_width-dw, win->m_height-dh );
+        gtk_paint_shadow (widget->style,
+                          widget->window,
+                          GTK_STATE_NORMAL,
+                          GTK_SHADOW_IN,
+                          NULL, NULL, NULL, // FIXME: No clipping?
+                          x, y, w, h );

         return;
     }
         return;
     }

-    
+

     if (win->HasFlag(wxSIMPLE_BORDER))
     {
         GdkGC *gc;
     if (win->HasFlag(wxSIMPLE_BORDER))
     {
         GdkGC *gc;

-       gc = gdk_gc_new( widget->window );
+        gc = gdk_gc_new( widget->window );

         gdk_gc_set_foreground( gc, &widget->style->black );
         gdk_gc_set_foreground( gc, &widget->style->black );

-        gdk_draw_rectangle( widget->window, gc, FALSE, 
-                         dx, dy,
-                         win->m_width-dw-1, win->m_height-dh-1 );
-        gdk_gc_unref( gc );
+        gdk_draw_rectangle( widget->window, gc, FALSE, x, y, w-1, h-1 );
+        g_object_unref (gc);

         return;
     }
         return;
     }

+#endif // __WXUNIVERSAL__

 }
 
 //-----------------------------------------------------------------------------
 // "expose_event" of m_widget
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "expose_event" of m_widget
 //-----------------------------------------------------------------------------
 

-static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+extern "C" {
+static gboolean
+gtk_window_own_expose_callback( GtkWidget *widget,
+                                GdkEventExpose *gdk_event,
+                                wxWindowGTK *win )

 {
 {

-    if (gdk_event->count > 0) return;
-    draw_frame( widget, win );
+    if (gdk_event->count == 0)
+        draw_frame(widget, win);
+    return false;
+}

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

-// "draw" of m_widget
+// "size_request" of m_widget

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

-static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
+// make it extern because wxStaticText needs to disconnect this one
+extern "C" {
+void wxgtk_window_size_request_callback(GtkWidget *widget,
+                                        GtkRequisition *requisition,
+                                        wxWindow *win)

 {
 {

-    draw_frame( widget, win );
+    int w, h;
+    win->GetSize( &w, &h );
+    if (w < 2)
+        w = 2;
+    if (h < 2)
+        h = 2;
+
+    requisition->height = h;
+    requisition->width = w;
+}

 }
 
 }
 

-#endif // GTK_MINOR_VERSION > 0
+extern "C" {
+static
+void wxgtk_combo_size_request_callback(GtkWidget *widget,
+                                       GtkRequisition *requisition,
+                                       wxComboBox *win)
+{
+    // This callback is actually hooked into the text entry
+    // of the combo box, not the GtkHBox.
+
+    int w, h;
+    win->GetSize( &w, &h );
+    if (w < 2)
+        w = 2;
+    if (h < 2)
+        h = 2;
+
+    GtkCombo *gcombo = GTK_COMBO(win->m_widget);
+
+    GtkRequisition entry_req;
+    entry_req.width = 2;
+    entry_req.height = 2;
+    (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->entry) )->size_request )
+        (gcombo->entry, &entry_req );
+
+    GtkRequisition button_req;
+    button_req.width = 2;
+    button_req.height = 2;
+    (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request )
+        (gcombo->button, &button_req );
+
+    requisition->width = w - button_req.width;
+    requisition->height = entry_req.height;
+}
+}

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

-// key event conversion routines
+// "expose_event" of m_wxwindow

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

-#if (GTK_MINOR_VERSION == 0)
-/* these functions are copied verbatim from GTK 1.2 */
-static void
-gdkx_XConvertCase (KeySym symbol,
-                   KeySym *lower,
-                   KeySym *upper)
-{
-  register KeySym sym = symbol;
-
-  g_return_if_fail (lower != NULL);
-  g_return_if_fail (upper != NULL);
-
-  *lower = sym;
-  *upper = sym;
-
-  switch (sym >> 8)
-    {
-#if        defined (GDK_A) && defined (GDK_Ooblique)
-    case 0: /* Latin 1 */
-      if ((sym >= GDK_A) && (sym <= GDK_Z))
-        *lower += (GDK_a - GDK_A);
-      else if ((sym >= GDK_a) && (sym <= GDK_z))
-        *upper -= (GDK_a - GDK_A);
-      else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
-        *lower += (GDK_agrave - GDK_Agrave);
-      else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
-        *upper -= (GDK_agrave - GDK_Agrave);
-      else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
-        *lower += (GDK_oslash - GDK_Ooblique);
-      else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
-        *upper -= (GDK_oslash - GDK_Ooblique);
-      break;
-#endif        /* LATIN1 */
-
-#if        defined (GDK_Aogonek) && defined (GDK_tcedilla)
-    case 1: /* Latin 2 */
-      /* Assume the KeySym is a legal value (ignore discontinuities) */
-      if (sym == GDK_Aogonek)
-        *lower = GDK_aogonek;
-      else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
-        *lower += (GDK_lstroke - GDK_Lstroke);
-      else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
-        *lower += (GDK_scaron - GDK_Scaron);
-      else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
-        *lower += (GDK_zcaron - GDK_Zcaron);
-      else if (sym == GDK_aogonek)
-        *upper = GDK_Aogonek;
-      else if (sym >= GDK_lstroke && sym <= GDK_sacute)
-        *upper -= (GDK_lstroke - GDK_Lstroke);
-      else if (sym >= GDK_scaron && sym <= GDK_zacute)
-        *upper -= (GDK_scaron - GDK_Scaron);
-      else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
-        *upper -= (GDK_zcaron - GDK_Zcaron);
-      else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
-        *lower += (GDK_racute - GDK_Racute);
-      else if (sym >= GDK_racute && sym <= GDK_tcedilla)
-        *upper -= (GDK_racute - GDK_Racute);
-      break;
-#endif        /* LATIN2 */
-
-#if        defined (GDK_Hstroke) && defined (GDK_Cabovedot)
-    case 2: /* Latin 3 */
-      /* Assume the KeySym is a legal value (ignore discontinuities) */
-      if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
-        *lower += (GDK_hstroke - GDK_Hstroke);
-      else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
-        *lower += (GDK_gbreve - GDK_Gbreve);
-      else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
-        *upper -= (GDK_hstroke - GDK_Hstroke);
-      else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
-        *upper -= (GDK_gbreve - GDK_Gbreve);
-      else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
-        *lower += (GDK_cabovedot - GDK_Cabovedot);
-      else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
-        *upper -= (GDK_cabovedot - GDK_Cabovedot);
-      break;
-#endif        /* LATIN3 */
-
-#if        defined (GDK_Rcedilla) && defined (GDK_Amacron)
-    case 3: /* Latin 4 */
-      /* Assume the KeySym is a legal value (ignore discontinuities) */
-      if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
-        *lower += (GDK_rcedilla - GDK_Rcedilla);
-      else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
-        *upper -= (GDK_rcedilla - GDK_Rcedilla);
-      else if (sym == GDK_ENG)
-        *lower = GDK_eng;
-      else if (sym == GDK_eng)
-        *upper = GDK_ENG;
-      else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
-        *lower += (GDK_amacron - GDK_Amacron);
-      else if (sym >= GDK_amacron && sym <= GDK_umacron)
-        *upper -= (GDK_amacron - GDK_Amacron);
-      break;
-#endif        /* LATIN4 */
-
-#if        defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
-    case 6: /* Cyrillic */
-      /* Assume the KeySym is a legal value (ignore discontinuities) */
-      if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
-        *lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
-      else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
-        *upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
-      else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
-        *lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
-      else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
-        *upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
-      break;
-#endif        /* CYRILLIC */
-
-#if        defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
-    case 7: /* Greek */
-      /* Assume the KeySym is a legal value (ignore discontinuities) */
-      if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
-        *lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
-      else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
-               sym != GDK_Greek_iotaaccentdieresis &&
-               sym != GDK_Greek_upsilonaccentdieresis)
-        *upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
-      else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
-        *lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
-      else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
-               sym != GDK_Greek_finalsmallsigma)
-        *upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
-      break;
-#endif        /* GREEK */
-    }
-}
-
-static guint
-gdk_keyval_to_upper (guint          keyval)
-{
-  if (keyval)
-    {
-      KeySym lower_val = 0;
-      KeySym upper_val = 0;
-
-      gdkx_XConvertCase (keyval, &lower_val, &upper_val);
-      return upper_val;
-    }
-  return 0;
-}
+extern "C" {
+static gboolean
+gtk_window_expose_callback( GtkWidget *widget,
+                            GdkEventExpose *gdk_event,
+                            wxWindow *win )
+{
+    DEBUG_MAIN_THREAD
+
+    // This callback gets called in drawing-idle time under
+    // GTK 2.0, so we don't need to defer anything to idle
+    // time anymore.
+
+    GtkPizza *pizza = GTK_PIZZA( widget );
+    if (gdk_event->window != pizza->bin_window)
+    {
+        // block expose events on GTK_WIDGET(pizza)->window,
+        //   all drawing is done on pizza->bin_window
+        return true;
+    }
+
+
+#if 0
+    if (win->GetName())
+    {
+        wxPrintf( wxT("OnExpose from ") );
+        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+            wxPrintf( win->GetClassInfo()->GetClassName() );
+        wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
+                                         (int)gdk_event->area.y,
+                                         (int)gdk_event->area.width,
+                                         (int)gdk_event->area.height );
+    }
+
+    gtk_paint_box
+    (
+        win->m_wxwindow->style,
+        pizza->bin_window,
+        GTK_STATE_NORMAL,
+        GTK_SHADOW_OUT,
+        (GdkRectangle*) NULL,
+        win->m_wxwindow,
+        (char *)"button", // const_cast
+        20,20,24,24
+    );

 #endif
 
 #endif
 

-static long map_to_unmodified_wx_keysym( KeySym keysym )
+    win->GetUpdateRegion() = wxRegion( gdk_event->region );
+
+    win->GtkSendPaintEvents();
+
+    // Let parent window draw window-less widgets
+    return FALSE;
+}
+}
+
+//-----------------------------------------------------------------------------
+// "key_press_event" from any window
+//-----------------------------------------------------------------------------
+
+// These are used when transforming Ctrl-alpha to ascii values 1-26
+inline bool wxIsLowerChar(int code)
+{
+    return (code >= 'a' && code <= 'z' );
+}
+
+inline bool wxIsUpperChar(int code)
+{
+    return (code >= 'A' && code <= 'Z' );
+}
+
+
+// set WXTRACE to this to see the key event codes on the console
+#define TRACE_KEYS  _T("keyevent")
+
+// translates an X key symbol to WXK_XXX value
+//
+// if isChar is true it means that the value returned will be used for EVT_CHAR
+// event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
+// for example, while if it is false it means that the value is going to be
+// used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
+// WXK_NUMPAD_DIVIDE
+static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)

 {
 {

-    guint key_code = 0;
+    long key_code;

 
 

-    switch (keysym)
+    switch ( keysym )

     {
     {

+        // Shift, Control and Alt don't generate the CHAR events at all

         case GDK_Shift_L:
         case GDK_Shift_L:

-        case GDK_Shift_R:       key_code = WXK_SHIFT;       break;
+        case GDK_Shift_R:
+            key_code = isChar ? 0 : WXK_SHIFT;
+            break;

         case GDK_Control_L:
         case GDK_Control_L:

-        case GDK_Control_R:     key_code = WXK_CONTROL;     break;
+        case GDK_Control_R:
+            key_code = isChar ? 0 : WXK_CONTROL;
+            break;

         case GDK_Meta_L:
         case GDK_Meta_R:
         case GDK_Alt_L:
         case GDK_Alt_R:
         case GDK_Super_L:
         case GDK_Meta_L:
         case GDK_Meta_R:
         case GDK_Alt_L:
         case GDK_Alt_R:
         case GDK_Super_L:

-        case GDK_Super_R:       key_code = WXK_ALT;         break;
-        case GDK_Menu:          key_code = WXK_MENU;        break;
-        case GDK_Help:          key_code = WXK_HELP;        break;
-        case GDK_BackSpace:     key_code = WXK_BACK;        break;
+        case GDK_Super_R:
+            key_code = isChar ? 0 : WXK_ALT;
+            break;
+
+        // neither do the toggle modifies
+        case GDK_Scroll_Lock:
+            key_code = isChar ? 0 : WXK_SCROLL;
+            break;
+
+        case GDK_Caps_Lock:
+            key_code = isChar ? 0 : WXK_CAPITAL;
+            break;
+
+        case GDK_Num_Lock:
+            key_code = isChar ? 0 : WXK_NUMLOCK;
+            break;
+
+
+        // various other special keys
+        case GDK_Menu:
+            key_code = WXK_MENU;
+            break;
+
+        case GDK_Help:
+            key_code = WXK_HELP;
+            break;
+
+        case GDK_BackSpace:
+            key_code = WXK_BACK;
+            break;
+

         case GDK_ISO_Left_Tab:
         case GDK_ISO_Left_Tab:

-        case GDK_Tab:           key_code = WXK_TAB;         break;
-        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
-        case GDK_Clear:         key_code = WXK_CLEAR;       break;
-        case GDK_Return:        key_code = WXK_RETURN;      break;
-        case GDK_Pause:         key_code = WXK_PAUSE;       break;
-        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
-        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
-        case GDK_Delete:        key_code = WXK_DELETE;      break;
-        case GDK_Home:          key_code = WXK_HOME;        break;
-        case GDK_Left:          key_code = WXK_LEFT;        break;
-        case GDK_Up:            key_code = WXK_UP;          break;
-        case GDK_Right:         key_code = WXK_RIGHT;       break;
-        case GDK_Down:          key_code = WXK_DOWN;        break;
-        case GDK_Prior:         key_code = WXK_PRIOR;       break;
-//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
-        case GDK_Next:          key_code = WXK_NEXT;        break;
-//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
-        case GDK_End:           key_code = WXK_END;         break;
-        case GDK_Begin:         key_code = WXK_HOME;        break;
-        case GDK_Select:        key_code = WXK_SELECT;      break;
-        case GDK_Print:         key_code = WXK_PRINT;       break;
-        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
-        case GDK_Insert:        key_code = WXK_INSERT;      break;
-        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
-
-        case GDK_KP_0:         key_code = WXK_NUMPAD0;      break;
-        case GDK_KP_1:         key_code = WXK_NUMPAD1;      break;
-        case GDK_KP_2:         key_code = WXK_NUMPAD2;      break;
-        case GDK_KP_3:         key_code = WXK_NUMPAD3;      break;
-        case GDK_KP_4:         key_code = WXK_NUMPAD4;      break;
-        case GDK_KP_5:         key_code = WXK_NUMPAD5;      break;
-        case GDK_KP_6:         key_code = WXK_NUMPAD6;      break;
-        case GDK_KP_7:         key_code = WXK_NUMPAD7;      break;
-        case GDK_KP_8:         key_code = WXK_NUMPAD8;      break;
-        case GDK_KP_9:         key_code = WXK_NUMPAD9;      break;
-        case GDK_KP_Space:     key_code = WXK_NUMPAD_SPACE; break;
-        case GDK_KP_Tab:       key_code = WXK_NUMPAD_TAB;   break;
-        case GDK_KP_Enter:     key_code = WXK_NUMPAD_ENTER; break;
-        case GDK_KP_F1:        key_code = WXK_NUMPAD_F1;    break;
-        case GDK_KP_F2:        key_code = WXK_NUMPAD_F2;    break;
-        case GDK_KP_F3:        key_code = WXK_NUMPAD_F3;    break;
-        case GDK_KP_F4:        key_code = WXK_NUMPAD_F4;    break;
-        case GDK_KP_Home:      key_code = WXK_NUMPAD_HOME;  break;
-        case GDK_KP_Left:      key_code = WXK_NUMPAD_LEFT;  break;
-        case GDK_KP_Up:        key_code = WXK_NUMPAD_UP;    break;
-        case GDK_KP_Right:     key_code = WXK_NUMPAD_RIGHT; break;
-        case GDK_KP_Down:      key_code = WXK_NUMPAD_DOWN;  break;
-        case GDK_KP_Prior:     key_code = WXK_NUMPAD_PRIOR; break;
-//      case GDK_KP_Page_Up:   key_code = WXK_NUMPAD_PAGEUP;   break;
-        case GDK_KP_Next:      key_code = WXK_NUMPAD_NEXT;  break;
-//      case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break;
-        case GDK_KP_End:       key_code = WXK_NUMPAD_END;   break;
-        case GDK_KP_Begin:     key_code = WXK_NUMPAD_BEGIN; break;
-        case GDK_KP_Insert:    key_code = WXK_NUMPAD_INSERT; break;
-        case GDK_KP_Delete:    key_code = WXK_NUMPAD_DELETE; break;
-        case GDK_KP_Equal:     key_code = WXK_NUMPAD_EQUAL;  break;
-        case GDK_KP_Multiply:  key_code = WXK_NUMPAD_MULTIPLY; break;
-        case GDK_KP_Add:       key_code = WXK_NUMPAD_ADD;    break;
-        case GDK_KP_Separator: key_code = WXK_NUMPAD_SEPARATOR; break;
-        case GDK_KP_Subtract:  key_code = WXK_NUMPAD_SUBTRACT;  break;
-        case GDK_KP_Decimal:   key_code = WXK_NUMPAD_DECIMAL;   break;
-        case GDK_KP_Divide:    key_code = WXK_NUMPAD_DIVIDE;    break;
-
-        case GDK_F1:            key_code = WXK_F1;          break;
-        case GDK_F2:            key_code = WXK_F2;          break;
-        case GDK_F3:            key_code = WXK_F3;          break;
-        case GDK_F4:            key_code = WXK_F4;          break;
-        case GDK_F5:            key_code = WXK_F5;          break;
-        case GDK_F6:            key_code = WXK_F6;          break;
-        case GDK_F7:            key_code = WXK_F7;          break;
-        case GDK_F8:            key_code = WXK_F8;          break;
-        case GDK_F9:            key_code = WXK_F9;          break;
-        case GDK_F10:           key_code = WXK_F10;         break;
-        case GDK_F11:           key_code = WXK_F11;         break;
-        case GDK_F12:           key_code = WXK_F12;         break;
+        case GDK_Tab:
+            key_code = WXK_TAB;
+            break;
+
+        case GDK_Linefeed:
+        case GDK_Return:
+            key_code = WXK_RETURN;
+            break;
+
+        case GDK_Clear:
+            key_code = WXK_CLEAR;
+            break;
+
+        case GDK_Pause:
+            key_code = WXK_PAUSE;
+            break;
+
+        case GDK_Select:
+            key_code = WXK_SELECT;
+            break;
+
+        case GDK_Print:
+            key_code = WXK_PRINT;
+            break;
+
+        case GDK_Execute:
+            key_code = WXK_EXECUTE;
+            break;
+
+        case GDK_Escape:
+            key_code = WXK_ESCAPE;
+            break;
+
+        // cursor and other extended keyboard keys
+        case GDK_Delete:
+            key_code = WXK_DELETE;
+            break;
+
+        case GDK_Home:
+            key_code = WXK_HOME;
+            break;
+
+        case GDK_Left:
+            key_code = WXK_LEFT;
+            break;
+
+        case GDK_Up:
+            key_code = WXK_UP;
+            break;
+
+        case GDK_Right:
+            key_code = WXK_RIGHT;
+            break;
+
+        case GDK_Down:
+            key_code = WXK_DOWN;
+            break;
+
+        case GDK_Prior:     // == GDK_Page_Up
+            key_code = WXK_PAGEUP;
+            break;
+
+        case GDK_Next:      // == GDK_Page_Down
+            key_code = WXK_PAGEDOWN;
+            break;
+
+        case GDK_End:
+            key_code = WXK_END;
+            break;
+
+        case GDK_Begin:
+            key_code = WXK_HOME;
+            break;
+
+        case GDK_Insert:
+            key_code = WXK_INSERT;
+            break;
+
+
+        // numpad keys
+        case GDK_KP_0:
+        case GDK_KP_1:
+        case GDK_KP_2:
+        case GDK_KP_3:
+        case GDK_KP_4:
+        case GDK_KP_5:
+        case GDK_KP_6:
+        case GDK_KP_7:
+        case GDK_KP_8:
+        case GDK_KP_9:
+            key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
+            break;
+
+        case GDK_KP_Space:
+            key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
+            break;
+
+        case GDK_KP_Tab:
+            key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
+            break;
+
+        case GDK_KP_Enter:
+            key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
+            break;
+
+        case GDK_KP_F1:
+            key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
+            break;
+
+        case GDK_KP_F2:
+            key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
+            break;
+
+        case GDK_KP_F3:
+            key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
+            break;
+
+        case GDK_KP_F4:
+            key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
+            break;
+
+        case GDK_KP_Home:
+            key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
+            break;
+
+        case GDK_KP_Left:
+            key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
+            break;
+
+        case GDK_KP_Up:
+            key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
+            break;
+
+        case GDK_KP_Right:
+            key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
+            break;
+
+        case GDK_KP_Down:
+            key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
+            break;
+
+        case GDK_KP_Prior: // == GDK_KP_Page_Up
+            key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
+            break;
+
+        case GDK_KP_Next: // == GDK_KP_Page_Down
+            key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
+            break;
+
+        case GDK_KP_End:
+            key_code = isChar ? WXK_END : WXK_NUMPAD_END;
+            break;
+
+        case GDK_KP_Begin:
+            key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
+            break;
+
+        case GDK_KP_Insert:
+            key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
+            break;
+
+        case GDK_KP_Delete:
+            key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
+            break;
+
+        case GDK_KP_Equal:
+            key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
+            break;
+
+        case GDK_KP_Multiply:
+            key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
+            break;
+
+        case GDK_KP_Add:
+            key_code = isChar ? '+' : WXK_NUMPAD_ADD;
+            break;
+
+        case GDK_KP_Separator:
+            // FIXME: what is this?
+            key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
+            break;
+
+        case GDK_KP_Subtract:
+            key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
+            break;
+
+        case GDK_KP_Decimal:
+            key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
+            break;
+
+        case GDK_KP_Divide:
+            key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
+            break;
+
+
+        // function keys
+        case GDK_F1:
+        case GDK_F2:
+        case GDK_F3:
+        case GDK_F4:
+        case GDK_F5:
+        case GDK_F6:
+        case GDK_F7:
+        case GDK_F8:
+        case GDK_F9:
+        case GDK_F10:
+        case GDK_F11:
+        case GDK_F12:
+            key_code = WXK_F1 + keysym - GDK_F1;
+            break;
+

         default:
         default:

-        {
-            if (keysym <= 0xFF)
-            {
-                guint upper = gdk_keyval_to_upper( keysym );
-                keysym = (upper != 0 ? upper : keysym ); /* to be MSW compatible */
-                key_code = keysym;
-            }
-        }
+            key_code = 0;

     }
 
     }
 

-    return (key_code);
+    return key_code;

 }
 
 }
 

-static long map_to_wx_keysym( KeySym keysym )
+static inline bool wxIsAsciiKeysym(KeySym ks)

 {
 {

-    guint key_code = 0;
+    return ks < 256;
+}

 
 

-    switch (keysym)
-    {
-        case GDK_Menu:          key_code = WXK_MENU;        break;
-        case GDK_Help:          key_code = WXK_HELP;        break;
-        case GDK_BackSpace:     key_code = WXK_BACK;        break;
-        case GDK_ISO_Left_Tab:
-        case GDK_Tab:           key_code = WXK_TAB;         break;
-        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
-        case GDK_Clear:         key_code = WXK_CLEAR;       break;
-        case GDK_Return:        key_code = WXK_RETURN;      break;
-        case GDK_Pause:         key_code = WXK_PAUSE;       break;
-        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
-        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
-        case GDK_Delete:        key_code = WXK_DELETE;      break;
-        case GDK_Home:          key_code = WXK_HOME;        break;
-        case GDK_Left:          key_code = WXK_LEFT;        break;
-        case GDK_Up:            key_code = WXK_UP;          break;
-        case GDK_Right:         key_code = WXK_RIGHT;       break;
-        case GDK_Down:          key_code = WXK_DOWN;        break;
-        case GDK_Prior:         key_code = WXK_PRIOR;       break;
-//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
-        case GDK_Next:          key_code = WXK_NEXT;        break;
-//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
-        case GDK_End:           key_code = WXK_END;         break;
-        case GDK_Begin:         key_code = WXK_HOME;        break;
-        case GDK_Select:        key_code = WXK_SELECT;      break;
-        case GDK_Print:         key_code = WXK_PRINT;       break;
-        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
-        case GDK_Insert:        key_code = WXK_INSERT;      break;
-        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
-
-        case GDK_KP_0:         key_code = '0';      break;
-        case GDK_KP_1:         key_code = '1';      break;
-        case GDK_KP_2:         key_code = '2';      break;
-        case GDK_KP_3:         key_code = '3';      break;
-        case GDK_KP_4:         key_code = '4';      break;
-        case GDK_KP_5:         key_code = '5';      break;
-        case GDK_KP_6:         key_code = '6';      break;
-        case GDK_KP_7:         key_code = '7';      break;
-        case GDK_KP_8:         key_code = '8';      break;
-        case GDK_KP_9:         key_code = '9';      break;
-        case GDK_KP_Space:     key_code = ' ';      break;
-        case GDK_KP_Tab:       key_code = WXK_TAB;    break;        /* or '\t' ??? */
-        case GDK_KP_Enter:     key_code = WXK_RETURN; break;        /* or '\r' ??? */
-        case GDK_KP_F1:        key_code = WXK_NUMPAD_F1;    break;
-        case GDK_KP_F2:        key_code = WXK_NUMPAD_F2;    break;
-        case GDK_KP_F3:        key_code = WXK_NUMPAD_F3;    break;
-        case GDK_KP_F4:        key_code = WXK_NUMPAD_F4;    break;
-        case GDK_KP_Home:      key_code = WXK_HOME;  break;
-        case GDK_KP_Left:      key_code = WXK_LEFT;  break;
-        case GDK_KP_Up:        key_code = WXK_UP;    break;
-        case GDK_KP_Right:     key_code = WXK_RIGHT; break;
-        case GDK_KP_Down:      key_code = WXK_DOWN;  break;
-        case GDK_KP_Prior:     key_code = WXK_PRIOR; break;
-//      case GDK_KP_Page_Up:   key_code = WXK_PAGEUP; break;
-        case GDK_KP_Next:      key_code = WXK_NEXT;  break;
-//      case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
-        case GDK_KP_End:       key_code = WXK_END;    break;
-        case GDK_KP_Begin:     key_code = WXK_HOME;   break;
-        case GDK_KP_Insert:    key_code = WXK_INSERT; break;
-        case GDK_KP_Delete:    key_code = WXK_DELETE; break;
-        case GDK_KP_Equal:     key_code = '=';   break;
-        case GDK_KP_Multiply:  key_code = '*';   break;
-        case GDK_KP_Add:       key_code = '+';   break;
-        case GDK_KP_Separator: key_code = ',';   break;
-        case GDK_KP_Subtract:  key_code = '-';   break;
-        case GDK_KP_Decimal:   key_code = '.';   break;
-        case GDK_KP_Divide:    key_code = '/';   break;
-
-        case GDK_F1:            key_code = WXK_F1;          break;
-        case GDK_F2:            key_code = WXK_F2;          break;
-        case GDK_F3:            key_code = WXK_F3;          break;
-        case GDK_F4:            key_code = WXK_F4;          break;
-        case GDK_F5:            key_code = WXK_F5;          break;
-        case GDK_F6:            key_code = WXK_F6;          break;
-        case GDK_F7:            key_code = WXK_F7;          break;
-        case GDK_F8:            key_code = WXK_F8;          break;
-        case GDK_F9:            key_code = WXK_F9;          break;
-        case GDK_F10:           key_code = WXK_F10;         break;
-        case GDK_F11:           key_code = WXK_F11;         break;
-        case GDK_F12:           key_code = WXK_F12;         break;
-        default:
-        {
-            if (keysym <= 0xFF)
-            {
-                key_code = keysym;
-            }
-        }
-    }
+static void wxFillOtherKeyEventFields(wxKeyEvent& event,
+                                      wxWindowGTK *win,
+                                      GdkEventKey *gdk_event)
+{
+    int x = 0;
+    int y = 0;
+    GdkModifierType state;
+    if (gdk_event->window)
+        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);

 
 

-    return (key_code);
+    event.SetTimestamp( gdk_event->time );
+    event.SetId(win->GetId());
+    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
+    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
+    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
+    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
+    event.m_scanCode = gdk_event->keyval;
+    event.m_rawCode = (wxUint32) gdk_event->keyval;
+    event.m_rawFlags = 0;
+#if wxUSE_UNICODE
+    event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
+#endif
+    wxGetMousePosition( &x, &y );
+    win->ScreenToClient( &x, &y );
+    event.m_x = x;
+    event.m_y = y;
+    event.SetEventObject( win );

 }
 
 }
 

-//-----------------------------------------------------------------------------
-// "expose_event" of m_wxwindow
-//-----------------------------------------------------------------------------

 
 

-static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
+static bool
+wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
+                           wxWindowGTK *win,
+                           GdkEventKey *gdk_event)

 {
 {

-    if (!win->m_hasVMT)
-        return;
+    // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
+    //     but only event->keyval which is quite useless to us, so remember
+    //     the last character from GDK_KEY_PRESS and reuse it as last resort
+    //
+    // NB: should be MT-safe as we're always called from the main thread only
+    static struct
+    {
+        KeySym keysym;
+        long   keycode;
+    } s_lastKeyPress = { 0, 0 };

 
 

-    win->GetUpdateRegion().Union( gdk_event->area.x,
-                                  gdk_event->area.y,
-                                  gdk_event->area.width,
-                                  gdk_event->area.height );
+    KeySym keysym = gdk_event->keyval;

 
 

-    if (gdk_event->count > 0)
-        return;
+    wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
+               event.GetEventType() == wxEVT_KEY_UP ? _T("release")
+                                                    : _T("press"),
+               keysym);

 
 

-/*
-    wxPrintf( "OnExpose from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( " %d %d %d %d\n", (int)gdk_event->area.x,
-                                (int)gdk_event->area.y,
-                                (int)gdk_event->area.width,
-                                (int)gdk_event->area.height );
-*/
+    long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);

 
 

-    wxEraseEvent eevent( win->GetId() );
-    eevent.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent(eevent);
-    
-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    if ( !key_code )
+    {
+        // do we have the translation or is it a plain ASCII character?
+        if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
+        {
+            // we should use keysym if it is ASCII as X does some translations
+            // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
+            // which we don't want here (but which we do use for OnChar())
+            if ( !wxIsAsciiKeysym(keysym) )
+            {
+                keysym = (KeySym)gdk_event->string[0];
+            }

 
 

-    win->GetUpdateRegion().Clear();
-}
+            // we want to always get the same key code when the same key is
+            // pressed regardless of the state of the modifiers, i.e. on a
+            // standard US keyboard pressing '5' or '%' ('5' key with
+            // Shift) should result in the same key code in OnKeyDown():
+            // '5' (although OnChar() will get either '5' or '%').
+            //
+            // to do it we first translate keysym to keycode (== scan code)
+            // and then back but always using the lower register
+            Display *dpy = (Display *)wxGetDisplay();
+            KeyCode keycode = XKeysymToKeycode(dpy, keysym);
+
+            wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
+
+            KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
+
+            // use the normalized, i.e. lower register, keysym if we've
+            // got one
+            key_code = keysymNormalized ? keysymNormalized : keysym;
+
+            // as explained above, we want to have lower register key codes
+            // normally but for the letter keys we want to have the upper ones
+            //
+            // NB: don't use XConvertCase() here, we want to do it for letters
+            // only
+            key_code = toupper(key_code);
+        }
+        else // non ASCII key, what to do?
+        {
+            // by default, ignore it
+            key_code = 0;

 
 

-//-----------------------------------------------------------------------------
-// "draw" of m_wxwindow
-//-----------------------------------------------------------------------------
+            // but if we have cached information from the last KEY_PRESS
+            if ( gdk_event->type == GDK_KEY_RELEASE )
+            {
+                // then reuse it
+                if ( keysym == s_lastKeyPress.keysym )
+                {
+                    key_code = s_lastKeyPress.keycode;
+                }
+            }
+        }

 
 

-static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
-{
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+        if ( gdk_event->type == GDK_KEY_PRESS )
+        {
+            // remember it to be reused for KEY_UP event later
+            s_lastKeyPress.keysym = keysym;
+            s_lastKeyPress.keycode = key_code;
+        }
+    }

 
 

-    if (!win->m_hasVMT)
-        return;
+    wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);

 
 

-    win->GetUpdateRegion().Union( rect->x, rect->y,
-                                  rect->width, rect->height );
+    // sending unknown key events doesn't really make sense
+    if ( !key_code )
+        return false;

 
 

-/*
-    wxPrintf( "OnDraw from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( " %d %d %d %d\n", (int)rect->x,
-                                (int)rect->y,
-                                (int)rect->width,
-                                (int)rect->height );
-*/
-                               
-    wxEraseEvent eevent( win->GetId() );
-    eevent.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent(eevent);
-    
-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    // now fill all the other fields
+    wxFillOtherKeyEventFields(event, win, gdk_event);
+
+    event.m_keyCode = key_code;
+#if wxUSE_UNICODE
+    if ( gdk_event->type == GDK_KEY_PRESS ||  gdk_event->type == GDK_KEY_RELEASE )
+    {
+        event.m_uniChar = key_code;
+    }
+#endif

 
 

-    win->GetUpdateRegion().Clear();
+    return true;

 }
 
 }
 

-//-----------------------------------------------------------------------------
-// "key_press_event" from any window
-//-----------------------------------------------------------------------------

 
 

-static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+struct wxGtkIMData

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    GtkIMContext *context;
+    GdkEventKey  *lastKeyEvent;

 
 

-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-
-/*
-    printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
-    if (gdk_event->state & GDK_SHIFT_MASK)
-      printf( "ShiftDown.\n" );
-    else
-      printf( "ShiftUp.\n" );
-    if (gdk_event->state & GDK_CONTROL_MASK)
-      printf( "ControlDown.\n" );
-    else
-      printf( "ControlUp.\n" );
-    printf( "\n" );
-*/
-    int x = 0;
-    int y = 0;
-    GdkModifierType state;
-    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+    wxGtkIMData()
+    {
+        context = gtk_im_multicontext_new();
+        lastKeyEvent = NULL;
+    }
+    ~wxGtkIMData()
+    {
+        g_object_unref (context);
+    }
+};

 
 

-    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+extern "C" {
+static gboolean
+gtk_window_key_press_callback( GtkWidget *widget,
+                               GdkEventKey *gdk_event,
+                               wxWindow *win )
+{
+    DEBUG_MAIN_THREAD

 
 

-    /* sending unknown key events doesn't really make sense */
-    if (key_code == 0) return FALSE;
+    if (!win->m_hasVMT)
+        return FALSE;
+    if (g_blockEventsOnDrag)
+        return FALSE;

 
 

-    bool ret = FALSE;

 
     wxKeyEvent event( wxEVT_KEY_DOWN );
 
     wxKeyEvent event( wxEVT_KEY_DOWN );

-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_keyCode = key_code;
-    event.m_scanCode = gdk_event->keyval;
-    event.m_x = x;
-    event.m_y = y;
-    event.SetEventObject( win );
-    ret = win->GetEventHandler()->ProcessEvent( event );
+    bool ret = false;
+    bool return_after_IM = false;

 
 

-    key_code = map_to_wx_keysym( gdk_event->keyval );
+    if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
+    {
+        // Emit KEY_DOWN event
+        ret = win->GetEventHandler()->ProcessEvent( event );
+    }
+    else
+    {
+        // Return after IM processing as we cannot do
+        // anything with it anyhow.
+        return_after_IM = true;
+    }
+
+    // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
+    // When we get a key_press event here, it could be originate
+    // from the current widget or its child widgets.  However, only the widget
+    // with the INPUT FOCUS can generate the INITIAL key_press event.  That is,
+    // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
+    // originated from its child widgets and shouldn't be passed to IM context.
+    // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
+    // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS.  Besides, when current
+    // widgets has both IM context and input focus, the event should be filtered
+    // by gtk_im_context_filter_keypress().
+    // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
+    if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win ))
+    {
+        // 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, _T("Key event intercepted by IM"));
+            return TRUE;
+        }
+    }
+
+    if (return_after_IM)
+        return FALSE;

 
 #if wxUSE_ACCEL
     if (!ret)
     {
 
 #if wxUSE_ACCEL
     if (!ret)
     {

-        wxWindow *ancestor = win;
+        wxWindowGTK *ancestor = win;

         while (ancestor)
         {
             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
         while (ancestor)
         {
             int command = ancestor->GetAcceleratorTable()->GetCommand( event );


@@ -805,319 +1045,563 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
                 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
                 break;
             }
                 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
                 break;
             }

+            if (ancestor->IsTopLevel())
+                break;

             ancestor = ancestor->GetParent();
         }
     }
 #endif // wxUSE_ACCEL
             ancestor = ancestor->GetParent();
         }
     }
 #endif // wxUSE_ACCEL

-    /* wxMSW doesn't send char events with Alt pressed */
-    /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
-       will only be sent if it is not a menu accelerator. */
-    if ((key_code != 0) && ! ret )
-    {
-        wxKeyEvent event2( wxEVT_CHAR );
-        event2.SetTimestamp( gdk_event->time );
-        event2.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-        event2.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-        event2.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-        event2.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-        event2.m_keyCode = key_code;
-        event2.m_scanCode = gdk_event->keyval;
-        event2.m_x = x;
-        event2.m_y = y;
-        event2.SetEventObject( win );
-        ret = (ret || win->GetEventHandler()->ProcessEvent( event2 ));
-    }
-
-    /* win is a control: tab can be propagated up */
-    if ( (!ret) &&
-         ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
-         (win->HasFlag(wxTE_PROCESS_TAB) == 0))
-    {
-        wxNavigationKeyEvent new_event;
-        /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
-        new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
-        /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
-        new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
-        new_event.SetCurrentFocus( win );
-        ret = win->GetEventHandler()->ProcessEvent( new_event );
-    }
-
-    /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
-    if ( (!ret) &&
-         (gdk_event->keyval == GDK_Escape) )
-    {
-        wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
-        new_event.SetEventObject( win );
-        ret = win->GetEventHandler()->ProcessEvent( new_event );
-    }
-
-#if (GTK_MINOR_VERSION > 0)
-    /* pressing F10 will activate the menu bar of the top frame */
-    if ( (!ret) &&
-         (gdk_event->keyval == GDK_F10) )
-    {
-        wxWindow *ancestor = win;
-        while (ancestor)
+
+    // 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
+        key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
+        if ( !key_code )

         {
         {

-            if (wxIsKindOf(ancestor,wxFrame))
+            if ( wxIsAsciiKeysym(keysym) )

             {
             {

-                wxFrame *frame = (wxFrame*) ancestor;
-                wxMenuBar *menubar = frame->GetMenuBar();
-                if (menubar)
-                {
-                    wxNode *node = menubar->GetMenus().First();
-                    if (node)
-                    {
-                        // doesn't work correctly
-            // wxMenu *firstMenu = (wxMenu*) node->Data();
-                        // gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
-                        // ret = TRUE;
-                        break;
-                    }
-                }
+                // ASCII key
+                key_code = (unsigned char)keysym;
+            }
+            // gdk_event->string is actually deprecated
+            else if ( gdk_event->length == 1 )
+            {
+                key_code = (unsigned char)gdk_event->string[0];

             }
             }

-            ancestor = ancestor->GetParent();

         }
         }

-    }
-#endif

 
 

-/*
-    Damn, I forgot why this didn't work, but it didn't work.
+        if ( key_code )
+        {
+            wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);

 
 

-    // win is a panel: up can be propagated to the panel
-    if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
-        (gdk_event->keyval == GDK_Up))
-    {
-        win->m_parent->SetFocus();
-        ret = TRUE;
-    }
+            event.m_keyCode = key_code;

 
 

-    // win is a panel: left/right can be propagated to the panel
-    if ((!ret) && (win->m_wxwindow) &&
-        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
-         (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
-    {
-        wxNavigationKeyEvent new_event;
-        new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
-        new_event.SetCurrentFocus( win );
-        ret = win->GetEventHandler()->ProcessEvent( new_event );
-    }
-*/
+            // To conform to the docs we need to translate Ctrl-alpha
+            // characters to values in the range 1-26.
+            if ( event.ControlDown() &&
+                 ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
+            {
+                if ( wxIsLowerChar(key_code) )
+                    event.m_keyCode = key_code - 'a' + 1;
+                if ( wxIsUpperChar(key_code) )
+                    event.m_keyCode = key_code - 'A' + 1;
+#if wxUSE_UNICODE
+                event.m_uniChar = event.m_keyCode;
+#endif
+            }

 
 

-    if (ret)
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
-        return TRUE;
+            // Implement OnCharHook by checking ancestor top level windows
+            wxWindow *parent = win;
+            while (parent && !parent->IsTopLevel())
+                parent = parent->GetParent();
+            if (parent)
+            {
+                event.SetEventType( wxEVT_CHAR_HOOK );
+                ret = parent->GetEventHandler()->ProcessEvent( event );
+            }
+
+            if (!ret)
+            {
+                event.SetEventType(wxEVT_CHAR);
+                ret = win->GetEventHandler()->ProcessEvent( event );
+            }
+        }

     }
 
     }
 

-    return FALSE;
+    return ret;
+}

 }
 
 }
 

-//-----------------------------------------------------------------------------
+extern "C" {
+static void
+gtk_wxwindow_commit_cb (GtkIMContext *context,
+                        const gchar  *str,
+                        wxWindow     *window)
+{
+    wxKeyEvent event( wxEVT_KEY_DOWN );
+
+    // take modifiers, cursor position, timestamp etc. from the last
+    // key_press_event that was fed into Input Method:
+    if (window->m_imData->lastKeyEvent)
+    {
+        wxFillOtherKeyEventFields(event,
+                                  window, window->m_imData->lastKeyEvent);
+    }
+
+    const wxWxCharBuffer data(wxGTK_CONV_BACK_SYS(str));
+    if( !data )
+        return;
+
+    bool ret = false;
+
+    // Implement OnCharHook by checking ancestor top level windows
+    wxWindow *parent = window;
+    while (parent && !parent->IsTopLevel())
+        parent = parent->GetParent();
+
+    for( const wxChar* pstr = data; *pstr; pstr++ )
+    {
+#if wxUSE_UNICODE
+        event.m_uniChar = *pstr;
+        // Backward compatible for ISO-8859-1
+        event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
+        wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
+#else
+        event.m_keyCode = *pstr;
+#endif  // wxUSE_UNICODE
+
+        // To conform to the docs we need to translate Ctrl-alpha
+        // characters to values in the range 1-26.
+        if ( event.ControlDown() &&
+             ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) ))
+        {
+            if ( wxIsLowerChar(*pstr) )
+                event.m_keyCode = *pstr - 'a' + 1;
+            if ( wxIsUpperChar(*pstr) )
+                event.m_keyCode = *pstr - 'A' + 1;
+
+            event.m_keyCode = *pstr - 'a' + 1;
+#if wxUSE_UNICODE
+            event.m_uniChar = event.m_keyCode;
+#endif
+        }
+
+        if (parent)
+        {
+            event.SetEventType( wxEVT_CHAR_HOOK );
+            ret = parent->GetEventHandler()->ProcessEvent( event );
+        }
+
+        if (!ret)
+        {
+            event.SetEventType(wxEVT_CHAR);
+            ret = window->GetEventHandler()->ProcessEvent( event );
+        }
+    }
+}
+}
+
+
+//-----------------------------------------------------------------------------

 // "key_release_event" from any window
 //-----------------------------------------------------------------------------
 
 // "key_release_event" from any window
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+extern "C" {
+static gboolean
+gtk_window_key_release_callback( GtkWidget *widget,
+                                 GdkEventKey *gdk_event,
+                                 wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    DEBUG_MAIN_THREAD

 
 

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

 
 

-/*
-    printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
-    if (gdk_event->state & GDK_SHIFT_MASK)
-      printf( "ShiftDown.\n" );
-    else
-      printf( "ShiftUp.\n" );
-    if (gdk_event->state & GDK_CONTROL_MASK)
-      printf( "ControlDown.\n" );
-    else
-      printf( "ControlUp.\n" );
-    printf( "\n" );
-*/
+    if (g_blockEventsOnDrag)
+        return FALSE;

 
 

-    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+    wxKeyEvent event( wxEVT_KEY_UP );
+    if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
+    {
+        // unknown key pressed, ignore (the event would be useless anyhow)
+        return FALSE;
+    }

 
 

-    /* sending unknown key events doesn't really make sense */
-    if (key_code == 0) return FALSE;
+    return win->GTKProcessEvent(event);
+}
+}

 
 

-    int x = 0;
-    int y = 0;
-    GdkModifierType state;
-    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+// ============================================================================
+// the mouse events
+// ============================================================================

 
 

-    wxKeyEvent event( wxEVT_KEY_UP );
+// ----------------------------------------------------------------------------
+// mouse event processing helpers
+// ----------------------------------------------------------------------------
+
+// init wxMouseEvent with the info from GdkEventXXX struct
+template<typename T> void InitMouseEvent(wxWindowGTK *win,
+                                         wxMouseEvent& event,
+                                         T *gdk_event)
+{

     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);

-    event.m_keyCode = key_code;
-    event.m_scanCode = gdk_event->keyval;
-    event.m_x = x;
-    event.m_y = y;
+    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
+    {
+       event.m_linesPerAction = 3;
+       event.m_wheelDelta = 120;
+       if (((GdkEventButton*)gdk_event)->button == 4)
+           event.m_wheelRotation = 120;
+       else if (((GdkEventButton*)gdk_event)->button == 5)
+           event.m_wheelRotation = -120;
+    }
+
+    wxPoint pt = win->GetClientAreaOrigin();
+    event.m_x = (wxCoord)gdk_event->x - pt.x;
+    event.m_y = (wxCoord)gdk_event->y - pt.y;
+
+    if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
+    {
+        // origin in the upper right corner
+        int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) );
+        event.m_x = window_width - event.m_x;
+    }
+

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

+    event.SetId( win->GetId() );
+    event.SetTimestamp( gdk_event->time );
+}
+
+static void AdjustEventButtonState(wxMouseEvent& event)
+{
+    // GDK reports the old state of the button for a button press event, but
+    // for compatibility with MSW and common sense we want m_leftDown be TRUE
+    // for a LEFT_DOWN event, not FALSE, so we will invert
+    // left/right/middleDown for the corresponding click events
+
+    if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
+        (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
+        (event.GetEventType() == wxEVT_LEFT_UP))
+    {
+        event.m_leftDown = !event.m_leftDown;
+        return;
+    }
+
+    if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
+        (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
+        (event.GetEventType() == wxEVT_MIDDLE_UP))
+    {
+        event.m_middleDown = !event.m_middleDown;
+        return;
+    }

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
+    if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
+        (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
+        (event.GetEventType() == wxEVT_RIGHT_UP))

     {
     {

-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
+        event.m_rightDown = !event.m_rightDown;
+        return;
+    }
+}
+
+// find the window to send the mouse event too
+static
+wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
+{
+    wxCoord xx = x;
+    wxCoord yy = y;
+
+    if (win->m_wxwindow)
+    {
+        GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+        xx += gtk_pizza_get_xoffset( pizza );
+        yy += gtk_pizza_get_yoffset( pizza );
+    }
+
+    wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
+    while (node)
+    {
+        wxWindowGTK *child = node->GetData();
+
+        node = node->GetNext();
+        if (!child->IsShown())
+            continue;
+
+        if (child->IsTransparentForMouse())
+        {
+            // wxStaticBox is transparent in the box itself
+            int xx1 = child->m_x;
+            int yy1 = child->m_y;
+            int xx2 = child->m_x + child->m_width;
+            int yy2 = child->m_y + child->m_height;
+
+            // left
+            if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
+            // right
+                ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
+            // top
+                ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
+            // bottom
+                ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
+            {
+                win = child;
+                x -= child->m_x;
+                y -= child->m_y;
+                break;
+            }
+
+        }
+        else
+        {
+            if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+                (child->m_x <= xx) &&
+                (child->m_y <= yy) &&
+                (child->m_x+child->m_width  >= xx) &&
+                (child->m_y+child->m_height >= yy))
+            {
+                win = child;
+                x -= child->m_x;
+                y -= child->m_y;
+                break;
+            }
+        }
+    }
+
+    return win;
+}
+
+// ----------------------------------------------------------------------------
+// common event handlers helpers
+// ----------------------------------------------------------------------------
+
+bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
+{
+    // nothing special at this level
+    return GetEventHandler()->ProcessEvent(event);
+}
+
+int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
+{
+    DEBUG_MAIN_THREAD
+
+    if (!m_hasVMT)
+        return FALSE;
+    if (g_blockEventsOnDrag)
+        return TRUE;
+    if (g_blockEventsOnScroll)

         return TRUE;
         return TRUE;

+
+    if (!GTKIsOwnWindow(event->window))
+        return FALSE;
+
+    return -1;
+}
+
+// overloads for all GDK event types we use here: we need to have this as
+// GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
+// derives from it in the sense that the structs have the same layout
+#define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T)                                  \
+    static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win)        \
+    {                                                                         \
+        return win->GTKCallbackCommonPrologue((GdkEventAny *)event);          \

     }
 
     }
 

-    return FALSE;
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
+
+#undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
+
+#define wxCOMMON_CALLBACK_PROLOGUE(event, win)                                \
+    const int rc = wxGtkCallbackCommonPrologue(event, win);                   \
+    if ( rc != -1 )                                                           \
+        return rc
+
+// send the wxChildFocusEvent and wxFocusEvent, common code of
+// gtk_window_focus_in_callback() and SetFocus()
+static bool DoSendFocusEvents(wxWindow *win)
+{
+    // Notify the parent keeping track of focus for the kbd navigation
+    // purposes that we got it.
+    wxChildFocusEvent eventChildFocus(win);
+    (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+
+    wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
+    eventFocus.SetEventObject(win);
+
+    return win->GetEventHandler()->ProcessEvent(eventFocus);

 }
 
 }
 

+// all event handlers must have C linkage as they're called from GTK+ C code
+extern "C"
+{
+

 //-----------------------------------------------------------------------------
 // "button_press_event"
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // "button_press_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
+static gboolean
+gtk_window_button_press_callback( GtkWidget *widget,
+                                  GdkEventButton *gdk_event,
+                                  wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);

 
 

-/*
-    wxPrintf( wxT("1) OnButtonPress from ") );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( wxT(".\n") );
-*/
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return TRUE;
-    if (g_blockEventsOnScroll) return TRUE;
+    g_lastButtonNumber = gdk_event->button;

 
 

-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    if (win->m_wxwindow && (g_focusWindow != win) && win->CanAcceptFocus())
+    {
+        gtk_widget_grab_focus( win->m_wxwindow );
+    }

 
 

-    if (win->m_wxwindow)
+    // 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))

     {
     {

-        if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
+        GdkEvent *peek_event = gdk_event_peek();
+        if (peek_event)

         {
         {

-            gtk_widget_grab_focus (win->m_wxwindow);
-
-/*
-            wxPrintf( wxT("GrabFocus from ") );
-            if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-                wxPrintf( win->GetClassInfo()->GetClassName() );
-            wxPrintf( wxT(".\n") );
-*/
-
+            if ((peek_event->type == GDK_2BUTTON_PRESS) ||
+                (peek_event->type == GDK_3BUTTON_PRESS))
+            {
+                gdk_event_free( peek_event );
+                return TRUE;
+            }
+            else
+            {
+                gdk_event_free( peek_event );
+            }

         }
     }
 
         }
     }
 

-/*
-    wxPrintf( wxT("2) OnButtonPress from ") );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( wxT(".\n") );
-*/
+    wxEventType event_type = wxEVT_NULL;

 
 

-    wxEventType event_type = wxEVT_LEFT_DOWN;
+    // GdkDisplay is a GTK+ 2.2.0 thing
+#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
+    if ( gdk_event->type == GDK_2BUTTON_PRESS &&
+            !gtk_check_version(2,2,0) &&
+            gdk_event->button >= 1 && gdk_event->button <= 3 )
+    {
+        // Reset GDK internal timestamp variables in order to disable GDK
+        // 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;
+    }
+#endif // GTK 2+

 
     if (gdk_event->button == 1)
     {
 
     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)
         {
         switch (gdk_event->type)
         {

-            case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
-            default:  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 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)
         {
         }
     }
     else if (gdk_event->button == 2)
     {
         switch (gdk_event->type)
         {

-            case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
-            default:  break;
+            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)
         {
         }
     }
     else if (gdk_event->button == 3)
     {
         switch (gdk_event->type)
         {

-            case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
-            default:  break;
+            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 == 4 || gdk_event->button == 5)
+    {
+        if (gdk_event->type == GDK_BUTTON_PRESS )
+        {
+            event_type = wxEVT_MOUSEWHEEL;

         }
     }
 
         }
     }
 

-    wxMouseEvent event( event_type );
-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    if ( event_type == wxEVT_NULL )
+    {
+        // unknown mouse button or click type
+        return FALSE;
+    }

 
 

-    event.m_x = (long)gdk_event->x;
-    event.m_y = (long)gdk_event->y;
+    g_lastMouseEvent = (GdkEvent*) gdk_event;

 
 

-    // Some control don't have their own X window and thus cannot get
-    // any events.
+    wxMouseEvent event( event_type );
+    InitMouseEvent( win, event, gdk_event );

 
 

-    if (!g_captureWindow)
-    {
-        wxNode *node = win->GetChildren().First();
-        while (node)
-        {
-            wxWindow *child = (wxWindow*)node->Data();
+    AdjustEventButtonState(event);

 
 

-            if (child->m_isStaticBox)
-            {
-                // wxStaticBox is transparent in the box itself
-                int x = event.m_x;
-                int y = event.m_y;
-                int xx1 = child->m_x;
-                int yy1 = child->m_y;
-                int xx2 = child->m_x + child->m_width;
-                int yy2 = child->m_x + child->m_height;
-
-                // left
-                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-                // right
-                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-                // top
-                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-                // bottom
-                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
+    // wxListBox actually gets mouse events from the item, so we need to give it
+    // a chance to correct this
+    win->FixUpMouseEvent(widget, event.m_x, event.m_y);

 
 

-            }
-            else
-            {
-                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
-                    (child->m_x <= event.m_x) &&
-                    (child->m_y <= event.m_y) &&
-                    (child->m_x+child->m_width  >= event.m_x) &&
-                    (child->m_y+child->m_height >= event.m_y))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
-            }
-            node = node->Next();
-        }
-    }
+    // find the correct window to send the event to: it may be a different one
+    // from the one which got it at GTK+ level because some controls don't have
+    // their own X window and thus cannot get any events.
+    if ( !g_captureWindow )
+        win = FindWindowForMouseEvent(win, event.m_x, event.m_y);

 
 

+    // reset the event object and id in case win changed.

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

+    event.SetId( win->GetId() );

 
 

-    gs_timeLastClick = gdk_event->time;
+    bool ret = win->GTKProcessEvent( event );
+    g_lastMouseEvent = NULL;
+    if ( ret )
+        return TRUE;

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
+    if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && 
+        (g_focusWindow != win) && win->CanAcceptFocus())

     {
     {

-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
-        return TRUE;
+        gtk_widget_grab_focus( win->m_wxwindow );
+    }
+
+    if (event_type == wxEVT_RIGHT_DOWN)
+    {
+        // generate a "context menu" event: this is similar to right mouse
+        // click under many GUIs except that it is generated differently
+        // (right up under MSW, ctrl-click under Mac, right down here) and
+        //
+        // (a) it's a command event and so is propagated to the parent
+        // (b) under some ports it can be generated from kbd too
+        // (c) it uses screen coords (because of (a))
+        wxContextMenuEvent evtCtx(
+            wxEVT_CONTEXT_MENU,
+            win->GetId(),
+            win->ClientToScreen(event.GetPosition()));
+        evtCtx.SetEventObject(win);
+        return win->GTKProcessEvent(evtCtx);

     }
 
     return FALSE;
     }
 
     return FALSE;


@@ -1127,124 +1611,70 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 // "button_release_event"
 //-----------------------------------------------------------------------------
 
 // "button_release_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
+static gboolean
+gtk_window_button_release_callback( GtkWidget *widget,
+                                    GdkEventButton *gdk_event,
+                                    wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-    if (g_blockEventsOnScroll) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);

 
 

-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-
-/*
-    printf( "OnButtonRelease from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    g_lastButtonNumber = 0;

 
     wxEventType event_type = wxEVT_NULL;
 
     switch (gdk_event->button)
     {
 
     wxEventType event_type = wxEVT_NULL;
 
     switch (gdk_event->button)
     {

-        case 1: event_type = wxEVT_LEFT_UP; break;
-        case 2: event_type = wxEVT_MIDDLE_UP; break;
-        case 3: event_type = wxEVT_RIGHT_UP; break;
+        case 1:
+            event_type = wxEVT_LEFT_UP;
+            break;
+
+        case 2:
+            event_type = wxEVT_MIDDLE_UP;
+            break;
+
+        case 3:
+            event_type = wxEVT_RIGHT_UP;
+            break;
+
+        default:
+            // unknown button, don't process
+            return FALSE;

     }
 
     }
 

-    wxMouseEvent event( event_type );
-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-    event.m_x = (long)gdk_event->x;
-    event.m_y = (long)gdk_event->y;
+    g_lastMouseEvent = (GdkEvent*) gdk_event;

 
 

-    // Some control don't have their own X window and thus cannot get
-    // any events.
+    wxMouseEvent event( event_type );
+    InitMouseEvent( win, event, gdk_event );

 
 

-    if (!g_captureWindow)
-    {
-        wxNode *node = win->GetChildren().First();
-        while (node)
-        {
-            wxWindow *child = (wxWindow*)node->Data();
+    AdjustEventButtonState(event);

 
 

-            if (child->m_isStaticBox)
-            {
-                // wxStaticBox is transparent in the box itself
-                int x = event.m_x;
-                int y = event.m_y;
-                int xx1 = child->m_x;
-                int yy1 = child->m_y;
-                int xx2 = child->m_x + child->m_width;
-                int yy2 = child->m_x + child->m_height;
-
-                // left
-                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-                // right
-                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-                // top
-                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-                // bottom
-                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
+    // same wxListBox hack as above
+    win->FixUpMouseEvent(widget, event.m_x, event.m_y);

 
 

-            }
-            else
-            {
-                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
-                    (child->m_x <= event.m_x) &&
-                    (child->m_y <= event.m_y) &&
-                    (child->m_x+child->m_width  >= event.m_x) &&
-                    (child->m_y+child->m_height >= event.m_y))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
-            }
-            node = node->Next();
-        }
-    }
+    if ( !g_captureWindow )
+        win = FindWindowForMouseEvent(win, event.m_x, event.m_y);

 
 

+    // reset the event object and id in case win changed.

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

+    event.SetId( win->GetId() );

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
-        return TRUE;
-    }
+    bool ret = win->GTKProcessEvent(event);

 
 

-    return FALSE;
+    g_lastMouseEvent = NULL;
+
+    return ret;

 }
 
 //-----------------------------------------------------------------------------
 // "motion_notify_event"
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "motion_notify_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
+static gboolean
+gtk_window_motion_notify_callback( GtkWidget *widget,
+                                   GdkEventMotion *gdk_event,
+                                   wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-    if (g_blockEventsOnScroll) return FALSE;
-    
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);

 
     if (gdk_event->is_hint)
     {
 
     if (gdk_event->is_hint)
     {


@@ -1256,14 +1686,74 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         gdk_event->y = y;
     }
 
         gdk_event->y = y;
     }
 

-/*
-    printf( "OnMotion from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-      printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    g_lastMouseEvent = (GdkEvent*) gdk_event;

 
     wxMouseEvent event( wxEVT_MOTION );
 
     wxMouseEvent event( wxEVT_MOTION );

+    InitMouseEvent(win, event, gdk_event);
+
+    if ( g_captureWindow )
+    {
+        // synthesise a mouse enter or leave event if needed
+        GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+        // This seems to be necessary and actually been added to
+        // GDK itself in version 2.0.X
+        gdk_flush();
+
+        bool hasMouse = winUnderMouse == gdk_event->window;
+        if ( hasMouse != g_captureWindowHasMouse )
+        {
+            // the mouse changed window
+            g_captureWindowHasMouse = hasMouse;
+
+            wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
+                                                        : wxEVT_LEAVE_WINDOW);
+            InitMouseEvent(win, eventM, gdk_event);
+            eventM.SetEventObject(win);
+            win->GTKProcessEvent(eventM);
+        }
+    }
+    else // no capture
+    {
+        win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+        // reset the event object and id in case win changed.
+        event.SetEventObject( win );
+        event.SetId( win->GetId() );
+    }
+
+    if ( !g_captureWindow )
+    {
+        wxSetCursorEvent cevent( event.m_x, event.m_y );
+        if (win->GTKProcessEvent( cevent ))
+        {
+            win->SetCursor( cevent.GetCursor() );
+        }
+    }
+
+    bool ret = win->GTKProcessEvent(event);
+
+    g_lastMouseEvent = NULL;
+
+    return ret;
+}
+
+//-----------------------------------------------------------------------------
+// "scroll_event", (mouse wheel event)
+//-----------------------------------------------------------------------------
+
+static gboolean
+window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
+{
+    DEBUG_MAIN_THREAD
+
+    if (gdk_event->direction != GDK_SCROLL_UP &&
+        gdk_event->direction != GDK_SCROLL_DOWN)
+    {
+        return false;
+    }
+
+    wxMouseEvent event(wxEVT_MOUSEWHEEL);
+    // Can't use InitMouse macro because scroll events don't have button

     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);


@@ -1272,122 +1762,82 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);

+    event.m_linesPerAction = 3;
+    event.m_wheelDelta = 120;
+    if (gdk_event->direction == GDK_SCROLL_UP)
+        event.m_wheelRotation = 120;
+    else
+        event.m_wheelRotation = -120;

 
 

-    event.m_x = (long)gdk_event->x;
-    event.m_y = (long)gdk_event->y;
-
-    // Some control don't have their own X window and thus cannot get
-    // any events.
-
-    if (!g_captureWindow)
-    {
-        wxNode *node = win->GetChildren().First();
-        while (node)
-        {
-            wxWindow *child = (wxWindow*)node->Data();
-
-            if (child->m_isStaticBox)
-            {
-                // wxStaticBox is transparent in the box itself
-                int x = event.m_x;
-                int y = event.m_y;
-                int xx1 = child->m_x;
-                int yy1 = child->m_y;
-                int xx2 = child->m_x + child->m_width;
-                int yy2 = child->m_x + child->m_height;
-
-                // left
-                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-                // right
-                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-                // top
-                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-                // bottom
-                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
-
-            }
-            else
-            {
-                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
-                    (child->m_x <= event.m_x) &&
-                    (child->m_y <= event.m_y) &&
-                    (child->m_x+child->m_width  >= event.m_x) &&
-                    (child->m_y+child->m_height >= event.m_y))
-                {
-                    win = child;
-                    event.m_x -= child->m_x;
-                    event.m_y -= child->m_y;
-                    break;
-                }
-            }
-            node = node->Next();
-        }
-    }
+    wxPoint pt = win->GetClientAreaOrigin();
+    event.m_x = (wxCoord)gdk_event->x - pt.x;
+    event.m_y = (wxCoord)gdk_event->y - pt.y;

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

+    event.SetId( win->GetId() );
+    event.SetTimestamp( gdk_event->time );

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
-        return TRUE;
-    }
+    return win->GTKProcessEvent(event);
+}

 
 

-    return FALSE;
+//-----------------------------------------------------------------------------
+// "popup-menu"
+//-----------------------------------------------------------------------------
+
+static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
+{
+    wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
+    event.SetEventObject(win);
+    return win->GTKProcessEvent(event);

 }
 
 //-----------------------------------------------------------------------------
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
+static gboolean
+gtk_window_focus_in_callback( GtkWidget *widget,
+                              GdkEventFocus *WXUNUSED(event),
+                              wxWindow *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    DEBUG_MAIN_THREAD

 
 

-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    if (win->m_imData)
+        gtk_im_context_focus_in(win->m_imData->context);

 
 

+    g_focusWindowLast =

     g_focusWindow = win;
 
     g_focusWindow = win;
 

-    if (win->m_wxwindow)
+    wxLogTrace(TRACE_FOCUS,
+               _T("%s: focus in"), win->GetName().c_str());
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = win->GetCaret();
+    if ( caret )

     {
     {

-        if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
-        {
-            GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
-/*
-            printf( "SetFocus flag from " );
-            if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-                printf( win->GetClassInfo()->GetClassName() );
-            printf( ".\n" );
-*/
-        }
+        caret->OnSetFocus();

     }
     }

+#endif // wxUSE_CARET

 
 

+    gboolean ret = FALSE;

 
 

-/*
-    printf( "OnSetFocus from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( "   " );
-    printf( WXSTRINGCAST win->GetLabel() );
-    printf( ".\n" );
-*/
+    // does the window itself think that it has the focus?
+    if ( !win->m_hasFocus )
+    {
+        // not yet, notify it
+        win->m_hasFocus = true;

 
 

-    wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
-    event.SetEventObject( win );
+        (void)DoSendFocusEvents(win);

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
-        return TRUE;
+        ret = TRUE;

     }
 
     }
 

+    // Disable default focus handling for custom windows
+    // since the default GTK+ handler issues a repaint
+    if (win->m_wxwindow)
+        return ret;
+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -1395,36 +1845,76 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
+static gboolean
+gtk_window_focus_out_callback( GtkWidget *widget,
+                               GdkEventFocus *gdk_event,
+                               wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    DEBUG_MAIN_THREAD

 
 

-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    if (win->m_imData)
+        gtk_im_context_focus_out(win->m_imData->context);

 
 

-    if (win->m_wxwindow)
+    wxLogTrace( TRACE_FOCUS,
+                _T("%s: focus out"), win->GetName().c_str() );
+
+
+    wxWindowGTK *winFocus = wxFindFocusedChild(win);
+    if ( winFocus )
+        win = winFocus;
+
+    g_focusWindow = (wxWindowGTK *)NULL;
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = win->GetCaret();
+    if ( caret )

     {
     {

-      if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
-          GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
+        caret->OnKillFocus();

     }
     }

+#endif // wxUSE_CARET

 
 

-/*
-    printf( "OnKillFocus from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    // don't send the window a kill focus event if it thinks that it doesn't
+    // have focus already
+    if ( win->m_hasFocus )
+    {
+        // the event handler might delete the window when it loses focus, so
+        // check whether this is a custom window before calling it
+        const bool has_wxwindow = win->m_wxwindow != NULL;

 
 

-    wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
-    event.SetEventObject( win );
+        win->m_hasFocus = false;

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
-        return TRUE;
+        wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
+        event.SetEventObject( win );
+
+        (void)win->GTKProcessEvent( event );
+
+        // Disable default focus handling for custom windows
+        // since the default GTK+ handler issues a repaint
+        if ( has_wxwindow )
+            return TRUE;

     }
 
     }
 

+    // continue with normal processing
+    return FALSE;
+}
+
+static gboolean
+wx_window_focus_callback(GtkWidget *widget,
+                         GtkDirectionType direction,
+                         wxWindowGTK *win)
+{
+    // the default handler for focus signal in GtkPizza (or, rather, in
+    // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
+    // focus to the window itself even if it doesn't accept focus, i.e. has no
+    // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
+    // the signal from reaching gtk_scrolled_window_focus() if we don't have
+    // any children which might accept focus (we know we don't accept the focus
+    // ourselves as this signal is only connected in this case)
+    if ( win->GetChildren().empty() )
+        g_signal_stop_emission_by_name(widget, "focus");
+
+    // we didn't change the focus

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -1432,21 +1922,15 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
 // "enter_notify_event"
 //-----------------------------------------------------------------------------
 
 // "enter_notify_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
+static gboolean
+gtk_window_enter_callback( GtkWidget *widget,
+                           GdkEventCrossing *gdk_event,
+                           wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);

 
 

-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-
-    wxMouseEvent event( wxEVT_ENTER_WINDOW );
-#if (GTK_MINOR_VERSION > 0)
-    event.SetTimestamp( gdk_event->time );
-#endif
-    event.SetEventObject( win );
+    // Event was emitted after a grab
+    if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;

 
     int x = 0;
     int y = 0;
 
     int x = 0;
     int y = 0;


@@ -1454,44 +1938,40 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     gdk_window_get_pointer( widget->window, &x, &y, &state );
 
 
     gdk_window_get_pointer( widget->window, &x, &y, &state );
 

-    event.m_shiftDown = (state & GDK_SHIFT_MASK);
-    event.m_controlDown = (state & GDK_CONTROL_MASK);
-    event.m_altDown = (state & GDK_MOD1_MASK);
-    event.m_metaDown = (state & GDK_MOD2_MASK);
-    event.m_leftDown = (state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (state & GDK_BUTTON3_MASK);
-
-    event.m_x = (long)x;
-    event.m_y = (long)y;
+    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 (win->GetEventHandler()->ProcessEvent( event ))
+    if ( !g_captureWindow )

     {
     {

-       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
-       return TRUE;
+        wxSetCursorEvent cevent( event.m_x, event.m_y );
+        if (win->GTKProcessEvent( cevent ))
+        {
+            win->SetCursor( cevent.GetCursor() );
+        }

     }
 
     }
 

-    return FALSE;
+    return win->GTKProcessEvent(event);

 }
 
 //-----------------------------------------------------------------------------
 // "leave_notify_event"
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "leave_notify_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
+static gboolean
+gtk_window_leave_callback( GtkWidget *widget,
+                           GdkEventCrossing *gdk_event,
+                           wxWindowGTK *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);

 
 

-    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+    // Event was emitted after an ungrab
+    if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;

 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );

-#if (GTK_MINOR_VERSION > 0)

     event.SetTimestamp( gdk_event->time );
     event.SetTimestamp( gdk_event->time );

-#endif

     event.SetEventObject( win );
 
     int x = 0;
     event.SetEventObject( win );
 
     int x = 0;


@@ -1500,269 +1980,261 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     gdk_window_get_pointer( widget->window, &x, &y, &state );
 
 
     gdk_window_get_pointer( widget->window, &x, &y, &state );
 

-    event.m_shiftDown = (state & GDK_SHIFT_MASK);
-    event.m_controlDown = (state & GDK_CONTROL_MASK);
-    event.m_altDown = (state & GDK_MOD1_MASK);
-    event.m_metaDown = (state & GDK_MOD2_MASK);
-    event.m_leftDown = (state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (state & GDK_BUTTON3_MASK);
+    event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
+    event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
+    event.m_altDown = (state & GDK_MOD1_MASK) != 0;
+    event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
+    event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
+    event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
+    event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;

 
 

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

 
 

-    if (win->GetEventHandler()->ProcessEvent( event ))
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
-        return TRUE;
-    }
-
-    return FALSE;
+    return win->GTKProcessEvent(event);

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

-// "value_changed" from m_vAdjust
+// "value_changed" from scrollbar

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

-static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
+static void
+gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
+    wxEventType eventType = win->GetScrollEventType(range);
+    if (eventType != wxEVT_NULL)
+    {
+        // Convert scroll event type to scrollwin event type
+        eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;

 
 

-    if (!win->m_hasVMT) return;
-    
-    float diff = adjust->value - win->m_oldVerticalPos;
-    if (fabs(diff) < 0.2) return;
-    
-    win->m_oldVerticalPos = adjust->value;
+        // find the scrollbar which generated the event
+        wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);

 
 

-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-    GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar );
-    
-    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
-    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
-    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
-    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
-    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
-    
-    int value = (int)(adjust->value+0.5);
+        // generate the corresponding wx event
+        const int orient = wxWindow::OrientFromScrollDir(dir);
+        wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
+        event.SetEventObject(win);

 
 

-    wxScrollWinEvent event( command, value, wxVERTICAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+        win->m_blockValueChanged[dir] = true;
+        win->GTKProcessEvent(event);
+        win->m_blockValueChanged[dir] = false;
+    }

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

-// "value_changed" from m_hAdjust
+// "button_press_event" from scrollbar

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

-static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
+static gboolean
+gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
-    if (!win->m_hasVMT) return;
+    DEBUG_MAIN_THREAD

 
 

-    float diff = adjust->value - win->m_oldHorizontalPos;
-    if (fabs(diff) < 0.2) return;
-    
-    win->m_oldHorizontalPos = adjust->value;
+    g_blockEventsOnScroll = true;
+    win->m_mouseButtonDown = true;

 
 

-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-    GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
-    
-    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
-    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
-    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
-    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
-    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
-    
-    int value = (int)(adjust->value+0.5);
-
-    wxScrollWinEvent event( command, value, wxHORIZONTAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    return false;

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

-// "changed" from m_vAdjust
+// "event_after" from scrollbar

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

-static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void
+gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
-    if (!win->m_hasVMT) return;
-
-    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
-    int value = (int)(win->m_vAdjust->value+0.5);
+    if (event->type == GDK_BUTTON_RELEASE)
+    {
+        g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);

 
 

-    wxScrollWinEvent event( command, value, wxVERTICAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+        const int orient = wxWindow::OrientFromScrollDir(
+                                        win->ScrollDirFromRange(range));
+        wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient);
+        event.SetEventObject(win);
+        win->GTKProcessEvent(event);
+    }

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

-// "changed" from m_hAdjust
+// "button_release_event" from scrollbar

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

-static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static gboolean
+gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (g_blockEventsOnDrag) return;
-    if (!win->m_hasVMT) return;
+    DEBUG_MAIN_THREAD

 
 

-    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
-    int value = (int)(win->m_hAdjust->value+0.5);
+    g_blockEventsOnScroll = false;
+    win->m_mouseButtonDown = false;
+    // If thumb tracking
+    if (win->m_isScrolling)
+    {
+        win->m_isScrolling = false;
+        // Hook up handler to send thumb release event after this emission is finished.
+        // To allow setting scroll position from event handler, sending event must
+        // be deferred until after the GtkRange handler for this signal has run
+        g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
+    }

 
 

-    wxScrollWinEvent event( command, value, wxHORIZONTAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    return false;

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

-// "button_press_event" from scrollbar
+// "realize" from m_widget

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

-static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
-                                                 GdkEventButton *WXUNUSED(gdk_event),
-                                                 wxWindow *win )
+static void
+gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )

 {
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    DEBUG_MAIN_THREAD

 
 

-//  don't test here as we can release the mouse while being over
-//  a different window than the slider
-//
-//    if (gdk_event->window != widget->slider) return FALSE;
+    if (win->m_imData)
+    {
+        GtkPizza *pizza = GTK_PIZZA( m_widget );
+        gtk_im_context_set_client_window( win->m_imData->context,
+                                          pizza->bin_window );
+    }

 
 

-    win->SetScrolling( TRUE );
+    // We cannot set colours and fonts before the widget
+    // been realized, so we do this directly after realization
+    // or otherwise in idle time

 
 

-    return FALSE;
+    if (win->m_needsStyleChange)
+    {
+        win->SetBackgroundStyle(win->GetBackgroundStyle());
+        win->m_needsStyleChange = false;
+    }
+
+    wxWindowCreateEvent event( win );
+    event.SetEventObject( win );
+    win->GTKProcessEvent( event );

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

-// "button_release_event" from scrollbar
+// "size_allocate"

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

-static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
-                                                   GdkEventButton *WXUNUSED(gdk_event),
-                                                   wxWindow *win )
+static
+void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
+                               GtkAllocation *alloc,
+                               wxWindow *win )

 {
 {

+    int client_width = 0;
+    int client_height = 0;
+    win->GetClientSize( &client_width, &client_height );
+    if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
+        return;

 
 

-//  don't test here as we can release the mouse while being over
-//  a different window than the slider
-//
-//    if (gdk_event->window != widget->slider) return FALSE;
+    if ( !client_width && !client_height )
+    {
+        // the window is currently unmapped, don't generate size events
+        return;
+    }

 
 

-    win->SetScrolling( FALSE );
+    win->m_oldClientWidth = client_width;
+    win->m_oldClientHeight = client_height;

 
 

-    return FALSE;
+    if (!win->m_nativeSizeEvent)
+    {
+        wxSizeEvent event( win->GetSize(), win->GetId() );
+        event.SetEventObject( win );
+        win->GTKProcessEvent( event );
+    }

 }
 
 }
 

+} // extern "C"
+

 // ----------------------------------------------------------------------------
 // this wxWindowBase function is implemented here (in platform-specific file)
 // because it is static and so couldn't be made virtual
 // ----------------------------------------------------------------------------
 // this wxWindowBase function is implemented here (in platform-specific file)
 // because it is static and so couldn't be made virtual

-// ----------------------------------------------------------------------------
-
-wxWindow *wxWindowBase::FindFocus()
-{
-    return g_focusWindow;
-}
-
-//-----------------------------------------------------------------------------
-// "realize" from m_widget
-//-----------------------------------------------------------------------------
-
-/* we cannot set colours and fonts before the widget has
-   been realized, so we do this directly after realization */
-
-static gint
-gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
-{
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (win->m_delayedFont)
-        win->SetFont( win->GetFont() );
-
-    if (win->m_delayedBackgroundColour)
-        win->SetBackgroundColour( win->GetBackgroundColour() );
-
-    if (win->m_delayedForegroundColour)
-        win->SetForegroundColour( win->GetForegroundColour() );
-
-    wxWindowCreateEvent event( win );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+// ----------------------------------------------------------------------------

 
 

-    return FALSE;
+wxWindow *wxWindowBase::DoFindFocus()
+{
+    // the cast is necessary when we compile in wxUniversal mode
+    return (wxWindow *)g_focusWindow;

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

-// InsertChild for wxWindow.
+// InsertChild for wxWindowGTK.

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

-/* Callback for wxWindow. This very strange beast has to be used because
+/* Callback for wxWindowGTK. This very strange beast has to be used because

  * C++ has no virtual methods in a constructor. We have to emulate a
  * virtual function here as wxNotebook requires a different way to insert
  * a child in it. I had opted for creating a wxNotebookPage window class
  * which would have made this superfluous (such in the MDI window system),
  * but no-one was listening to me... */
 
  * C++ has no virtual methods in a constructor. We have to emulate a
  * virtual function here as wxNotebook requires a different way to insert
  * a child in it. I had opted for creating a wxNotebookPage window class
  * which would have made this superfluous (such in the MDI window system),
  * but no-one was listening to me... */
 

-static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
+static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )

 {
     /* the window might have been scrolled already, do we
        have to adapt the position */
 {
     /* the window might have been scrolled already, do we
        have to adapt the position */

-    GtkMyFixed *myfixed = GTK_MYFIXED(parent->m_wxwindow);
-    child->m_x += myfixed->xoffset;
-    child->m_y += myfixed->yoffset;
-    
-    gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
-                     GTK_WIDGET(child->m_widget),
+    GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
+    child->m_x += gtk_pizza_get_xoffset( pizza );
+    child->m_y += gtk_pizza_get_yoffset( pizza );
+
+    gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
+                     child->m_widget,

                      child->m_x,
                      child->m_y,
                      child->m_width,
                      child->m_height );
                      child->m_x,
                      child->m_y,
                      child->m_width,
                      child->m_height );

-
-    if (parent->HasFlag(wxTAB_TRAVERSAL))
-    {
-        /* we now allow a window to get the focus as long as it
-           doesn't have any children. */
-        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
-    }

 }
 
 //-----------------------------------------------------------------------------
 // global functions
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // global functions
 //-----------------------------------------------------------------------------
 

-wxWindow* wxGetActiveWindow()
+wxWindow *wxGetActiveWindow()
+{
+    return wxWindow::FindFocus();
+}
+
+
+wxMouseState wxGetMouseState()

 {
 {

-    return g_focusWindow;
+    wxMouseState ms;
+
+    gint x;
+    gint y;
+    GdkModifierType mask;
+
+    gdk_window_get_pointer(NULL, &x, &y, &mask);
+
+    ms.SetX(x);
+    ms.SetY(y);
+    ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
+    ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
+    ms.SetRightDown(mask & GDK_BUTTON3_MASK);
+
+    ms.SetControlDown(mask & GDK_CONTROL_MASK);
+    ms.SetShiftDown(mask & GDK_SHIFT_MASK);
+    ms.SetAltDown(mask & GDK_MOD1_MASK);
+    ms.SetMetaDown(mask & GDK_MOD2_MASK);
+
+    return ms;

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

-// wxWindow
+// wxWindowGTK

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

-IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
+// method
+#ifdef __WXUNIVERSAL__
+    IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
+#else // __WXGTK__
+    IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+#endif // __WXUNIVERSAL__/__WXGTK__

 
 

-void wxWindow::Init()
+void wxWindowGTK::Init()

 {
 {

-    // common init
-    InitBase();
-

     // GTK specific
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
     // GTK specific
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;

+    m_focusWidget = (GtkWidget *) NULL;

 
     // position/size
     m_x = 0;
 
     // position/size
     m_x = 0;


@@ -1770,224 +2242,216 @@ void wxWindow::Init()
     m_width = 0;
     m_height = 0;
 
     m_width = 0;
     m_height = 0;
 

-    m_sizeSet = FALSE;
-    m_hasVMT = FALSE;
-    m_needParent = TRUE;
-    m_isBeingDeleted = FALSE;
-    
-    m_noExpose = FALSE;
+    m_sizeSet = false;
+    m_hasVMT = false;
+    m_isBeingDeleted = false;
+
+    m_showOnIdle= false;
+
+    m_noExpose = false;
+    m_nativeSizeEvent = false;
+
+    m_hasScrolling = false;
+    m_isScrolling = false;
+    m_mouseButtonDown = false;
+    m_blockScrollEvent = false;

 
 

-    m_hasScrolling = FALSE;
-    m_isScrolling = FALSE;
+    // initialize scrolling stuff
+    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+    {
+        m_scrollBar[dir] = NULL;
+        m_scrollPos[dir] = 0;
+        m_blockValueChanged[dir] = false;
+    }

 
 

-    m_hAdjust = (GtkAdjustment*) NULL;
-    m_vAdjust = (GtkAdjustment*) NULL;
-    m_oldHorizontalPos = 0.0;
-    m_oldVerticalPos = 0.0;
+    m_oldClientWidth =
+    m_oldClientHeight = 0;

 
 

-    m_resizing = FALSE;
-    m_widgetStyle = (GtkStyle*) NULL;
+    m_resizing = false;

 
     m_insertCallback = (wxInsertChildFunction) NULL;
 
 
     m_insertCallback = (wxInsertChildFunction) NULL;
 

-    m_isStaticBox = FALSE;
-    m_isRadioButton = FALSE;
-    m_isFrame = FALSE;
-    m_acceptsFocus = FALSE;
-    
+    m_hasFocus = false;
+
+    m_clipPaintRegion = false;
+
+    m_needsStyleChange = false;
+

     m_cursor = *wxSTANDARD_CURSOR;
     m_cursor = *wxSTANDARD_CURSOR;

+
+    m_imData = NULL;
+    m_dirtyTabOrder = false;

 }
 
 }
 

-wxWindow::wxWindow()
+wxWindowGTK::wxWindowGTK()

 {
     Init();
 }
 
 {
     Init();
 }
 

-wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
-                    const wxPoint &pos, const wxSize &size,
-                    long style, const wxString &name  )
+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 );
 }
 
 {
     Init();
 
     Create( parent, id, pos, size, style, name );
 }
 

-bool wxWindow::Create( wxWindow *parent, wxWindowID id,
-                       const wxPoint &pos, const wxSize &size,
-                       long style, const wxString &name  )
+bool wxWindowGTK::Create( wxWindow *parent,
+                          wxWindowID id,
+                          const wxPoint &pos,
+                          const wxSize &size,
+                          long style,
+                          const wxString &name  )

 {
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {
 {
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {

-        wxFAIL_MSG( wxT("wxWindow creation failed") );
-       return FALSE;
+        wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
+        return false;

     }
 
     m_insertCallback = wxInsertChildInWindow;
 
     }
 
     m_insertCallback = wxInsertChildInWindow;
 

-    m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
-    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-
-#ifdef __WXDEBUG__
-    debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );
-#endif
-
-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
-
-#ifdef __WXDEBUG__
-    debug_focus_in( scrolledWindow->hscrollbar, wxT("wxWindow::hsrcollbar"), name );
-    debug_focus_in( scrolledWindow->vscrollbar, wxT("wxWindow::vsrcollbar"), name );
-#endif
-
-    GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-    scroll_class->scrollbar_spacing = 0;
-
-    gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-
-    m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
-    m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
-
-    m_wxwindow = gtk_myfixed_new();
-
-#ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
-#endif
-
-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
-
-#if (GTK_MINOR_VERSION > 0)
-    GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);

 
 

-    if (HasFlag(wxRAISED_BORDER))
-    {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_OUT );
-    }
-    else if (HasFlag(wxSUNKEN_BORDER))
-    {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_IN );
-    }
-    else if (HasFlag(wxSIMPLE_BORDER))
-    {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_THIN );
-    }
-    else
+    if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))

     {
     {

-        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_NONE );
-    }
-#else // GTK_MINOR_VERSION == 0
-    GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
+        m_wxwindow = gtk_pizza_new_no_scroll();

 
 

-    if (HasFlag(wxRAISED_BORDER))
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
-    }
-    else if (HasFlag(wxSUNKEN_BORDER))
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
-    }
-    else
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
-    }
-#endif // GTK_MINOR_VERSION
+#ifndef __WXUNIVERSAL__
+        if (HasFlag(wxSIMPLE_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+        else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+#endif // __WXUNIVERSAL__

 
 

-    if (HasFlag(wxTAB_TRAVERSAL))
-    {
-        /* we now allow a window to get the focus as long as it
-           doesn't have any children. */
-        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-        m_acceptsFocus = FALSE;
+        m_widget = m_wxwindow;

     }
     else
     {
     }
     else
     {

-        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-        m_acceptsFocus = TRUE;
-    }
+        m_wxwindow = gtk_pizza_new();

 
 

-#if (GTK_MINOR_VERSION == 0)
-    // shut the viewport up
-    gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-    gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-#endif // GTK_MINOR_VERSION == 0
+#ifndef __WXUNIVERSAL__
+        if (HasFlag(wxSIMPLE_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+        else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+#endif // __WXUNIVERSAL__

 
 

-    // I _really_ don't want scrollbars in the beginning
-    m_vAdjust->lower = 0.0;
-    m_vAdjust->upper = 1.0;
-    m_vAdjust->value = 0.0;
-    m_vAdjust->step_increment = 1.0;
-    m_vAdjust->page_increment = 1.0;
-    m_vAdjust->page_size = 5.0;
-    gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
-    m_hAdjust->lower = 0.0;
-    m_hAdjust->upper = 1.0;
-    m_hAdjust->value = 0.0;
-    m_hAdjust->step_increment = 1.0;
-    m_hAdjust->page_increment = 1.0;
-    m_hAdjust->page_size = 5.0;
-    gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+        m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );

 
 

-    // these handlers block mouse events to any window during scrolling such as
-    // motion events and prevent GTK and wxWindows from fighting over where the
-    // slider should be
+        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);

 
 

-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
-          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
+        scroll_class->scrollbar_spacing = 0;

 
 

-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
-          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
+        // There is a conflict with default bindings at GTK+
+        // level between scrolled windows and notebooks both of which want to use
+        // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
+        // direction and notebooks for changing pages -- we decide that if we don't
+        // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
+        // means we can get working keyboard navigation in notebooks
+        if ( !HasFlag(wxHSCROLL) )
+        {
+            GtkBindingSet *
+                bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
+            if ( bindings )
+            {
+                gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
+                gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
+            }
+        }

 
 

-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
-          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+        if (HasFlag(wxALWAYS_SHOW_SB))
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );

 
 

-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
-          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+            scrolledWindow->hscrollbar_visible = TRUE;
+            scrolledWindow->vscrollbar_visible = TRUE;
+        }
+        else
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        }

 
 

-    // these handlers get notified when screen updates are required either when
-    // scrolling or when the window size (and therefore scrollbar configuration)
-    // has changed
+        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
+        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );

 
 

-    gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
-          (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
-    gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
-          (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
+        gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );

 
 

-    gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
-          (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
-    gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
-          (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
+        // 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(m_scrollBar[dir], "value_changed",
+                         G_CALLBACK(gtk_scrollbar_value_changed), this);
+        }

 
 

-    gtk_widget_show( m_wxwindow );
+        gtk_widget_show( m_wxwindow );
+    }

 
     if (m_parent)
         m_parent->DoAddChild( this );
 
 
     if (m_parent)
         m_parent->DoAddChild( this );
 

-    PostCreation();
+    m_focusWidget = m_wxwindow;

 
 

-    Show( TRUE );
+    PostCreation();

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-wxWindow::~wxWindow()
+wxWindowGTK::~wxWindowGTK()

 {
 {

-    m_isBeingDeleted = TRUE;
-    m_hasVMT = FALSE;
+    SendDestroyEvent();

 
 

-    if (m_widget)
-        Show( FALSE );
+    if (g_focusWindow == this)
+        g_focusWindow = NULL;

 
 

-    DestroyChildren();
+    if ( g_delayedFocus == this )
+        g_delayedFocus = NULL;

 
 

-    if (m_parent)
-        m_parent->RemoveChild( this );
+    m_isBeingDeleted = true;
+    m_hasVMT = false;
+
+    // destroy children before destroying this window itself
+    DestroyChildren();

 
 

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

     {
     {

-        gtk_style_unref( m_widgetStyle );
-        m_widgetStyle = (GtkStyle*) NULL;
+        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);

     }
 
     }
 

-    if (m_wxwindow)
+    if (m_widget)
+        Show( false );
+
+    // delete before the widgets to avoid a crash on solaris
+    delete m_imData;
+
+    if (m_wxwindow && (m_wxwindow != m_widget))

     {
         gtk_widget_destroy( m_wxwindow );
         m_wxwindow = (GtkWidget*) NULL;
     {
         gtk_widget_destroy( m_wxwindow );
         m_wxwindow = (GtkWidget*) NULL;


@@ -2000,126 +2464,245 @@ wxWindow::~wxWindow()
     }
 }
 
     }
 }
 

-bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize &size )
+bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )

 {
 {

-    wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
+    if ( GTKNeedsParent() )
+    {
+        wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
+    }

 
 

-    /* this turns -1 into 20 so that a minimal window is
-       visible even although -1,-1 has been given as the
-       size of the window. the same trick is used in other
-       ports and should make debugging easier */
-    m_width = WidthDefault(size.x);
+    // Use either the given size, or the default if -1 is given.
+    // See wxWindowBase for these functions.
+    m_width = WidthDefault(size.x) ;

     m_height = HeightDefault(size.y);
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
     m_height = HeightDefault(size.y);
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 

-    /* some reasonable defaults */
-    if (!parent)  
-    {
-        if (m_x == -1)
-        {
-            m_x = (gdk_screen_width () - m_width) / 2;
-            if (m_x < 10) m_x = 10;
-        }
-        if (m_y == -1)
-        {
-            m_y = (gdk_screen_height () - m_height) / 2;
-            if (m_y < 10) m_y = 10;
-        }
-    }
-    
-    return TRUE;
+    return true;

 }
 
 }
 

-void wxWindow::PostCreation()
+void wxWindowGTK::PostCreation()

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     if (m_wxwindow)
     {
         if (!m_noExpose)
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     if (m_wxwindow)
     {
         if (!m_noExpose)

-       {
-            /* these get reported to wxWindows -> wxPaintEvent */
-            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
-
-            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
-                GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
-       }
-         
-#if (GTK_MINOR_VERSION > 0)
-        /* these are called when the "sunken" or "raised" borders are drawn */
-        gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
-          GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
-
-        gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
-          GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
-#endif
+        {
+            // these get reported to wxWidgets -> wxPaintEvent
+
+            g_signal_connect (m_wxwindow, "expose_event",
+                              G_CALLBACK (gtk_window_expose_callback), this);
+
+            if (GetLayoutDirection() == wxLayout_LeftToRight)
+                gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
+        }
+
+        // Create input method handler
+        m_imData = new wxGtkIMData;
+
+        // Cannot handle drawing preedited text yet
+        gtk_im_context_set_use_preedit( m_imData->context, FALSE );
+
+        g_signal_connect (m_imData->context, "commit",
+                          G_CALLBACK (gtk_wxwindow_commit_cb), this);
+
+        // these are called when the "sunken" or "raised" borders are drawn
+        g_signal_connect (m_widget, "expose_event",
+                          G_CALLBACK (gtk_window_own_expose_callback), this);
+    }
+
+    // focus handling
+
+    if (!GTK_IS_WINDOW(m_widget))
+    {
+        if (m_focusWidget == NULL)
+            m_focusWidget = m_widget;
+
+        if (m_wxwindow)
+        {
+            g_signal_connect (m_focusWidget, "focus_in_event",
+                          G_CALLBACK (gtk_window_focus_in_callback), this);
+            g_signal_connect (m_focusWidget, "focus_out_event",
+                                G_CALLBACK (gtk_window_focus_out_callback), this);
+        }
+        else
+        {
+            g_signal_connect_after (m_focusWidget, "focus_in_event",
+                          G_CALLBACK (gtk_window_focus_in_callback), this);
+            g_signal_connect_after (m_focusWidget, "focus_out_event",
+                                G_CALLBACK (gtk_window_focus_out_callback), this);
+        }

     }
 
     }
 

+    if ( !AcceptsFocusFromKeyboard() )
+    {
+        SetCanFocus(false);
+
+        g_signal_connect(m_widget, "focus",
+                            G_CALLBACK(wx_window_focus_callback), this);
+    }
+
+    // connect to the various key and mouse handlers
+

     GtkWidget *connect_widget = GetConnectWidget();
 
     ConnectWidget( connect_widget );
 
     GtkWidget *connect_widget = GetConnectWidget();
 
     ConnectWidget( connect_widget );
 

-   /*  we cannot set colours, fonts and cursors before the widget has
+    /* We cannot set colours, fonts and cursors before the widget has

        been realized, so we do this directly after realization */
        been realized, so we do this directly after realization */

-    gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
-                            GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
-
-    m_hasVMT = TRUE;
-}
-
-void wxWindow::ConnectWidget( GtkWidget *widget )
-{
-    gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
-      GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
+    g_signal_connect (connect_widget, "realize",
+                      G_CALLBACK (gtk_window_realized_callback), this);

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
-      GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
+    if (m_wxwindow)
+    {
+        // Catch native resize events
+        g_signal_connect (m_wxwindow, "size_allocate",
+                          G_CALLBACK (gtk_window_size_callback), this);
+    }

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
+    if (GTK_IS_COMBO(m_widget))
+    {
+        GtkCombo *gcombo = GTK_COMBO(m_widget);

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
+        g_signal_connect (gcombo->entry, "size_request",
+                          G_CALLBACK (wxgtk_combo_size_request_callback),
+                          this);
+    }
+#ifdef GTK_IS_FILE_CHOOSER_BUTTON
+    else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
+    {
+        // If we connect to the "size_request" signal of a GtkFileChooserButton
+        // then that control won't be sized properly when placed inside sizers
+        // (this can be tested removing this elseif and running XRC or WIDGETS samples)
+        // FIXME: what should be done here ?
+    }
+#endif
+    else if ( !IsTopLevel() ) // top level windows use their own callback
+    {
+        // This is needed if we want to add our windows into native
+        // GTK controls, such as the toolbar. With this callback, the
+        // toolbar gets to know the correct size (the one set by the
+        // programmer). Sadly, it misbehaves for wxComboBox.
+        g_signal_connect (m_widget, "size_request",
+                          G_CALLBACK (wxgtk_window_size_request_callback),
+                          this);
+    }

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
+    InheritAttributes();

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
-      GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
+    m_hasVMT = true;

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
-      GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
+    SetLayoutDirection(wxLayout_Default);

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
+    // unless the window was created initially hidden (i.e. Hide() had been
+    // called before Create()), we should show it at GTK+ level as well
+    if ( IsShown() )
+        gtk_widget_show( m_widget );
+}

 
 

-    gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
+void wxWindowGTK::ConnectWidget( GtkWidget *widget )
+{
+    g_signal_connect (widget, "key_press_event",
+                      G_CALLBACK (gtk_window_key_press_callback), this);
+    g_signal_connect (widget, "key_release_event",
+                      G_CALLBACK (gtk_window_key_release_callback), this);
+    g_signal_connect (widget, "button_press_event",
+                      G_CALLBACK (gtk_window_button_press_callback), this);
+    g_signal_connect (widget, "button_release_event",
+                      G_CALLBACK (gtk_window_button_release_callback), this);
+    g_signal_connect (widget, "motion_notify_event",
+                      G_CALLBACK (gtk_window_motion_notify_callback), this);
+    g_signal_connect (widget, "scroll_event",
+                      G_CALLBACK (window_scroll_event), this);
+    g_signal_connect (widget, "popup_menu",
+                     G_CALLBACK (wxgtk_window_popup_menu_callback), this);
+    g_signal_connect (widget, "enter_notify_event",
+                      G_CALLBACK (gtk_window_enter_callback), this);
+    g_signal_connect (widget, "leave_notify_event",
+                      G_CALLBACK (gtk_window_leave_callback), this);

 }
 
 }
 

-bool wxWindow::Destroy()
+bool wxWindowGTK::Destroy()

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 

-    m_hasVMT = FALSE;
+    m_hasVMT = false;

 
     return wxWindowBase::Destroy();
 }
 
 
     return wxWindowBase::Destroy();
 }
 

-void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
+{
+    // inform the parent to perform the move
+    gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
+
+}
+
+void wxWindowGTK::ConstrainSize()
+{
+#ifdef __WXGPE__
+    // GPE's window manager doesn't like size hints at all, esp. when the user
+    // has to use the virtual keyboard, so don't constrain size there
+    if (!IsTopLevel())
+#endif
+    {
+        const wxSize minSize = GetMinSize();
+        const wxSize maxSize = GetMaxSize();
+        if (minSize.x > 0 && m_width  < minSize.x) m_width  = minSize.x;
+        if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
+        if (maxSize.x > 0 && m_width  > maxSize.x) m_width  = maxSize.x;
+        if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
+    }
+}
+
+void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );

-    wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") );
+    wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );

 
     if (m_resizing) return; /* I don't like recursions */
 
     if (m_resizing) return; /* I don't like recursions */

-    m_resizing = TRUE;
+    m_resizing = true;
+
+    int currentX, currentY;
+    GetPosition(&currentX, &currentY);
+    if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+        x = currentX;
+    if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+        y = currentY;
+    AdjustForParentClientOrigin(x, y, sizeFlags);
+
+    // calculate the best size if we should auto size the window
+    if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
+         ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
+    {
+        const wxSize sizeBest = GetBestSize();
+        if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
+            width = sizeBest.x;
+        if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
+            height = sizeBest.y;
+    }
+
+    if (width != -1)
+        m_width = width;
+    if (height != -1)
+        m_height = height;
+
+    ConstrainSize();

 
 

-    if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
+#if wxUSE_TOOLBAR_NATIVE
+    if (wxDynamicCast(GetParent(), wxToolBar))
+    {
+       // don't take the x,y values, they're wrong because toolbar sets them
+       GtkWidget  *widget = m_widget;
+       gtk_widget_set_size_request (widget, m_width, m_height);
+    }
+    else
+#endif
+    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook

     {
     {

-        /* don't set the size for children of wxNotebook, just take the values. */
+        // don't set the size for children of wxNotebook, just take the values.

         m_x = x;
         m_y = y;
         m_width = width;
         m_x = x;
         m_y = y;
         m_width = width;


@@ -2127,56 +2710,55 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     }
     else
     {
     }
     else
     {

-        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
-       
+        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);

         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {

-            if (x != -1) m_x = x + myfixed->xoffset;
-            if (y != -1) m_y = y + myfixed->yoffset;
-            if (width != -1) m_width = width;
-            if (height != -1) m_height = height;
+            if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
+            if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );

         }
         else
         {
         }
         else
         {

-            m_x = x + myfixed->xoffset;
-            m_y = y + myfixed->yoffset;
-            m_width = width;
-            m_height = height;
-        }
-
-        if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
-        {
-             if (width == -1) m_width = 80;
-        }
-
-        if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
-        {
-             if (height == -1) m_height = 26;
+            m_x = x + gtk_pizza_get_xoffset( pizza );
+            m_y = y + gtk_pizza_get_yoffset( pizza );

         }
 
         }
 

-        if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
-        if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
-        if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
-        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
-
-        int border = 0;
+        int left_border = 0;
+        int right_border = 0;
+        int top_border = 0;

         int bottom_border = 0;
 
         int bottom_border = 0;
 

+        /* the default button has a border around it */

         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
         {
         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
         {

-            /* the default button has a border around it */
-            border = 6;
-            bottom_border = 5;
+            GtkBorder *default_border = NULL;
+            gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
+            if (default_border)
+            {
+                left_border += default_border->left;
+                right_border += default_border->right;
+                top_border += default_border->top;
+                bottom_border += default_border->bottom;
+                g_free( default_border );
+            }

         }
 
         }
 

-        gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
-                              m_widget,
-                              m_x-border,
-                              m_y-border,
-                              m_width+2*border,
-                              m_height+border+bottom_border );
+        DoMoveWindow( m_x-top_border,
+                      m_y-left_border,
+                      m_width+left_border+right_border,
+                      m_height+top_border+bottom_border );
+    }
+
+    if (m_hasScrolling)
+    {
+        /* Sometimes the client area changes size without the
+           whole windows's size changing, but if the whole
+           windows's size doesn't change, no wxSizeEvent will
+           normally be sent. Here we add an extra test if
+           the client test has been changed and this will
+           be used then. */
+        GetClientSize( &m_oldClientWidth, &m_oldClientHeight );

     }
     }

-    
+

 /*
     wxPrintf( "OnSize sent from " );
     if (GetClassInfo() && GetClassInfo()->GetClassName())
 /*
     wxPrintf( "OnSize sent from " );
     if (GetClassInfo() && GetClassInfo()->GetClassName())


@@ -2184,28 +2766,69 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
 */
 
     wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
 */
 

-    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-    event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( event );
+    if (!m_nativeSizeEvent)
+    {
+        wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+        event.SetEventObject( this );
+        GetEventHandler()->ProcessEvent( event );
+    }
+
+    m_resizing = false;
+}
+
+bool wxWindowGTK::GtkShowFromOnIdle()
+{
+    if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
+    {
+        GtkAllocation alloc;
+        alloc.x = m_x;
+        alloc.y = m_y;
+        alloc.width = m_width;
+        alloc.height = m_height;
+        gtk_widget_size_allocate( m_widget, &alloc );
+        gtk_widget_show( m_widget );
+        wxShowEvent eventShow(GetId(), true);
+        eventShow.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(eventShow);
+        m_showOnIdle = false;
+        return true;
+    }

 
 

-    m_resizing = FALSE;
+    return false;

 }
 
 }
 

-void wxWindow::OnInternalIdle()
+void wxWindowGTK::OnInternalIdle()

 {
 {

+    // Check if we have to show window now
+    if (GtkShowFromOnIdle()) return;
+
+    if ( m_dirtyTabOrder )
+    {
+        m_dirtyTabOrder = false;
+        RealizeTabOrder();
+    }
+
+    // Update style if the window was not yet realized
+    // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
+    if (m_needsStyleChange)
+    {
+        SetBackgroundStyle(GetBackgroundStyle());
+        m_needsStyleChange = false;
+    }
+

     wxCursor cursor = m_cursor;
     if (g_globalCursor.Ok()) cursor = g_globalCursor;
 
     if (cursor.Ok())
     {
     wxCursor cursor = m_cursor;
     if (g_globalCursor.Ok()) cursor = g_globalCursor;
 
     if (cursor.Ok())
     {

-        /* I now set the cursor the anew in every OnInternalIdle call
-          as setting the cursor in a parent window also effects the
-          windows above so that checking for the current cursor is
-          not possible. */
-       
-        if (m_wxwindow)
+        /* I now set the cursor anew in every OnInternalIdle call
+           as setting the cursor in a parent window also effects the
+           windows above so that checking for the current cursor is
+           not possible. */
+
+        if (m_wxwindow && (m_wxwindow != m_widget))

         {
         {

-            GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;
+            GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;

             if (window)
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 
             if (window)
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 


@@ -2217,20 +2840,19 @@ void wxWindow::OnInternalIdle()
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 
         }
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 
         }

-        else
+        else if ( m_widget )

         {
         {

-

             GdkWindow *window = m_widget->window;
             GdkWindow *window = m_widget->window;

-            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+            if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )

                gdk_window_set_cursor( window, cursor.GetCursor() );
                gdk_window_set_cursor( window, cursor.GetCursor() );

-

         }
     }
 
         }
     }
 

-    UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 }
 

-void wxWindow::DoGetSize( int *width, int *height ) const
+void wxWindowGTK::DoGetSize( int *width, int *height ) const

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 


@@ -2238,156 +2860,63 @@ void wxWindow::DoGetSize( int *width, int *height ) const
     if (height) (*height) = m_height;
 }
 
     if (height) (*height) = m_height;
 }
 

-void wxWindow::DoSetClientSize( int width, int height )
+void wxWindowGTK::DoSetClientSize( int width, int height )

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 

-    if (!m_wxwindow)
-    {
-        SetSize( width, height );
-    }
-    else
+    if (m_wxwindow)

     {
         int dw = 0;
         int dh = 0;
 
     {
         int dw = 0;
         int dh = 0;
 

-#if (GTK_MINOR_VERSION == 0)
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            if (HasScrolling())
-            {
-                GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-#if 0 // unused - if this is ok, just remove this line (VZ)
-                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#endif // 0
-
-                GtkWidget *viewport = scroll_window->viewport;
-                GtkStyleClass *viewport_class = viewport->style->klass;
-
-                dw += 2 * viewport_class->xthickness;
-                dh += 2 * viewport_class->ythickness;
-            }
-        }
-#else
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            /* when using GTK 1.2 we set the shadow border size to 2 */
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
+        if (m_hasScrolling)

         {
         {

-            /* when using GTK 1.2 we set the simple border size to 1 */
-            dw += 1 * 2;
-            dh += 1 * 2;
+            GetScrollbarWidth(m_widget, dw, dh);

         }
         }

-#endif
-
-        if (HasScrolling())
-        {
-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;

 
 

-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
-
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-
-            if (scroll_window->vscrollbar_visible)
-            {
-                dw += 15;   /* dw += vscrollbar->allocation.width; */
-                dw += scroll_class->scrollbar_spacing;
-            }
-
-            if (scroll_window->hscrollbar_visible)
-            {
-                dh += 15;   /* dh += hscrollbar->allocation.height; */
-                dh += scroll_class->scrollbar_spacing;
-            }
-       }
+        const int border = GTK_CONTAINER(m_wxwindow)->border_width;
+        dw += 2 * border;
+        dh += 2 * border;

 
 

-       SetSize( width+dw, height+dh );
+        width += dw;
+        height += dh;

     }
     }

+
+    SetSize(width, height);

 }
 
 }
 

-void wxWindow::DoGetClientSize( int *width, int *height ) const
+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_wxwindow)
-    {
-        if (width) (*width) = m_width;
-        if (height) (*height) = m_height;
-    }
-    else
+    int w = m_width;
+    int h = m_height;
+
+    if (m_wxwindow)

     {
         int dw = 0;
         int dh = 0;
 
     {
         int dw = 0;
         int dh = 0;
 

-#if (GTK_MINOR_VERSION == 0)
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            if (HasScrolling())
-            {
-                GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-#if 0 // unused - if this is ok, just remove this line (VZ)
-                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#endif // 0
-
-                GtkWidget *viewport = scroll_window->viewport;
-                GtkStyleClass *viewport_class = viewport->style->klass;
-
-                dw += 2 * viewport_class->xthickness;
-                dh += 2 * viewport_class->ythickness;
-            }
-        }
-#else
-        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        {
-            /* when using GTK 1.2 we set the shadow border size to 2 */
-            dw += 2 * 2;
-            dh += 2 * 2;
-        }
-        if (HasFlag(wxSIMPLE_BORDER))
-        {
-            /* when using GTK 1.2 we set the simple border size to 1 */
-            dw += 1 * 2;
-            dh += 1 * 2;
-        }
-#endif
-        if (HasScrolling())
-        {
-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
-
-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
-
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-
-            if (scroll_window->vscrollbar_visible)
-            {
-                dw += 15;   /* dw += vscrollbar->allocation.width; */
-                dw += scroll_class->scrollbar_spacing;
-            }
+        if (m_hasScrolling)
+            GetScrollbarWidth(m_widget, dw, dh);

 
 

-            if (scroll_window->hscrollbar_visible)
-            {
-                dh += 15;   /* dh += hscrollbar->allocation.height; */
-                dh += scroll_class->scrollbar_spacing;
-            }
-        }
+        const int border = GTK_CONTAINER(m_wxwindow)->border_width;
+        dw += 2 * border;
+        dh += 2 * border;

 
 

-        if (width) (*width) = m_width - dw;
-        if (height) (*height) = m_height - dh;
+        w -= dw;
+        h -= dh;
+        if (w < 0)
+            w = 0;
+        if (h < 0)
+            h = 0;

     }
     }

+
+    if (width) *width = w;
+    if (height) *height = h;

 }
 
 }
 

-void wxWindow::DoGetPosition( int *x, int *y ) const
+void wxWindowGTK::DoGetPosition( int *x, int *y ) const

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 


@@ -2395,16 +2924,38 @@ void wxWindow::DoGetPosition( int *x, int *y ) const
     int dy = 0;
     if (m_parent && m_parent->m_wxwindow)
     {
     int dy = 0;
     if (m_parent && m_parent->m_wxwindow)
     {

-        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
-       dx = myfixed->xoffset;
-       dy = myfixed->yoffset;
+        GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
+        dx = gtk_pizza_get_xoffset( pizza );
+        dy = gtk_pizza_get_yoffset( pizza );
+    }
+
+    if (m_x == -1 && m_y == -1)
+    {
+        GdkWindow *source = (GdkWindow *) NULL;
+        if (m_wxwindow)
+            source = GTK_PIZZA(m_wxwindow)->bin_window;
+        else
+            source = m_widget->window;
+
+        if (source)
+        {
+            int org_x = 0;
+            int org_y = 0;
+            gdk_window_get_origin( source, &org_x, &org_y );
+
+            if (m_parent)
+                m_parent->ScreenToClient(&org_x, &org_y);
+
+            wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
+            wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
+        }

     }
 
     if (x) (*x) = m_x - dx;
     if (y) (*y) = m_y - dy;
 }
 
     }
 
     if (x) (*x) = m_x - dx;
     if (y) (*y) = m_y - dy;
 }
 

-void wxWindow::DoClientToScreen( int *x, int *y ) const
+void wxWindowGTK::DoClientToScreen( int *x, int *y ) const

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 


@@ -2412,7 +2963,7 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)

-        source = GTK_MYFIXED(m_wxwindow)->bin_window;
+        source = GTK_PIZZA(m_wxwindow)->bin_window;

     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 


@@ -2429,11 +2980,19 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
         }
     }
 
         }
     }
 

-    if (x) *x += org_x;
+
+    if (x)
+    {
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            *x = (GetClientSize().x - *x) + org_x;
+        else
+            *x += org_x;
+    }
+

     if (y) *y += org_y;
 }
 
     if (y) *y += org_y;
 }
 

-void wxWindow::DoScreenToClient( int *x, int *y ) const
+void wxWindowGTK::DoScreenToClient( int *x, int *y ) const

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 


@@ -2441,7 +3000,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)

-        source = GTK_MYFIXED(m_wxwindow)->bin_window;
+        source = GTK_PIZZA(m_wxwindow)->bin_window;

     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 


@@ -2458,123 +3017,271 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
         }
     }
 
         }
     }
 

-    if (x) *x -= org_x;
+    if (x)
+    {
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            *x = (GetClientSize().x - *x) - org_x;
+        else
+            *x -= org_x;
+    }

     if (y) *y -= org_y;
 }
 
     if (y) *y -= org_y;
 }
 

-bool wxWindow::Show( bool show )
+bool wxWindowGTK::Show( bool show )

 {
 {

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

 
     if (!wxWindowBase::Show(show))
     {
         // nothing to do
 
     if (!wxWindowBase::Show(show))
     {
         // nothing to do

-        return FALSE;
+        return false;

     }
 
     if (show)
     }
 
     if (show)

-        gtk_widget_show( m_widget );
+    {
+        if (!m_showOnIdle)
+        {
+            gtk_widget_show( m_widget );
+            wxShowEvent eventShow(GetId(), show);
+            eventShow.SetEventObject(this);
+            GetEventHandler()->ProcessEvent(eventShow);
+        }
+    }

     else
     else

+    {

         gtk_widget_hide( m_widget );
         gtk_widget_hide( m_widget );

+        wxShowEvent eventShow(GetId(), show);
+        eventShow.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(eventShow);
+    }

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-bool wxWindow::Enable( bool enable )
+void wxWindowGTK::DoEnable( bool enable )

 {
 {

-    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
-
-    if (!wxWindowBase::Enable(enable))
-    {
-        // nothing to do
-        return FALSE;
-    }
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );

 
     gtk_widget_set_sensitive( m_widget, enable );
 
     gtk_widget_set_sensitive( m_widget, enable );

-    if ( m_wxwindow )
+    if (m_wxwindow && (m_wxwindow != m_widget))

         gtk_widget_set_sensitive( m_wxwindow, enable );
         gtk_widget_set_sensitive( m_wxwindow, enable );

-
-    return TRUE;

 }
 
 }
 

-int wxWindow::GetCharHeight() const
+int wxWindowGTK::GetCharHeight() const

 {
     wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
 
 {
     wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
 

-    wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
+    wxFont font = GetFont();
+    wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
+
+    PangoContext *context = NULL;
+    if (m_widget)
+        context = gtk_widget_get_pango_context( m_widget );
+
+    if (!context)
+        return 0;
+
+    PangoFontDescription *desc = font.GetNativeFontInfo()->description;
+    PangoLayout *layout = pango_layout_new(context);
+    pango_layout_set_font_description(layout, desc);
+    pango_layout_set_text(layout, "H", 1);
+    PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;

 
 

-    GdkFont *font = m_font.GetInternalFont( 1.0 );
+    PangoRectangle rect;
+    pango_layout_line_get_extents(line, NULL, &rect);

 
 

-    return font->ascent + font->descent;
+    g_object_unref (layout);
+
+    return (int) PANGO_PIXELS(rect.height);

 }
 
 }
 

-int wxWindow::GetCharWidth() const
+int wxWindowGTK::GetCharWidth() const

 {
     wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
 
 {
     wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
 

-    wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
+    wxFont font = GetFont();
+    wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
+
+    PangoContext *context = NULL;
+    if (m_widget)
+        context = gtk_widget_get_pango_context( m_widget );
+
+    if (!context)
+        return 0;
+
+    PangoFontDescription *desc = font.GetNativeFontInfo()->description;
+    PangoLayout *layout = pango_layout_new(context);
+    pango_layout_set_font_description(layout, desc);
+    pango_layout_set_text(layout, "g", 1);
+    PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
+
+    PangoRectangle rect;
+    pango_layout_line_get_extents(line, NULL, &rect);

 
 

-    GdkFont *font = m_font.GetInternalFont( 1.0 );
+    g_object_unref (layout);

 
 

-    return gdk_string_width( font, "H" );
+    return (int) PANGO_PIXELS(rect.width);

 }
 
 }
 

-void wxWindow::GetTextExtent( const wxString& string,
-                              int *x,
-                              int *y,
-                              int *descent,
-                              int *externalLeading,
-                              const wxFont *theFont ) const
+void wxWindowGTK::GetTextExtent( const wxString& string,
+                                 int *x,
+                                 int *y,
+                                 int *descent,
+                                 int *externalLeading,
+                                 const wxFont *theFont ) const

 {
 {

-    wxFont fontToUse = m_font;
-    if (theFont) fontToUse = *theFont;
+    wxFont fontToUse = theFont ? *theFont : GetFont();

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

-    GdkFont *font = fontToUse.GetInternalFont( 1.0 );
-    if (x) (*x) = gdk_string_width( font, string.mbc_str() );
-    if (y) (*y) = font->ascent + font->descent;
-    if (descent) (*descent) = font->descent;
+    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;  // ??
     if (externalLeading) (*externalLeading) = 0;  // ??

+
+    g_object_unref (layout);

 }
 
 }
 

-void wxWindow::SetFocus()
+bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()

 {
 {

-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+    if ( g_delayedFocus == this )
+    {
+        if ( GTK_WIDGET_REALIZED(m_widget) )
+        {
+            gtk_widget_grab_focus(m_widget);
+            g_delayedFocus = NULL;

 
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (connect_widget)
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void wxWindowGTK::SetFocus()
+{
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+    if ( m_hasFocus )

     {
     {

-        if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
+        // don't do anything if we already have focus
+        return;
+    }
+
+    if (m_wxwindow)
+    {
+        if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
+        {
+            gtk_widget_grab_focus (m_wxwindow);
+        }
+    }
+    else if (m_widget)
+    {
+        if (GTK_IS_CONTAINER(m_widget))

         {
         {

-            gtk_widget_grab_focus (connect_widget);
+            if (IsKindOf(CLASSINFO(wxRadioButton)))
+            {
+                gtk_widget_grab_focus (m_widget);
+                return;
+            }
+
+            gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );

         }
         }

-        else if (GTK_IS_CONTAINER(connect_widget))
+        else
+        if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )

         {
         {

-            gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
+
+            if (!GTK_WIDGET_REALIZED(m_widget))
+            {
+                // we can't set the focus to the widget now so we remember that
+                // it should be focused and will do it later, during the idle
+                // time, as soon as we can
+                wxLogTrace(TRACE_FOCUS,
+                           _T("Delaying setting focus to %s(%s)"),
+                           GetClassInfo()->GetClassName(), GetLabel().c_str());
+
+                g_delayedFocus = this;
+            }
+            else
+            {
+                wxLogTrace(TRACE_FOCUS,
+                           _T("Setting focus to %s(%s)"),
+                           GetClassInfo()->GetClassName(), GetLabel().c_str());
+
+                gtk_widget_grab_focus (m_widget);
+            }

         }
         else
         {
         }
         else
         {

+           wxLogTrace(TRACE_FOCUS,
+                      _T("Can't set focus to %s(%s)"),
+                      GetClassInfo()->GetClassName(), GetLabel().c_str());

         }
     }
 }
 
         }
     }
 }
 

-bool wxWindow::AcceptsFocus() const
+void wxWindowGTK::SetCanFocus(bool canFocus)

 {
 {

-    return m_acceptsFocus && wxWindowBase::AcceptsFocus();
+    if ( canFocus )
+        GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
+    else
+        GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
+
+    if ( m_wxwindow && (m_widget != m_wxwindow) )
+    {
+        if ( canFocus )
+            GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+        else
+            GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+    }

 }
 
 }
 

-bool wxWindow::Reparent( wxWindowBase *newParentBase )
+bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )

 {
 {

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

 
 

-    wxWindow *oldParent = m_parent,
-             *newParent = (wxWindow *)newParentBase;
+    wxWindowGTK *oldParent = m_parent,
+             *newParent = (wxWindowGTK *)newParentBase;

 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 
     if ( !wxWindowBase::Reparent(newParent) )
 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 
     if ( !wxWindowBase::Reparent(newParent) )

-        return FALSE;
+        return false;

 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 
 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 


@@ -2583,24 +3290,32 @@ bool wxWindow::Reparent( wxWindowBase *newParentBase )
 
     if (oldParent)
     {
 
     if (oldParent)
     {

-        gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
+        gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );

     }
 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 
     if (newParent)
     {
     }
 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 
     if (newParent)
     {

+        if (GTK_WIDGET_VISIBLE (newParent->m_widget))
+        {
+            m_showOnIdle = true;
+            gtk_widget_hide( m_widget );
+        }
+

         /* insert GTK representation */
         (*(newParent->m_insertCallback))(newParent, this);
     }
 
     /* reverse: prevent GTK from deleting the widget arbitrarily */
     gtk_widget_unref( m_widget );
         /* insert GTK representation */
         (*(newParent->m_insertCallback))(newParent, this);
     }
 
     /* reverse: prevent GTK from deleting the widget arbitrarily */
     gtk_widget_unref( m_widget );

-    
-    return TRUE;
+
+    SetLayoutDirection(wxLayout_Default);
+
+    return true;

 }
 
 }
 

-void wxWindow::DoAddChild(wxWindow *child)
+void wxWindowGTK::DoAddChild(wxWindowGTK *child)

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 


@@ -2615,349 +3330,700 @@ void wxWindow::DoAddChild(wxWindow *child)
     (*m_insertCallback)(this, child);
 }
 
     (*m_insertCallback)(this, child);
 }
 

-void wxWindow::Raise()
+void wxWindowGTK::AddChild(wxWindowBase *child)
+{
+    wxWindowBase::AddChild(child);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
+
+void wxWindowGTK::RemoveChild(wxWindowBase *child)
+{
+    wxWindowBase::RemoveChild(child);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
+
+/* static */
+wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
+{
+    return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
+                ? wxLayout_RightToLeft
+                : wxLayout_LeftToRight;
+}
+
+/* static */
+void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
+{
+    wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
+
+    gtk_widget_set_direction(widget,
+                             dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
+                                                         : GTK_TEXT_DIR_LTR);
+}
+
+wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
+{
+    return GTKGetLayout(m_widget);
+}
+
+void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
+{
+    if ( dir == wxLayout_Default )
+    {
+        const wxWindow *const parent = GetParent();
+        if ( parent )
+        {
+            // inherit layout from parent.
+            dir = parent->GetLayoutDirection();
+        }
+        else // no parent, use global default layout
+        {
+            dir = wxTheApp->GetLayoutDirection();
+        }
+    }
+
+    if ( dir == wxLayout_Default )
+        return;
+
+    GTKSetLayout(m_widget, dir);
+
+    if (m_wxwindow && (m_wxwindow != m_widget))
+        GTKSetLayout(m_wxwindow, dir);
+}
+
+wxCoord
+wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
+                                      wxCoord WXUNUSED(width),
+                                      wxCoord WXUNUSED(widthTotal)) const
+{
+    // We now mirrors the coordinates of RTL windows in GtkPizza
+    return x;
+}
+
+void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+{
+    wxWindowBase::DoMoveInTabOrder(win, move);
+    m_dirtyTabOrder = true;
+    wxTheApp->WakeUpIdle();
+}
+
+bool wxWindowGTK::DoNavigateIn(int flags)
+{
+    if ( flags & wxNavigationKeyEvent::WinChange )
+    {
+        wxFAIL_MSG( _T("not implemented") );
+
+        return false;
+    }
+    else // navigate inside the container
+    {
+        wxWindow *parent = wxGetTopLevelParent(this);
+        wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
+
+        GtkDirectionType dir;
+        dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
+                                                      : GTK_DIR_TAB_BACKWARD;
+
+        gboolean rc;
+        g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
+
+        return rc == TRUE;
+    }
+}
+
+bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
+{
+    // none needed by default
+    return false;
+}
+
+void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
+{
+    // nothing to do by default since none is needed
+}
+
+void wxWindowGTK::RealizeTabOrder()
+{
+    if (m_wxwindow)
+    {
+        if ( !m_children.empty() )
+        {
+            // we don't only construct the correct focus chain but also use
+            // this opportunity to update the mnemonic widgets for the widgets
+            // that need them
+
+            GList *chain = NULL;
+            wxWindowGTK* mnemonicWindow = NULL;
+
+            for ( wxWindowList::const_iterator i = m_children.begin();
+                  i != m_children.end();
+                  ++i )
+            {
+                wxWindowGTK *win = *i;
+
+                if ( mnemonicWindow )
+                {
+                    if ( win->AcceptsFocusFromKeyboard() )
+                    {
+                        // wxComboBox et al. needs to focus on on a different
+                        // widget than m_widget, so if the main widget isn't
+                        // focusable try the connect widget
+                        GtkWidget* w = win->m_widget;
+                        if ( !GTK_WIDGET_CAN_FOCUS(w) )
+                        {
+                            w = win->GetConnectWidget();
+                            if ( !GTK_WIDGET_CAN_FOCUS(w) )
+                                w = NULL;
+                        }
+
+                        if ( w )
+                        {
+                            mnemonicWindow->GTKWidgetDoSetMnemonic(w);
+                            mnemonicWindow = NULL;
+                        }
+                    }
+                }
+                else if ( win->GTKWidgetNeedsMnemonic() )
+                {
+                    mnemonicWindow = win;
+                }
+
+                chain = g_list_prepend(chain, win->m_widget);
+            }
+
+            chain = g_list_reverse(chain);
+
+            gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
+            g_list_free(chain);
+        }
+        else // no children
+        {
+            gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
+        }
+    }
+}
+
+void wxWindowGTK::Raise()

 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 

-    if (!m_widget->window) return;
+    if (m_wxwindow && m_wxwindow->window)
+    {
+        gdk_window_raise( m_wxwindow->window );
+    }
+    else if (m_widget->window)
+    {
+        gdk_window_raise( m_widget->window );
+    }
+}
+
+void wxWindowGTK::Lower()
+{
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+    if (m_wxwindow && m_wxwindow->window)
+    {
+        gdk_window_lower( m_wxwindow->window );
+    }
+    else if (m_widget->window)
+    {
+        gdk_window_lower( m_widget->window );
+    }
+}
+
+bool wxWindowGTK::SetCursor( const wxCursor &cursor )
+{
+    if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
+        return false;
+
+    GTKUpdateCursor();
+
+    return true;
+}
+
+void wxWindowGTK::GTKUpdateCursor()
+{
+    wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
+    if ( cursor.Ok() )
+    {
+        wxArrayGdkWindows windowsThis;
+        GdkWindow * const winThis = GTKGetWindow(windowsThis);
+        if ( winThis )
+        {
+            gdk_window_set_cursor(winThis, cursor.GetCursor());
+        }
+        else
+        {
+            const size_t count = windowsThis.size();
+            for ( size_t n = 0; n < count; n++ )
+            {
+                GdkWindow *win = windowsThis[n];
+                if ( !win )
+                {
+                    wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
+                    continue;
+                }
+
+                gdk_window_set_cursor(win, cursor.GetCursor());
+            }
+        }
+    }
+}
+
+void wxWindowGTK::WarpPointer( int x, int y )
+{
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+    // We provide this function ourselves as it is
+    // missing in GDK (top of this file).
+
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_PIZZA(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+
+    if (window)
+        gdk_window_warp_pointer( window, x, y );
+}
+
+wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
+{
+    // find the scrollbar which generated the event
+    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+    {
+        if ( range == m_scrollBar[dir] )
+            return (ScrollDir)dir;
+    }
+
+    wxFAIL_MSG( _T("event from unknown scrollbar received") );
+
+    return ScrollDir_Max;
+}
+
+bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
+{
+    bool changed = false;
+    GtkRange* range = m_scrollBar[dir];
+    if ( range && units )
+    {
+        GtkAdjustment* adj = range->adjustment;
+        gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
+                                              : adj->page_increment;
+
+        const int posOld = int(adj->value + 0.5);
+        gtk_range_set_value(range, posOld + units*inc);
+
+        changed = int(adj->value + 0.5) != posOld;
+    }
+
+    return changed;
+}
+
+bool wxWindowGTK::ScrollLines(int lines)
+{
+    return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
+}
+
+bool wxWindowGTK::ScrollPages(int pages)
+{
+    return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
+}
+
+void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
+{
+    if (!m_widget)
+        return;
+    if (!m_widget->window)
+        return;
+
+    if (m_wxwindow)
+    {
+        if (!GTK_PIZZA(m_wxwindow)->bin_window) return;
+
+        GdkRectangle gdk_rect,
+                    *p;
+        if (rect)
+        {
+            gdk_rect.x = rect->x;
+            gdk_rect.y = rect->y;
+            gdk_rect.width = rect->width;
+            gdk_rect.height = rect->height;
+            if (GetLayoutDirection() == wxLayout_RightToLeft)
+                gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
+
+            p = &gdk_rect;
+        }
+        else // invalidate everything
+        {
+            p = NULL;
+        }

 
 

-    gdk_window_raise( m_widget->window );
+        gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
+    }

 }
 
 }
 

-void wxWindow::Lower()
+void wxWindowGTK::Update()

 {
 {

-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
-
-    if (!m_widget->window) return;
+    GtkUpdate();

 
 

-    gdk_window_lower( m_widget->window );
+    // when we call Update() we really want to update the window immediately on
+    // screen, even if it means flushing the entire queue and hence slowing down
+    // everything -- but it should still be done, it's just that Update() should
+    // be called very rarely
+    gdk_flush();

 }
 
 }
 

-bool wxWindow::SetCursor( const wxCursor &cursor )
+void wxWindowGTK::GtkUpdate()

 {
 {

-    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
-
-    return wxWindowBase::SetCursor( cursor );
+    if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
+        gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
+    if (m_widget && m_widget->window && (m_wxwindow != m_widget))
+        gdk_window_process_updates( m_widget->window, FALSE );
+
+    // for consistency with other platforms (and also because it's convenient
+    // to be able to update an entire TLW by calling Update() only once), we
+    // should also update all our children here
+    for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        node->GetData()->GtkUpdate();
+    }

 }
 
 }
 

-void wxWindow::WarpPointer( int x, int y )
+bool wxWindowGTK::DoIsExposed( int x, int y ) const

 {
 {

-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+    return m_updateRegion.Contains(x, y) != wxOutRegion;
+}

 
 

-    /* we provide this function ourselves as it is
-       missing in GDK (top of this file)  */
-    
-    GdkWindow *window = (GdkWindow*) NULL;
-    if (m_wxwindow)
-        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+
+bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
+{
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+        return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;

     else
     else

-        window = GetConnectWidget()->window;
-       
-    if (window)
-        gdk_window_warp_pointer( window, x, y );
+        return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;

 }
 
 }
 

-void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
+void wxWindowGTK::GtkSendPaintEvents()

 {
 {

-    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+    if (!m_wxwindow)
+    {
+        m_updateRegion.Clear();
+        return;
+    }

 
 

-    if (!m_widget->window) return;
+    // Clip to paint region in wxClientDC
+    m_clipPaintRegion = true;
+
+    m_nativeUpdateRegion = m_updateRegion;

 
 

-    if (eraseBackground && m_wxwindow && m_wxwindow->window)
+    if (GetLayoutDirection() == wxLayout_RightToLeft)

     {
     {

-        if (rect)
-        {
-            gdk_window_clear_area( GTK_MYFIXED(m_wxwindow)->bin_window,
-                                   rect->x, rect->y,
-                                   rect->width, rect->height );
-        }
-        else
+        // Transform m_updateRegion under RTL
+        m_updateRegion.Clear();
+
+        gint width;
+        gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window,
+                                 NULL, NULL, &width, NULL, NULL );
+
+        wxRegionIterator upd( m_nativeUpdateRegion );
+        while (upd)

         {
         {

-            gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );
+            wxRect rect;
+            rect.x = upd.GetX();
+            rect.y = upd.GetY();
+            rect.width = upd.GetWidth();
+            rect.height = upd.GetHeight();
+
+            rect.x = width - rect.x - rect.width;
+            m_updateRegion.Union( rect );
+
+            ++upd;

         }
     }
 
         }
     }
 

-    /* there is no GTK equivalent of "draw only, don't clear" so we
-       invent our own in the GtkMyFixed widget */
+    // widget to draw on
+    GtkPizza *pizza = GTK_PIZZA (m_wxwindow);

 
 

-    if (!rect)
+    if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))

     {
     {

-        if (m_wxwindow)
-       {
-           GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
-           gboolean old_clear = myfixed->clear_on_draw;
-           gtk_my_fixed_set_clear( myfixed, FALSE );
-           
-            gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
-           
-           gtk_my_fixed_set_clear( myfixed, old_clear );
-       }
-        else
-            gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
+        // find ancestor from which to steal background
+        wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
+        if (!parent)
+            parent = (wxWindow*)this;
+
+        if (GTK_WIDGET_MAPPED(parent->m_widget))
+        {
+            wxRegionIterator upd( m_nativeUpdateRegion );
+            while (upd)
+            {
+                GdkRectangle rect;
+                rect.x = upd.GetX();
+                rect.y = upd.GetY();
+                rect.width = upd.GetWidth();
+                rect.height = upd.GetHeight();
+
+                gtk_paint_flat_box( parent->m_widget->style,
+                            pizza->bin_window,
+                            (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
+                            GTK_SHADOW_NONE,
+                            &rect,
+                            parent->m_widget,
+                            (char *)"base",
+                            0, 0, -1, -1 );
+
+                ++upd;
+            }
+        }

     }
     else
     {
     }
     else
     {

-        GdkRectangle gdk_rect;
-        gdk_rect.x = rect->x;
-        gdk_rect.y = rect->y;
-        gdk_rect.width = rect->width;
-        gdk_rect.height = rect->height;
+        wxWindowDC dc( (wxWindow*)this );
+        dc.SetClippingRegion( m_updateRegion );

 
 

-        if (m_wxwindow)
-       {
-           GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
-           gboolean old_clear = myfixed->clear_on_draw;
-           gtk_my_fixed_set_clear( myfixed, FALSE );
-           
-            gtk_widget_draw( m_wxwindow, &gdk_rect );
-           
-           gtk_my_fixed_set_clear( myfixed, old_clear );
-       }
-        else
-            gtk_widget_draw( m_widget, &gdk_rect );
+        wxEraseEvent erase_event( GetId(), &dc );
+        erase_event.SetEventObject( this );
+
+        GetEventHandler()->ProcessEvent(erase_event);

     }
     }

+
+    wxNcPaintEvent nc_paint_event( GetId() );
+    nc_paint_event.SetEventObject( this );
+    GetEventHandler()->ProcessEvent( nc_paint_event );
+
+    wxPaintEvent paint_event( GetId() );
+    paint_event.SetEventObject( this );
+    GetEventHandler()->ProcessEvent( paint_event );
+
+    m_clipPaintRegion = false;
+
+    m_updateRegion.Clear();
+    m_nativeUpdateRegion.Clear();

 }
 
 }
 

-void wxWindow::Clear()
+void wxWindowGTK::SetDoubleBuffered( bool on )

 {
 {

-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );

 
 

-    if (!m_widget->window) return;
+    if ( m_wxwindow )
+        gtk_widget_set_double_buffered( m_wxwindow, on );
+}

 
 

-    if (m_wxwindow && m_wxwindow->window)
-    {
-        gdk_window_clear( m_wxwindow->window );
-    }
+bool wxWindowGTK::IsDoubleBuffered() const
+{
+    return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
+}
+
+void wxWindowGTK::ClearBackground()
+{
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );

 }
 
 #if wxUSE_TOOLTIPS
 }
 
 #if wxUSE_TOOLTIPS

-void wxWindow::DoSetToolTip( wxToolTip *tip )
+void wxWindowGTK::DoSetToolTip( wxToolTip *tip )

 {
     wxWindowBase::DoSetToolTip(tip);
 
     if (m_tooltip)
 {
     wxWindowBase::DoSetToolTip(tip);
 
     if (m_tooltip)

-        m_tooltip->Apply( this );
-}
-
-void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
-{
-    gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
+        m_tooltip->Apply( (wxWindow *)this );

 }
 }

-#endif // wxUSE_TOOLTIPS

 
 

-bool wxWindow::SetBackgroundColour( const wxColour &colour )
+void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )

 {
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
-
-    if (!wxWindowBase::SetBackgroundColour(colour))
+    if (tip)

     {
     {

-        // don't leave if the GTK widget has just
-        // been realized
-        if (!m_delayedBackgroundColour) return FALSE;
+        wxString tmp( tip );
+        gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );

     }
     }

-
-    GdkWindow *window = (GdkWindow*) NULL;
-    if (m_wxwindow)
-        window = GTK_MYFIXED(m_wxwindow)->bin_window;

     else
     else

-        window = GetConnectWidget()->window;
-       
-    if (!window)

     {
     {

-        // indicate that a new style has been set
-        // but it couldn't get applied as the
-        // widget hasn't been realized yet.
-        m_delayedBackgroundColour = TRUE;
-
-        // pretend we have done something
-        return TRUE;
+        gtk_tooltips_set_tip( tips, GetConnectWidget(), NULL, NULL);

     }
     }

+}
+#endif // wxUSE_TOOLTIPS

 
 

-    if (m_wxwindow)
-    {
-        /* wxMSW doesn't clear the window here. I don't do that either to
-          provide compatibility. call Clear() to do the job. */
+bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
+{
+    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );

 
 

-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
-        gdk_window_set_background( window, m_backgroundColour.GetColor() );
-    }
+    if (!wxWindowBase::SetBackgroundColour(colour))
+        return false;

 
 

-    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if (sysbg == m_backgroundColour)
-    {
-        m_backgroundColour = wxNullColour;
-        ApplyWidgetStyle();
-        m_backgroundColour = sysbg;
-    }
-    else
+    if (colour.Ok())

     {
     {

-        ApplyWidgetStyle();
+        // We need the pixel value e.g. for background clearing.
+        m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));

     }
 
     }
 

-    return TRUE;
+    // apply style change (forceStyle=true so that new style is applied
+    // even if the bg colour changed from valid to wxNullColour)
+    if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
+        ApplyWidgetStyle(true);
+
+    return true;

 }
 
 }
 

-bool wxWindow::SetForegroundColour( const wxColour &colour )
+bool wxWindowGTK::SetForegroundColour( const wxColour &colour )

 {
 {

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

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

-        // don't leave if the GTK widget has just
-        // been realized
-        if (!m_delayedForegroundColour) return FALSE;
+        return false;

     }
 
     }
 

-    GdkWindow *window = (GdkWindow*) NULL;
-    if (m_wxwindow)
-        window = GTK_MYFIXED(m_wxwindow)->bin_window;
-    else
-        window = GetConnectWidget()->window;
-       
-    if (!window)
+    if (colour.Ok())

     {
     {

-        // indicate that a new style has been set
-        // but it couldn't get applied as the
-        // widget hasn't been realized yet.
-        m_delayedForegroundColour = TRUE;
-
-        // pretend we have done something
-        return TRUE;
+        // We need the pixel value e.g. for background clearing.
+        m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));

     }
 
     }
 

-    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if ( sysbg == m_backgroundColour )
-    {
-        m_backgroundColour = wxNullColour;
-        ApplyWidgetStyle();
-        m_backgroundColour = sysbg;
-    }
-    else
-    {
-        ApplyWidgetStyle();
-    }
+    // apply style change (forceStyle=true so that new style is applied
+    // even if the bg colour changed from valid to wxNullColour):
+    ApplyWidgetStyle(true);

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-GtkStyle *wxWindow::GetWidgetStyle()
+PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()

 {
 {

-    if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
-
-    m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
-
-    return m_widgetStyle;
+    return gtk_widget_get_pango_context( m_widget );

 }
 
 }
 

-void wxWindow::SetWidgetStyle()
+GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)

 {
 {

-    GtkStyle *style = GetWidgetStyle();
+    // do we need to apply any changes at all?
+    if ( !forceStyle &&
+         !m_font.Ok() &&
+         !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
+    {
+        return NULL;
+    }

 
 

-    gdk_font_unref( style->font );
-    style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+    GtkRcStyle *style = gtk_rc_style_new();

 
 

-    if (m_foregroundColour.Ok())
+    if ( m_font.Ok() )

     {
     {

-        m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
-        style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
-        style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
-        style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
+        style->font_desc =
+            pango_font_description_copy( m_font.GetNativeFontInfo()->description );

     }
 
     }
 

-    if (m_backgroundColour.Ok())
+    int flagsNormal = 0,
+        flagsPrelight = 0,
+        flagsActive = 0,
+        flagsInsensitive = 0;
+
+    if ( m_foregroundColour.Ok() )

     {
     {

-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
-        style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
+        const GdkColor *fg = m_foregroundColour.GetColor();
+
+        style->fg[GTK_STATE_NORMAL] =
+        style->text[GTK_STATE_NORMAL] = *fg;
+        flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
+
+        style->fg[GTK_STATE_PRELIGHT] =
+        style->text[GTK_STATE_PRELIGHT] = *fg;
+        flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
+
+        style->fg[GTK_STATE_ACTIVE] =
+        style->text[GTK_STATE_ACTIVE] = *fg;
+        flagsActive |= GTK_RC_FG | GTK_RC_TEXT;

     }
     }

-}

 
 

-void wxWindow::ApplyWidgetStyle()
-{
-}
+    if ( m_backgroundColour.Ok() )
+    {
+        const GdkColor *bg = m_backgroundColour.GetColor();

 
 

-//-----------------------------------------------------------------------------
-// Pop-up menu stuff
-//-----------------------------------------------------------------------------
+        style->bg[GTK_STATE_NORMAL] =
+        style->base[GTK_STATE_NORMAL] = *bg;
+        flagsNormal |= GTK_RC_BG | GTK_RC_BASE;

 
 

-static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting  )
-{
-    *is_waiting = FALSE;
+        style->bg[GTK_STATE_PRELIGHT] =
+        style->base[GTK_STATE_PRELIGHT] = *bg;
+        flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
+
+        style->bg[GTK_STATE_ACTIVE] =
+        style->base[GTK_STATE_ACTIVE] = *bg;
+        flagsActive |= GTK_RC_BG | GTK_RC_BASE;
+
+        style->bg[GTK_STATE_INSENSITIVE] =
+        style->base[GTK_STATE_INSENSITIVE] = *bg;
+        flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
+    }
+
+    style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
+    style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
+    style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
+    style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
+
+    return style;

 }
 
 }
 

-static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
+void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)

 {
 {

-    menu->SetInvokingWindow( win );
-    wxNode *node = menu->GetItems().First();
-    while (node)
+    GtkRcStyle *style = CreateWidgetStyle(forceStyle);
+    if ( style )

     {
     {

-        wxMenuItem *menuitem = (wxMenuItem*)node->Data();
-        if (menuitem->IsSubMenu())
-        {
-            SetInvokingWindow( menuitem->GetSubMenu(), win );
-        }
-        node = node->Next();
+        DoApplyWidgetStyle(style);
+        gtk_rc_style_unref(style);

     }
     }

-}

 
 

-static gint gs_pop_x = 0;
-static gint gs_pop_y = 0;
+    // Style change may affect GTK+'s size calculation:
+    InvalidateBestSize();
+}

 
 

-static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
-                              gint *x, gint *y,
-                              wxWindow *win )
+void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)

 {
 {

-    win->ClientToScreen( &gs_pop_x, &gs_pop_y );
-    *x = gs_pop_x;
-    *y = gs_pop_y;
+    if (m_wxwindow)
+        gtk_widget_modify_style(m_wxwindow, style);
+    else
+        gtk_widget_modify_style(m_widget, style);

 }
 
 }
 

-bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
+bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)

 {
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
-
-    wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
-
-    SetInvokingWindow( menu, this );
-
-    menu->UpdateUI();
+    wxWindowBase::SetBackgroundStyle(style);

 
 

-    gs_pop_x = x;
-    gs_pop_y = y;
+    if (style == wxBG_STYLE_CUSTOM)
+    {
+        GdkWindow *window = (GdkWindow*) NULL;
+        if (m_wxwindow)
+            window = GTK_PIZZA(m_wxwindow)->bin_window;
+        else
+            window = GetConnectWidget()->window;

 
 

-    bool is_waiting = TRUE;
-    
-    gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
-      GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
+        if (window)
+        {
+            // Make sure GDK/X11 doesn't refresh the window
+            // automatically.
+            gdk_window_set_back_pixmap( window, None, False );
+#ifdef __X__
+            Display* display = GDK_WINDOW_DISPLAY(window);
+            XFlush(display);
+#endif
+            m_needsStyleChange = false;
+        }
+        else
+            // Do in OnIdle, because the window is not yet available
+            m_needsStyleChange = true;

 
 

-    gtk_menu_popup(
-                  GTK_MENU(menu->m_menu),
-                  (GtkWidget *) NULL,          // parent menu shell
-                  (GtkWidget *) NULL,          // parent menu item
-                  (GtkMenuPositionFunc) pop_pos_callback,
-                  (gpointer) this,             // client data
-                  0,                           // button used to activate it
-                  gs_timeLastClick             // the time of activation
-                );
-               
-    while (is_waiting)
+        // Don't apply widget style, or we get a grey background
+    }
+    else

     {
     {

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

     }
     }

-
-    return TRUE;
+    return true;

 }
 
 #if wxUSE_DRAG_AND_DROP
 
 }
 
 #if wxUSE_DRAG_AND_DROP
 

-void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
+void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )

 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 


@@ -2973,7 +4039,7 @@ void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 
 #endif // wxUSE_DRAG_AND_DROP
 
 
 #endif // wxUSE_DRAG_AND_DROP
 

-GtkWidget* wxWindow::GetConnectWidget()
+GtkWidget* wxWindowGTK::GetConnectWidget()

 {
     GtkWidget *connect_widget = m_widget;
     if (m_wxwindow) connect_widget = m_wxwindow;
 {
     GtkWidget *connect_widget = m_widget;
     if (m_wxwindow) connect_widget = m_wxwindow;


@@ -2981,311 +4047,364 @@ GtkWidget* wxWindow::GetConnectWidget()
     return connect_widget;
 }
 
     return connect_widget;
 }
 

-bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
+bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const

 {
 {

-    if (m_wxwindow) 
-        return (window == GTK_MYFIXED(m_wxwindow)->bin_window);
-    
-    return (window == m_widget->window);
+    wxArrayGdkWindows windowsThis;
+    GdkWindow * const winThis = GTKGetWindow(windowsThis);
+
+    return winThis ? window == winThis
+                   : windowsThis.Index(window) != wxNOT_FOUND;

 }
 
 }
 

-bool wxWindow::SetFont( const wxFont &font )
+GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const

 {
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
-
-    if (!wxWindowBase::SetFont(font))
-    {
-        // don't leave if the GTK widget has just
-        // been realized
-        if (!m_delayedFont) return FALSE;
-    }
+    return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window;
+}

 
 

-    GdkWindow *window = (GdkWindow*) NULL;
-    if (m_wxwindow)
-        window = GTK_MYFIXED(m_wxwindow)->bin_window;
-    else
-        window = GetConnectWidget()->window;
-       
-    if (!window)
-    {
-        // indicate that a new style has been set
-        // but it couldn't get applied as the
-        // widget hasn't been realized yet.
-        m_delayedFont = TRUE;
+bool wxWindowGTK::SetFont( const wxFont &font )
+{
+    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );

 
 

-        // pretend we have done something
-        return TRUE;
-    }
+    if (!wxWindowBase::SetFont(font))
+        return false;

 
 

-    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if ( sysbg == m_backgroundColour )
-    {
-        m_backgroundColour = wxNullColour;
-        ApplyWidgetStyle();
-        m_backgroundColour = sysbg;
-    }
-    else
-    {
-        ApplyWidgetStyle();
-    }
+    // apply style change (forceStyle=true so that new style is applied
+    // even if the font changed from valid to wxNullFont):
+    ApplyWidgetStyle(true);

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-void wxWindow::CaptureMouse()
+void wxWindowGTK::DoCaptureMouse()

 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 

-    wxCHECK_RET( g_captureWindow == NULL, wxT("CaptureMouse called twice") );
-

     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)

-        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+        window = GTK_PIZZA(m_wxwindow)->bin_window;

     else
         window = GetConnectWidget()->window;
     else
         window = GetConnectWidget()->window;

-       
-    if (!window) return;
+
+    wxCHECK_RET( window, _T("CaptureMouse() failed") );
+
+    const wxCursor* cursor = &m_cursor;
+    if (!cursor->Ok())
+        cursor = wxSTANDARD_CURSOR;

 
     gdk_pointer_grab( window, FALSE,
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
 
     gdk_pointer_grab( window, FALSE,
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |

-                          GDK_POINTER_MOTION_HINT_MASK | 
+                          GDK_POINTER_MOTION_HINT_MASK |

                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,

-                      m_cursor.GetCursor(),
-                      GDK_CURRENT_TIME );
+                      cursor->GetCursor(),
+                      (guint32)GDK_CURRENT_TIME );

     g_captureWindow = this;
     g_captureWindow = this;

+    g_captureWindowHasMouse = true;

 }
 
 }
 

-void wxWindow::ReleaseMouse()
+void wxWindowGTK::DoReleaseMouse()

 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 

-    wxCHECK_RET( g_captureWindow, wxT("ReleaseMouse called twice") );
+    wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
+
+    g_captureWindow = (wxWindowGTK*) NULL;

 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)

-        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+        window = GTK_PIZZA(m_wxwindow)->bin_window;

     else
         window = GetConnectWidget()->window;
     else
         window = GetConnectWidget()->window;

-       
-    if (!window) return;

 
 

-    gdk_pointer_ungrab ( GDK_CURRENT_TIME );
-    g_captureWindow = (wxWindow*) NULL;
+    if (!window)
+        return;
+
+    gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );

 }
 
 }
 

-bool wxWindow::IsRetained() const
+/* static */
+wxWindow *wxWindowBase::GetCapture()

 {
 {

-    return FALSE;
+    return (wxWindow *)g_captureWindow;

 }
 
 }
 

-void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
-      int range, bool refresh )
+bool wxWindowGTK::IsRetained() const

 {
 {

-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
-
-    m_hasScrolling = TRUE;
+    return false;
+}

 
 

-    if (orient == wxHORIZONTAL)
-    {
-        float fpos = (float)pos;
-        float frange = (float)range;
-        float fthumb = (float)thumbVisible;
-        if (fpos > frange-fthumb) fpos = frange-fthumb;
-        if (fpos < 0.0) fpos = 0.0;
+void wxWindowGTK::BlockScrollEvent()
+{
+    wxASSERT(!m_blockScrollEvent);
+    m_blockScrollEvent = true;
+}

 
 

-        if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
-            (fabs(fthumb-m_hAdjust->page_size) < 0.2))
-        {
-            SetScrollPos( orient, pos, refresh );
-            return;
-        }
+void wxWindowGTK::UnblockScrollEvent()
+{
+    wxASSERT(m_blockScrollEvent);
+    m_blockScrollEvent = false;
+}

 
 

-        m_oldHorizontalPos = fpos;
+void wxWindowGTK::SetScrollbar(int orient,
+                               int pos,
+                               int thumbVisible,
+                               int range,
+                               bool WXUNUSED(update))
+{
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+    wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );

 
 

-        m_hAdjust->lower = 0.0;
-        m_hAdjust->upper = frange;
-        m_hAdjust->value = fpos;
-        m_hAdjust->step_increment = 1.0;
-        m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
-        m_hAdjust->page_size = fthumb;
+    if (range > 0)
+    {
+        m_hasScrolling = true;

     }
     else
     {
     }
     else
     {

-        float fpos = (float)pos;
-        float frange = (float)range;
-        float fthumb = (float)thumbVisible;
-        if (fpos > frange-fthumb) fpos = frange-fthumb;
-        if (fpos < 0.0) fpos = 0.0;
-
-        if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
-            (fabs(fthumb-m_vAdjust->page_size) < 0.2))
-        {
-            SetScrollPos( orient, pos, refresh );
-            return;
-        }
-
-        m_oldVerticalPos = fpos;
-
-        m_vAdjust->lower = 0.0;
-        m_vAdjust->upper = frange;
-        m_vAdjust->value = fpos;
-        m_vAdjust->step_increment = 1.0;
-        m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
-        m_vAdjust->page_size = fthumb;
+        // GtkRange requires upper > lower
+        range =
+        thumbVisible = 1;

     }
 
     }
 

-    if (orient == wxHORIZONTAL)
-        gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
-    else
-        gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+    if (pos > range - thumbVisible)
+        pos = range - thumbVisible;
+    if (pos < 0)
+        pos = 0;
+    GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment;
+    adj->step_increment = 1;
+    adj->page_increment =
+    adj->page_size = thumbVisible;
+    adj->upper = range;
+    SetScrollPos(orient, pos);
+    gtk_adjustment_changed(adj);

 }
 
 }
 

-void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
+void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))

 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );

-

     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );

+    wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );

 
 

-    if (orient == wxHORIZONTAL)
-    {
-        float fpos = (float)pos;
-        if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
-        if (fpos < 0.0) fpos = 0.0;
-        m_oldHorizontalPos = fpos;
-
-        if (fabs(fpos-m_hAdjust->value) < 0.2) return;
-        m_hAdjust->value = fpos;
-    }
-    else
-    {
-        float fpos = (float)pos;
-        if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
-        if (fpos < 0.0) fpos = 0.0;
-        m_oldVerticalPos = fpos;
-
-        if (fabs(fpos-m_vAdjust->value) < 0.2) return;
-        m_vAdjust->value = fpos;
-    }
-
-/*
-    if (!m_isScrolling)
+    // This check is more than an optimization. Without it, the slider
+    //   will not move smoothly while tracking when using wxScrollHelper.
+    if (GetScrollPos(orient) != pos)

     {
     {

-*/
-        if (m_wxwindow->window)
+        const int dir = ScrollDirFromOrient(orient);
+        GtkAdjustment* adj = m_scrollBar[dir]->adjustment;
+        const int max = int(adj->upper - adj->page_size);
+        if (pos > max)
+            pos = max;
+        if (pos < 0)
+            pos = 0;
+        m_scrollPos[dir] = adj->value = pos;
+
+        // If a "value_changed" signal emission is not already in progress
+        if (!m_blockValueChanged[dir])

         {
         {

-            if (orient == wxHORIZONTAL)
-                gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
-            else
-                gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
+            gtk_adjustment_value_changed(adj);

         }
         }

-/*

     }
     }

-*/

 }
 
 }
 

-int wxWindow::GetScrollThumb( int orient ) const
+int wxWindowGTK::GetScrollThumb(int orient) const

 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );

-

     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );

+    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );

 
 

-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->page_size+0.5);
-    else
-        return (int)(m_vAdjust->page_size+0.5);
+    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size);

 }
 
 }
 

-int wxWindow::GetScrollPos( int orient ) const
+int wxWindowGTK::GetScrollPos( int orient ) const

 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );

-

     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );

+    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );

 
 

-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->value+0.5);
-    else
-        return (int)(m_vAdjust->value+0.5);
+    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->value + 0.5);

 }
 
 }
 

-int wxWindow::GetScrollRange( int orient ) const
+int wxWindowGTK::GetScrollRange( int orient ) const

 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 {
     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );

-

     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );

+    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );

 
 

-    if (orient == wxHORIZONTAL)
-        return (int)(m_hAdjust->upper+0.5);
-    else
-        return (int)(m_vAdjust->upper+0.5);
+    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper);

 }
 
 }
 

-void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
+// Determine if increment is the same as +/-x, allowing for some small
+//   difference due to possible inexactness in floating point arithmetic
+static inline bool IsScrollIncrement(double increment, double x)

 {
 {

-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+    wxASSERT(increment > 0);
+    const double tolerance = 1.0 / 1024;
+    return fabs(increment - fabs(x)) < tolerance;
+}

 
 

-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
+{
+    DEBUG_MAIN_THREAD

 
 

-    gtk_myfixed_scroll( GTK_MYFIXED(m_wxwindow), -dx, -dy );
+    wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);

 
 

-/*
-    if (!m_scrollGC)
+    const int barIndex = range == m_scrollBar[1];
+    GtkAdjustment* adj = range->adjustment;
+
+    const int value = int(adj->value + 0.5);
+
+    // save previous position
+    const double oldPos = m_scrollPos[barIndex];
+    // update current position
+    m_scrollPos[barIndex] = adj->value;
+    // If event should be ignored, or integral position has not changed
+    if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))

     {
     {

-        m_scrollGC = gdk_gc_new( m_wxwindow->window );
-        gdk_gc_set_exposures( m_scrollGC, TRUE );
+        return wxEVT_NULL;

     }
 
     }
 

-    wxNode *node = m_children.First();
-    while (node)
+    wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
+    if (!m_isScrolling)

     {
     {

-        wxWindow *child = (wxWindow*) node->Data();
-        int sx = 0;
-        int sy = 0;
-        child->GetSize( &sx, &sy );
-        child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
-        node = node->Next();
+        // Difference from last change event
+        const double diff = adj->value - oldPos;
+        const bool isDown = diff > 0;
+
+        if (IsScrollIncrement(adj->step_increment, diff))
+        {
+            eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
+        }
+        else if (IsScrollIncrement(adj->page_increment, diff))
+        {
+            eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
+        }
+        else if (m_mouseButtonDown)
+        {
+            // Assume track event
+            m_isScrolling = true;
+        }

     }
     }

+    return eventType;
+}
+
+void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
+{
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+
+    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
+
+    // No scrolling requested.
+    if ((dx == 0) && (dy == 0)) return;
+
+    m_clipPaintRegion = true;
+
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+        gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy );
+    else
+        gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );

 
 

-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
-    int w = cw - abs(dx);
-    int h = ch - abs(dy);
+    m_clipPaintRegion = false;

 
 

-    if ((h < 0) || (w < 0))
+#if wxUSE_CARET
+    bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
+    if (restoreCaret)

     {
     {

-        Refresh();
+        wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
+        if (dx > 0)
+            caretRect.width += dx;
+        else
+        {
+            caretRect.x += dx; caretRect.width -= dx;
+        }
+        if (dy > 0)
+            caretRect.height += dy;
+        else
+        {
+            caretRect.y += dy; caretRect.height -= dy;
+        }
+
+        RefreshRect(caretRect);

     }
     }

-    else
+#endif // wxUSE_CARET
+}
+
+void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
+{
+    //RN: Note that static controls usually have no border on gtk, so maybe
+    //it makes sense to treat that as simply no border at the wx level
+    //as well...
+    if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))

     {
     {

-        int s_x = 0;
-        int s_y = 0;
-        if (dx < 0) s_x = -dx;
-        if (dy < 0) s_y = -dy;
-        int d_x = 0;
-        int d_y = 0;
-        if (dx > 0) d_x = dx;
-        if (dy > 0) d_y = dy;
+        GtkShadowType gtkstyle;
+
+        if(wxstyle & wxBORDER_RAISED)
+            gtkstyle = GTK_SHADOW_OUT;
+        else if (wxstyle & wxBORDER_SUNKEN)
+            gtkstyle = GTK_SHADOW_IN;
+        else if (wxstyle & wxBORDER_DOUBLE)
+            gtkstyle = GTK_SHADOW_ETCHED_IN;
+        else //default
+            gtkstyle = GTK_SHADOW_IN;
+
+        gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
+                                             gtkstyle );
+    }
+}
+
+void wxWindowGTK::SetWindowStyleFlag( long style )
+{
+    // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
+    wxWindowBase::SetWindowStyleFlag(style);
+}

 
 

-        gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
-            m_wxwindow->window, s_x, s_y, w, h );
+// Find the wxWindow at the current mouse position, also returning the mouse
+// position.
+wxWindow* wxFindWindowAtPointer(wxPoint& pt)
+{
+    pt = wxGetMousePosition();
+    wxWindow* found = wxFindWindowAtPoint(pt);
+    return found;
+}

 
 

-        wxRect rect;
-        if (dx < 0) rect.x = cw+dx; else rect.x = 0;
-        if (dy < 0) rect.y = ch+dy; else rect.y = 0;
-        if (dy != 0) rect.width = cw; else rect.width = abs(dx);
-        if (dx != 0) rect.height = ch; else rect.height = abs(dy);
+// Get the current mouse position.
+wxPoint wxGetMousePosition()
+{
+  /* This crashes when used within wxHelpContext,
+     so we have to use the X-specific implementation below.
+    gint x, y;
+    GdkModifierType *mask;
+    (void) gdk_window_get_pointer(NULL, &x, &y, mask);
+
+    return wxPoint(x, y);
+  */
+
+    int x, y;
+    GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
+
+    Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
+    Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
+    Window rootReturn, childReturn;
+    int rootX, rootY, winX, winY;
+    unsigned int maskReturn;
+
+    XQueryPointer (display,
+           rootWindow,
+           &rootReturn,
+                   &childReturn,
+                   &rootX, &rootY, &winX, &winY, &maskReturn);
+    return wxPoint(rootX, rootY);

 
 

-        Refresh( TRUE, &rect );
-    }
-*/

 }
 
 }
 

-void wxWindow::SetScrolling(bool scroll)
+// Needed for implementing e.g. combobox on wxGTK within a modal dialog.
+void wxAddGrab(wxWindow* window)
+{
+    gtk_grab_add( (GtkWidget*) window->GetHandle() );
+}
+
+void wxRemoveGrab(wxWindow* window)

 {
 {

-    m_isScrolling = g_blockEventsOnScroll = scroll;
+    gtk_grab_remove( (GtkWidget*) window->GetHandle() );

 }
 }