fix for wxComboBox::GetSelection from inside event handler

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

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index d09ee10763e8c81ca8352bcc7272c6abfad44265..05a2f829cb4e0dfbf11285b61517ddc0c2bf15ea 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

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


@@ -12,9 +12,13 @@
     #pragma implementation "window.h"
 #endif
 
     #pragma implementation "window.h"
 #endif
 

+#ifdef __VMS
+#define XWarpPointer XWARPPOINTER
+#endif
+

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

-#include "wx/dc.h"
+#include "wx/dcclient.h"

 #include "wx/frame.h"
 #include "wx/app.h"
 #include "wx/layout.h"
 #include "wx/frame.h"
 #include "wx/app.h"
 #include "wx/layout.h"


@@ -30,21 +34,36 @@
     #include "wx/tooltip.h"
 #endif
 
     #include "wx/tooltip.h"
 #endif
 

+#if wxUSE_CARET
+    #include "wx/caret.h"
+#endif // wxUSE_CARET
+
+#if wxUSE_TEXTCTRL
+#include "wx/textctrl.h"
+#endif
+

 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"
 #include "wx/settings.h"
 #include "wx/log.h"
 
 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"
 #include "wx/settings.h"
 #include "wx/log.h"
 

+#ifdef __WXDEBUG__
+    #include "wx/thread.h"
+#endif
+

 #include <math.h>
 
 #include <math.h>
 

-#include "gdk/gdk.h"
-#include "gtk/gtk.h"
-#include "gdk/gdkprivate.h"
-#include "gdk/gdkkeysyms.h"
-#include "wx/gtk/win_gtk.h"
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkprivate.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>

 
 

-#include "gdk/gdkx.h"
+#include <gtk/gtk.h>
+#include <gtk/gtkprivate.h>
+
+#include "wx/gtk/win_gtk.h"

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


@@ -184,9 +203,23 @@ extern wxList     wxPendingDelete;
 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;
 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;

-static wxWindow  *g_captureWindow = (wxWindow*) NULL;

 
 

-/* extern */ wxWindow  *g_focusWindow = (wxWindow*) NULL;
+// mouse capture state: the window which has it and if the mouse is currently
+// inside it
+static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;
+static bool g_captureWindowHasMouse = FALSE;
+
+/* extern */ wxWindowGTK  *g_focusWindow = (wxWindowGTK*) NULL;
+
+// the last window which had the focus - this is normally never NULL (except
+// if we never had focus at all) as even when g_focusWindow is NULL it still
+// keeps its previous value
+static wxWindowGTK *g_focusWindowLast = (wxWindowGTK *)NULL;
+
+// the frame that is currently active (i.e. its child has focus). It is
+// used to generate wxActivateEvents
+static wxWindowGTK *g_activeFrame = (wxWindowGTK *)NULL;
+static bool g_activeFrameLostFocus = FALSE;

 
 // if we detect that the app has got/lost the focus, we set this variable to
 // either TRUE or FALSE and an activate event will be sent during the next
 
 // if we detect that the app has got/lost the focus, we set this variable to
 // either TRUE or FALSE and an activate event will be sent during the next


@@ -198,12 +231,24 @@ static int        g_sendActivateEvent = -1;
    the last click here */
 static guint32 gs_timeLastClick = 0;
 
    the last click here */
 static guint32 gs_timeLastClick = 0;
 

+extern bool g_mainThreadLocked;
+

 //-----------------------------------------------------------------------------
 // debug
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // debug
 //-----------------------------------------------------------------------------
 

+#ifndef __WXGTK20__
+#define DISABLE_STYLE_IF_BROKEN_THEME 1
+#endif
+

 #ifdef __WXDEBUG__
 
 #ifdef __WXDEBUG__
 

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

 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),
                                          const wxChar *WXUNUSED(name) )
 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),
                                          const wxChar *WXUNUSED(name) )


@@ -223,18 +268,25 @@ static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
 
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {
 
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {

-    wxString tmp = name;
-    tmp += wxT(" FROM ");
-    tmp += window;
+    // suppress warnings about gtk_debug_focus_in_callback being unused with
+    // this "if ( 0 )"
+    if ( 0 )
+    {
+        wxString tmp = name;
+        tmp += wxT(" FROM ");
+        tmp += window;

 
 

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

 
 

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

 
 

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

 }
 
 }
 

+#else
+#define DEBUG_MAIN_THREAD

 #endif // Debug
 
 //-----------------------------------------------------------------------------
 #endif // Debug
 
 //-----------------------------------------------------------------------------


@@ -246,11 +298,23 @@ gdk_window_warp_pointer (GdkWindow      *window,
                          gint            x,
                          gint            y)
 {
                          gint            x,
                          gint            y)
 {

+#ifndef __WXGTK20__

   GdkWindowPrivate *priv;
   GdkWindowPrivate *priv;

+#endif

 
   if (!window)
 
   if (!window)

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

 
 

+#ifdef __WXGTK20__
+  if (!GDK_WINDOW_DESTROYED(window))
+  {
+      XWarpPointer (GDK_WINDOW_XDISPLAY(window),
+                    None,              /* not source window -> move from anywhere */
+                    GDK_WINDOW_XID(window),  /* dest window */
+                    0, 0, 0, 0,        /* not source window -> move from anywhere */
+                    x, y );
+  }
+#else

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


@@ -261,6 +325,7 @@ gdk_window_warp_pointer (GdkWindow      *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 );
   }

+#endif

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


@@ -274,37 +339,79 @@ extern bool g_isIdle;
 // local code (see below)
 //-----------------------------------------------------------------------------
 
 // local code (see below)
 //-----------------------------------------------------------------------------
 

-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)
+{
+    wxWindow *winFocus = wxWindowGTK::FindFocus();
+    if ( !winFocus )
+        return (wxWindow *)NULL;
+
+    if ( winFocus == win )
+        return (wxWindow *)win;
+
+    for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxWindow *child = wxFindFocusedChild(node->GetData());
+        if ( child )
+            return child;
+    }
+
+    return (wxWindow *)NULL;
+}
+
+// Returns toplevel grandparent of given window:
+static wxWindowGTK* wxGetTopLevelParent(wxWindowGTK *win)

 {
 {

+    wxWindowGTK *p = win;
+    while (p && !p->IsTopLevel())
+         p = p->GetParent();
+    return p;
+}
+
+
+static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
+{
+    // wxUniversal widgets draw the borders and scrollbars themselves
+#ifndef __WXUNIVERSAL__

     if (!win->m_hasVMT)
         return;
 
     int dw = 0;
     int dh = 0;
 
     if (!win->m_hasVMT)
         return;
 
     int dw = 0;
     int dh = 0;
 

-    if (win->HasScrolling())
+    if (win->m_hasScrolling)

     {
     {

-        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
-        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);

 
 

-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+            GtkRequisition vscroll_req;
+            vscroll_req.width = 2;
+            vscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
+                (scroll_window->vscrollbar, &vscroll_req );

 
 

-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
+            GtkRequisition hscroll_req;
+            hscroll_req.width = 2;
+            hscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
+                (scroll_window->hscrollbar, &hscroll_req );

 
 

-        if (scroll_window->vscrollbar_visible)
-        {
-            dw += 15;   /* dw += vscrollbar->allocation.width; */
-            dw += scroll_class->scrollbar_spacing;
-        }
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );

 
 

-        if (scroll_window->hscrollbar_visible)
-        {
-            dh += 15;   /* dh += hscrollbar->allocation.height; */
-            dh += scroll_class->scrollbar_spacing;
-        }
+            if (scroll_window->vscrollbar_visible)
+            {
+                dw += vscroll_req.width;
+                dw += scroll_class->scrollbar_spacing;
+            }
+
+            if (scroll_window->hscrollbar_visible)
+            {
+                dh += hscroll_req.height;
+                dh += scroll_class->scrollbar_spacing;
+            }

     }
 
     int dx = 0;
     }
 
     int dx = 0;


@@ -322,7 +429,7 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
                          GTK_STATE_NORMAL,
                          GTK_SHADOW_OUT,
                          dx, dy,
                          GTK_STATE_NORMAL,
                          GTK_SHADOW_OUT,
                          dx, dy,

-                         win->m_width-dw, win->m_height-dh );
+                         widget->allocation.width-dw, widget->allocation.height-dh );

         return;
     }
 
         return;
     }
 


@@ -333,7 +440,7 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
                          GTK_STATE_NORMAL,
                          GTK_SHADOW_IN,
                          dx, dy,
                          GTK_STATE_NORMAL,
                          GTK_SHADOW_IN,
                          dx, dy,

-                         win->m_width-dw, win->m_height-dh );
+                         widget->allocation.width-dw, widget->allocation.height-dh );

         return;
     }
 
         return;
     }
 


@@ -344,27 +451,31 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
         gdk_gc_set_foreground( gc, &widget->style->black );
         gdk_draw_rectangle( widget->window, gc, FALSE,
                          dx, dy,
         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 );
+                         widget->allocation.width-dw-1, widget->allocation.height-dh-1 );

         gdk_gc_unref( gc );
         return;
     }
         gdk_gc_unref( gc );
         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 )
+gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )

 {
 {

-    if (gdk_event->count > 0) return;
+    if (gdk_event->count > 0) return FALSE;
+

     draw_frame( widget, win );
     draw_frame( widget, win );

+
+    return TRUE;

 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_widget
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_widget
 //-----------------------------------------------------------------------------
 

-static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
+static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )

 {
     draw_frame( widget, win );
 }
 {
     draw_frame( widget, win );
 }


@@ -373,11 +484,23 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
 // key code mapping routines
 //-----------------------------------------------------------------------------
 
 // key code mapping routines
 //-----------------------------------------------------------------------------
 

-static long map_to_unmodified_wx_keysym( KeySym keysym )
+static long map_to_unmodified_wx_keysym( GdkEventKey *event )

 {
 {

-    guint key_code = 0;
+    // 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 resue it as last resort
+    //
+    // NB: should be MT-neutral as always called from main thread only
+    static struct
+    {
+        KeySym keysym;
+        long   keycode;
+    } s_lastKeyPress = { 0, 0 };

 
 

-    switch (keysym)
+    KeySym keysym = event->keyval;
+    long key_code;
+
+    switch ( keysym )

     {
         case GDK_Shift_L:
         case GDK_Shift_R:       key_code = WXK_SHIFT;       break;
     {
         case GDK_Shift_L:
         case GDK_Shift_R:       key_code = WXK_SHIFT;       break;


@@ -470,20 +593,50 @@ static long map_to_unmodified_wx_keysym( KeySym keysym )
         case GDK_F12:           key_code = WXK_F12;         break;
         default:
         {
         case GDK_F12:           key_code = WXK_F12;         break;
         default:
         {

-            if (keysym <= 0xFF)
+            // do we have the translation?
+            if ( event->length == 1 )

             {
             {

-                guint upper = gdk_keyval_to_upper( (guint)keysym );
-                keysym = (upper != 0 ? upper : keysym ); /* to be MSW compatible */
-                key_code = (guint)keysym;
+                keysym = (KeySym)event->string[0];
+            }
+            else if ( (keysym & 0xFF) != keysym )
+            {
+                // non ASCII key, what to do?
+
+                if ( event->type == GDK_KEY_RELEASE )
+                {
+                    // reuse the one from the last keypress if any
+                    if ( keysym == s_lastKeyPress.keysym )
+                    {
+                        key_code = s_lastKeyPress.keycode;
+
+                        // skip "return 0"
+                        break;
+                    }
+                }
+
+                // ignore this one, we don't know it
+                return 0;
+            }
+            //else: ASCII key, ok
+
+            guint upper = gdk_keyval_to_upper( (guint)keysym );
+            key_code = upper ? upper : keysym;
+
+            if ( event->type == GDK_KEY_PRESS )
+            {
+                // remember it to be reused below later
+                s_lastKeyPress.keysym = keysym;
+                s_lastKeyPress.keycode = key_code;

             }
         }
     }
 
             }
         }
     }
 

-    return (key_code);
+    return key_code;

 }
 
 }
 

-static long map_to_wx_keysym( KeySym keysym )
+static long map_to_wx_keysym( GdkEventKey *event )

 {
 {

+    KeySym keysym = event->keyval;

     guint key_code = 0;
 
     switch (keysym)
     guint key_code = 0;
 
     switch (keysym)


@@ -568,126 +721,319 @@ static long map_to_wx_keysym( KeySym keysym )
         case GDK_F11:           key_code = WXK_F11;         break;
         case GDK_F12:           key_code = WXK_F12;         break;
         default:
         case GDK_F11:           key_code = WXK_F11;         break;
         case GDK_F12:           key_code = WXK_F12;         break;
         default:

-        {
-            if (keysym <= 0xFF)
+            if (event->length == 1)
+            {
+                key_code = (unsigned char)*event->string;
+            }
+            else if ((keysym & 0xFF) == keysym)

             {
                 key_code = (guint)keysym;
             }
             {
                 key_code = (guint)keysym;
             }

-        }

     }
 
     }
 

-    return (key_code);
+    return key_code;
+}
+
+//-----------------------------------------------------------------------------
+// "size_request" of m_widget
+//-----------------------------------------------------------------------------
+
+static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition *requisition, wxWindow *win )
+{
+    int w,h;
+    win->GetSize( &w, &h );
+    if (w < 2) w = 2;
+    if (h < 2) h = 2;
+
+    requisition->height = h;
+    requisition->width = w;

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

-static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
+static int gtk_window_expose_callback( GtkWidget *widget,
+                                       GdkEventExpose *gdk_event,
+                                       wxWindow *win )

 {
 {

-    if (!win->m_hasVMT)
-        return;
+    DEBUG_MAIN_THREAD
+
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+/*
+    if (win->GetName() == wxT("panel"))
+    {
+        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 );
+    }
+*/
+
+    GtkPizza *pizza = GTK_PIZZA (widget);
+
+    if (win->GetThemeEnabled())
+    {
+        wxWindow *parent = win->GetParent();
+        while (parent && !parent->IsTopLevel())
+            parent = parent->GetParent();
+        if (!parent)
+            parent = win;
+
+        gtk_paint_flat_box (parent->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+            GTK_SHADOW_NONE, &gdk_event->area, parent->m_widget, "base", 0, 0, -1, -1);
+    }

 
     win->GetUpdateRegion().Union( gdk_event->area.x,
                                   gdk_event->area.y,
                                   gdk_event->area.width,
                                   gdk_event->area.height );
 
 
     win->GetUpdateRegion().Union( gdk_event->area.x,
                                   gdk_event->area.y,
                                   gdk_event->area.width,
                                   gdk_event->area.height );
 

-    if (gdk_event->count > 0)
-        return;
+    if (gdk_event->count == 0)
+    {
+        win->m_clipPaintRegion = TRUE;
+
+        wxWindowDC dc(win);
+        dc.SetClippingRegion(win->GetUpdateRegion());
+        wxEraseEvent eevent( win->GetId(), &dc );
+        eevent.SetEventObject( win );
+#if 1
+        (void)win->GetEventHandler()->ProcessEvent(eevent);
+#else // 0
+        if (!win->GetEventHandler()->ProcessEvent(eevent))
+        {
+            wxClientDC dc( win );
+            dc.SetBrush( wxBrush( win->GetBackgroundColour(), wxSOLID ) );
+            dc.SetPen( *wxTRANSPARENT_PEN );

 
 

-/*
-    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 );
-*/
+            wxRegionIterator upd( win->GetUpdateRegion() );
+            while (upd)
+            {
+                dc.DrawRectangle( upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
+                upd ++;
+            }
+        }
+#endif // 1/0

 
 

-    wxEraseEvent eevent( win->GetId() );
-    eevent.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent(eevent);
+        wxNcPaintEvent eventNc( win->GetId() );
+        eventNc.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( eventNc );

 
 

-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+        wxPaintEvent event( win->GetId() );
+        event.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( event );

 
 

-    win->GetUpdateRegion().Clear();
+        win->GetUpdateRegion().Clear();
+
+        win->m_clipPaintRegion = FALSE;
+    }
+
+    /* The following code will result in all window-less widgets
+       being redrawn if the wxWindows class is given a chance to
+       paint *anything* because it will then be allowed to paint
+       over the window-less widgets */
+    GList *children = pizza->children;
+    while (children)
+    {
+        GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+        children = children->next;
+
+        GdkEventExpose child_event = *gdk_event;
+
+        if (GTK_WIDGET_NO_WINDOW (child->widget) &&
+            GTK_WIDGET_DRAWABLE (child->widget) /* &&
+            gtk_widget_intersect (child->widget, &gdk_event->area, &child_event.area)*/ )
+        {
+            child_event.area.x = child->widget->allocation.x;
+            child_event.area.y = child->widget->allocation.y;
+            child_event.area.width = child->widget->allocation.width;
+            child_event.area.height = child->widget->allocation.height;
+            gtk_widget_event (child->widget, (GdkEvent*) &child_event);
+        }
+    }
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "event" of m_wxwindow
+//-----------------------------------------------------------------------------
+
+/* GTK thinks it is clever and filters out a certain amount of "unneeded"
+   expose events. We need them, of course, so we override the main event
+   procedure in GtkWidget by giving our own handler for all system events.
+   There, we look for expose events ourselves whereas all other events are
+   handled normally. */
+
+gint gtk_window_event_event_callback( GtkWidget *widget,
+                                      GdkEventExpose *event,
+                                      wxWindow *win )
+{
+    if (event->type == GDK_EXPOSE)
+    {
+        gint ret = gtk_window_expose_callback( widget, event, win );
+        return ret;
+    }
+
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 

-static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget),
-                                      GdkRectangle *rect, wxWindow *win )
+/* This callback is a complete replacement of the gtk_pizza_draw() function,
+   which disabled. */
+
+static void gtk_window_draw_callback( GtkWidget *widget,
+                                      GdkRectangle *rect,
+                                      wxWindow *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 

-    if (!win->m_hasVMT)
+    if ((win->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) &&
+        (win->GetChildren().GetCount() == 0))
+    {

         return;
         return;

-
-    win->GetUpdateRegion().Union( rect->x, rect->y,
-                                  rect->width, rect->height );
+    }

 
 /*
 
 /*

-    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 );
+    if (win->GetName() == wxT("panel"))
+    {
+        wxPrintf( wxT("OnDraw from ") );
+        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+            wxPrintf( win->GetClassInfo()->GetClassName() );
+        wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
+                                         (int)rect->y,
+                                         (int)rect->width,
+                                         (int)rect->height );
+    }

 */
 
 */
 

-    wxEraseEvent eevent( win->GetId() );
+    GtkPizza *pizza = GTK_PIZZA (widget);
+
+    if (win->GetThemeEnabled())
+    {
+        wxWindow *parent = win->GetParent();
+        while (parent && !parent->IsTopLevel())
+            parent = parent->GetParent();
+        if (!parent)
+            parent = win;
+
+        gtk_paint_flat_box (parent->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+            GTK_SHADOW_NONE, rect, parent->m_widget, "base", 0, 0, -1, -1);
+    }
+
+
+    if (!(GTK_WIDGET_APP_PAINTABLE (widget)) &&
+         (pizza->clear_on_draw))
+    {
+        gdk_window_clear_area( pizza->bin_window,
+                               rect->x, rect->y, rect->width, rect->height);
+    }
+
+    win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
+
+    win->m_clipPaintRegion = TRUE;
+
+    wxWindowDC dc(win);
+    dc.SetClippingRegion(win->GetUpdateRegion());
+    wxEraseEvent eevent( win->GetId(), &dc );

     eevent.SetEventObject( win );
     eevent.SetEventObject( win );

-    win->GetEventHandler()->ProcessEvent(eevent);
+
+#if 1
+    (void)win->GetEventHandler()->ProcessEvent(eevent);
+#else
+    if (!win->GetEventHandler()->ProcessEvent(eevent))
+    {
+        if (!win->GetEventHandler()->ProcessEvent(eevent))
+        {
+            wxClientDC dc( win );
+            dc.SetBrush( wxBrush( win->GetBackgroundColour(), wxSOLID ) );
+            dc.SetPen( *wxTRANSPARENT_PEN );
+
+            wxRegionIterator upd( win->GetUpdateRegion() );
+            while (upd)
+            {
+                dc.DrawRectangle( upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
+                upd ++;
+            }
+        }
+    }
+#endif
+
+    wxNcPaintEvent eventNc( win->GetId() );
+    eventNc.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( eventNc );

 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetUpdateRegion().Clear();
 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetUpdateRegion().Clear();

+
+    win->m_clipPaintRegion = FALSE;
+
+
+    GList *children = pizza->children;
+    while (children)
+    {
+            GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+            children = children->next;
+
+            GdkRectangle child_area;
+            if (gtk_widget_intersect (child->widget, rect, &child_area))
+            {
+                gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
+            }
+    }

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

-static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+// turn on to see the key event codes on the console
+#undef DEBUG_KEY_EVENTS
+
+static gint gtk_window_key_press_callback( GtkWidget *widget,
+                                           GdkEventKey *gdk_event,
+                                           wxWindow *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     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;
     int x = 0;
     int y = 0;
     GdkModifierType state;

-    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+    if (gdk_event->window)
+        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);

 
     bool ret = FALSE;
 
 
     bool ret = FALSE;
 

-    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+    long key_code = map_to_unmodified_wx_keysym( gdk_event );
+
+#ifdef DEBUG_KEY_EVENTS
+    wxPrintf(_T("Key press event: %d => %ld\n"), gdk_event->keyval, key_code);
+#endif // DEBUG_KEY_EVENTS
+

     /* sending unknown key events doesn't really make sense */
     /* sending unknown key events doesn't really make sense */

-    if (key_code == 0) return FALSE;
+    if (key_code == 0)
+        return FALSE;

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


@@ -705,7 +1051,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 #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 );


@@ -715,54 +1061,57 @@ 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->m_isFrame)
+            if (ancestor->IsTopLevel())

                 break;
             ancestor = ancestor->GetParent();
         }
     }
 #endif // wxUSE_ACCEL
 
                 break;
             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 in an accelerator table. */
     /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
        will only be sent if it is not in an accelerator table. */

-    key_code = map_to_wx_keysym( gdk_event->keyval );
+    if ( !ret )
+    {
+        key_code = map_to_wx_keysym( gdk_event );

 
 

-    if ( (!ret) &&
-         (key_code != 0))
-    {
-        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 = win->GetEventHandler()->ProcessEvent( event2 );
+        if ( key_code )
+        {
+#ifdef DEBUG_KEY_EVENTS
+            wxPrintf(_T("Char event: %ld\n"), key_code);
+#endif // DEBUG_KEY_EVENTS
+
+            // reuse the ame event object, just change its type and use the
+            // translated keycode instead of the raw one
+            event.SetEventType(wxEVT_CHAR);
+            event.m_keyCode = key_code;
+
+            ret = win->GetEventHandler()->ProcessEvent( event );
+        }

     }
 
     /* win is a control: tab can be propagated up */
     }
 
     /* win is a control: tab can be propagated up */

-    if ( (!ret) &&
+    if ( !ret &&

          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&

-         (!win->HasFlag(wxTE_PROCESS_TAB)) &&
-         (win->GetParent()) &&
-         (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
+// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
+//     have this style, yet choose not to process this particular TAB in which
+//     case TAB must still work as a navigational character
+#if 0
+         !win->HasFlag(wxTE_PROCESS_TAB) &&
+#endif // 0
+         win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )

     {
         wxNavigationKeyEvent new_event;
     {
         wxNavigationKeyEvent new_event;

-        new_event.SetEventObject( win );
+        new_event.SetEventObject( win->GetParent() );

         /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
         /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
         new_event.SetCurrentFocus( win );
         /* 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 );
+        ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );

     }
 
     /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
     }
 
     /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */

-    if ( (!ret) &&
+    if ( !ret &&

          (gdk_event->keyval == GDK_Escape) )
     {
         wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
          (gdk_event->keyval == GDK_Escape) )
     {
         wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);


@@ -770,14 +1119,13 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 

-#if (GTK_MINOR_VERSION > 0)
-    /* Pressing F10 will activate the menu bar of the top frame. */

     /* Doesn't work. */
     /* Doesn't work. */

-/*
+#if 0 // (GTK_MINOR_VERSION > 0)
+    /* Pressing F10 will activate the menu bar of the top frame. */

     if ( (!ret) &&
          (gdk_event->keyval == GDK_F10) )
     {
     if ( (!ret) &&
          (gdk_event->keyval == GDK_F10) )
     {

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

         while (ancestor)
         {
             if (wxIsKindOf(ancestor,wxFrame))
         while (ancestor)
         {
             if (wxIsKindOf(ancestor,wxFrame))


@@ -799,8 +1147,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
             ancestor = ancestor->GetParent();
         }
     }
             ancestor = ancestor->GetParent();
         }
     }

-*/
-#endif
+#endif // 0

 
     if (ret)
     {
 
     if (ret)
     {


@@ -815,28 +1162,21 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 // "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 )
+static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) 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" );
-*/
+    long key_code = map_to_unmodified_wx_keysym( gdk_event );

 
 

-    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+#ifdef DEBUG_KEY_EVENTS
+    wxPrintf(_T("Key release event: %d => %ld\n"), gdk_event->keyval, key_code);
+#endif // DEBUG_KEY_EVENTS

 
     /* sending unknown key events doesn't really make sense */
     if (key_code == 0) return FALSE;
 
     /* sending unknown key events doesn't really make sense */
     if (key_code == 0) return FALSE;


@@ -844,7 +1184,8 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     int x = 0;
     int y = 0;
     GdkModifierType state;
     int x = 0;
     int y = 0;
     GdkModifierType state;

-    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+    if (gdk_event->window)
+        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);

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


@@ -867,12 +1208,50 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     return FALSE;
 }
 
     return FALSE;
 }
 

+// ----------------------------------------------------------------------------
+// mouse event processing helper
+// ----------------------------------------------------------------------------
+
+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 ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
+        (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
+        (event.GetEventType() == wxEVT_RIGHT_UP))
+    {
+        event.m_rightDown = !event.m_rightDown;
+        return;
+    }
+}
+

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

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

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -904,7 +1283,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         }
     }
 
         }
     }
 

-    wxEventType event_type = wxEVT_LEFT_DOWN;
+    wxEventType event_type = wxEVT_NULL;

 
     if (gdk_event->button == 1)
     {
 
     if (gdk_event->button == 1)
     {


@@ -934,6 +1313,12 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         }
     }
 
         }
     }
 

+    if ( event_type == wxEVT_NULL )
+    {
+        // unknown mouse button or click type
+        return FALSE;
+    }
+

     wxMouseEvent event( event_type );
     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     wxMouseEvent event( event_type );
     event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);


@@ -944,8 +1329,18 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_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;
+    event.m_x = (wxCoord)gdk_event->x;
+    event.m_y = (wxCoord)gdk_event->y;
+
+    AdjustEventButtonState(event);
+    
+    // wxListBox actually get mouse events from the item
+    
+    if (win->m_isListBox)
+    {
+        event.m_x += widget->allocation.x;
+        event.m_y += widget->allocation.y;
+    }

 
     // Some control don't have their own X window and thus cannot get
     // any events.
 
     // Some control don't have their own X window and thus cannot get
     // any events.


@@ -964,7 +1359,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         wxNode *node = win->GetChildren().First();
         while (node)
         {
         wxNode *node = win->GetChildren().First();
         while (node)
         {

-            wxWindow *child = (wxWindow*)node->Data();
+            wxWindowGTK *child = (wxWindowGTK*)node->Data();

 
             node = node->Next();
             if (!child->IsShown())
 
             node = node->Next();
             if (!child->IsShown())


@@ -1035,8 +1430,10 @@ 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 gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1060,6 +1457,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         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: return FALSE;

     }
 
     wxMouseEvent event( event_type );
     }
 
     wxMouseEvent event( event_type );


@@ -1071,8 +1469,18 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     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_x = (long)gdk_event->x;
-    event.m_y = (long)gdk_event->y;
+    event.m_x = (wxCoord)gdk_event->x;
+    event.m_y = (wxCoord)gdk_event->y;
+
+    AdjustEventButtonState(event);
+
+    // wxListBox actually get mouse events from the item
+    
+    if (win->m_isListBox)
+    {
+        event.m_x += widget->allocation.x;
+        event.m_y += widget->allocation.y;
+    }

 
     // Some control don't have their own X window and thus cannot get
     // any events.
 
     // Some control don't have their own X window and thus cannot get
     // any events.


@@ -1091,7 +1499,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         wxNode *node = win->GetChildren().First();
         while (node)
         {
         wxNode *node = win->GetChildren().First();
         while (node)
         {

-            wxWindow *child = (wxWindow*)node->Data();
+            wxWindowGTK *child = (wxWindowGTK*)node->Data();

 
             node = node->Next();
             if (!child->IsShown())
 
             node = node->Next();
             if (!child->IsShown())


@@ -1149,12 +1557,34 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     return FALSE;
 }
 
     return FALSE;
 }
 

+// ============================================================================
+// the mouse events
+// ============================================================================
+
+// init wxMouseEvent with the info from gdk_event
+#define InitMouseEvent(event, gdk_event) \
+    event.SetTimestamp( gdk_event->time ); \
+    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
+    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
+    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
+    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
+    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
+\
+    event.m_x = (wxCoord)gdk_event->x; \
+    event.m_y = (wxCoord)gdk_event->y \
+

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

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

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1182,23 +1612,30 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 */
 
     wxMouseEvent event( wxEVT_MOTION );
 */
 
     wxMouseEvent event( wxEVT_MOTION );

-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    InitMouseEvent(event, gdk_event);

 
 

-    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)
+    if ( g_captureWindow )

     {
     {

+        // synthetize a mouse enter or leave event if needed
+        GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+        bool hasMouse = winUnderMouse == gdk_event->window;
+        if ( hasMouse != g_captureWindowHasMouse )
+        {
+            // the mouse changed window
+            g_captureWindowHasMouse = hasMouse;
+
+            wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
+                                                       : wxEVT_LEAVE_WINDOW);
+            InitMouseEvent(event, gdk_event);
+            event.SetEventObject(win);
+            win->GetEventHandler()->ProcessEvent(event);
+        }
+    }
+    else // no capture
+    {
+        // Some control don't have their own X window and thus cannot get
+        // any events.
+

         wxCoord x = event.m_x;
         wxCoord y = event.m_y;
         if (win->m_wxwindow)
         wxCoord x = event.m_x;
         wxCoord y = event.m_y;
         if (win->m_wxwindow)


@@ -1211,7 +1648,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         wxNode *node = win->GetChildren().First();
         while (node)
         {
         wxNode *node = win->GetChildren().First();
         while (node)
         {

-            wxWindow *child = (wxWindow*)node->Data();
+            wxWindowGTK *child = (wxWindowGTK*)node->Data();

 
             node = node->Next();
             if (!child->IsShown())
 
             node = node->Next();
             if (!child->IsShown())


@@ -1273,8 +1710,12 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 

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

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1284,7 +1725,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
     switch ( g_sendActivateEvent )
     {
         case -1:
     switch ( g_sendActivateEvent )
     {
         case -1:

-            // we've got focus from outside, synthtize wxActivateEvent
+            // we've got focus from outside, synthetize wxActivateEvent

             g_sendActivateEvent = 1;
             break;
 
             g_sendActivateEvent = 1;
             break;
 


@@ -1295,32 +1736,65 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
             break;
     }
 
             break;
     }
 

+    g_focusWindowLast =

     g_focusWindow = win;
 
     g_focusWindow = win;
 

-/*
-    printf( "OnSetFocus from " );
+#if 0
+    wxPrintf( "OnSetFocus from " );

     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())

-        printf( win->GetClassInfo()->GetClassName() );
-    printf( "   " );
-    printf( WXSTRINGCAST win->GetLabel() );
-    printf( ".\n" );
-*/
+        wxPrintf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( ".\n" );
+#endif
+
+    // notify the parent keeping track of focus for the kbd navigation
+    // purposes that we got it
+    wxChildFocusEvent eventFocus(win);
+    (void)win->GetEventHandler()->ProcessEvent(eventFocus);

 
 

-    wxPanel *panel = wxDynamicCast(win->GetParent(), wxPanel);
-    if (panel)
+#ifdef HAVE_XIM
+    if (win->m_ic)
+        gdk_im_begin(win->m_ic, win->m_wxwindow->window);
+#endif
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = win->GetCaret();
+    if ( caret )

     {
     {

-        panel->SetLastFocus(win);
+        caret->OnSetFocus();
+    }
+#endif // wxUSE_CARET
+
+    wxWindowGTK *active = wxGetTopLevelParent(win);
+    if ( active != g_activeFrame )
+    {
+        if ( g_activeFrame )
+        {
+            wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
+            wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
+            event.SetEventObject(g_activeFrame);
+            g_activeFrame->GetEventHandler()->ProcessEvent(event);
+        }
+
+        wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
+        g_activeFrame = active;
+        wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
+        event.SetEventObject(g_activeFrame);
+        g_activeFrame->GetEventHandler()->ProcessEvent(event);

     }
     }

+    g_activeFrameLostFocus = FALSE;
+

 
     wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
 
     wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {

-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
-        return TRUE;
+       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
+       return TRUE;

     }
 
     }
 

+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -1328,27 +1802,74 @@ 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 GtkWidget *gs_widgetLastFocus = NULL;
+
+static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

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

+    // VZ: this is really weird but GTK+ seems to call us from inside
+    //     gtk_widget_grab_focus(), i.e. it first sends "focus_out" signal to
+    //     this widget and then "focus_in". This is totally unexpected and
+    //     completely breaks wxUniv code so ignore this dummy event (we can't
+    //     be losing focus if we're about to acquire it!)
+    if ( widget == gs_widgetLastFocus )
+    {
+        gs_widgetLastFocus = NULL;
+
+        return FALSE;
+    }
+
+    if ( !g_activeFrameLostFocus && g_activeFrame )
+    {
+        // VZ: commenting this out because it does happen (although not easy
+        //     to reproduce, I only see it when using wxMiniFrame and not
+        //     always) and makes using Mahogany quite annoying
+#if 0
+        wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
+                        wxT("unfocusing window that hasn't gained focus properly") )
+#endif // 0
+
+        g_activeFrameLostFocus = TRUE;
+    }
+

     // if the focus goes out of our app alltogether, OnIdle() will send
     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
     // g_sendActivateEvent to -1
     g_sendActivateEvent = 0;
 
     // if the focus goes out of our app alltogether, OnIdle() will send
     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
     // g_sendActivateEvent to -1
     g_sendActivateEvent = 0;
 

-    g_focusWindow = (wxWindow *)NULL;
+    wxWindowGTK *winFocus = wxFindFocusedChild(win);
+    if ( winFocus )
+        win = winFocus;

 
 

-/*
-    printf( "OnKillFocus from " );
+    g_focusWindow = (wxWindowGTK *)NULL;
+
+#if 0
+    wxPrintf( "OnKillFocus from " );

     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())

-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+        wxPrintf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( ".\n" );
+#endif
+
+#ifdef HAVE_XIM
+    if (win->m_ic)
+        gdk_im_end();
+#endif
+
+#if wxUSE_CARET
+    // caret needs to be informed about focus change
+    wxCaret *caret = win->GetCaret();
+    if ( caret )
+    {
+        caret->OnKillFocus();
+    }
+#endif // wxUSE_CARET

 
     wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
     event.SetEventObject( win );
 
     wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
     event.SetEventObject( win );


@@ -1366,8 +1887,10 @@ 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 gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1377,9 +1900,7 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_ENTER_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;


@@ -1388,16 +1909,10 @@ 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);
+    InitMouseEvent(event, gdk_event);

 
 

-    event.m_x = (long)x;
-    event.m_y = (long)y;
+    event.m_x = x;
+    event.m_y = y;

 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {


@@ -1412,8 +1927,10 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 // "leave_notify_event"
 //-----------------------------------------------------------------------------
 
 // "leave_notify_event"
 //-----------------------------------------------------------------------------
 

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

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1423,9 +1940,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     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;


@@ -1442,8 +1957,8 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     event.m_middleDown = (state & GDK_BUTTON2_MASK);
     event.m_rightDown = (state & GDK_BUTTON3_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;
+    event.m_x = x;
+    event.m_y = y;

 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {


@@ -1458,8 +1973,10 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 

-static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
+static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1492,8 +2009,10 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 

-static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
+static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 


@@ -1522,136 +2041,278 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

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

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

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

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     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);
+    g_blockEventsOnScroll = TRUE;
+    win->m_isScrolling = (gdk_event->window == widget->slider);

 
 

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

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

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

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

-static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
+                                                   GdkEventButton *WXUNUSED(gdk_event),
+                                                   wxWindowGTK *win)

 {
 {

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

 
 

-    if (g_blockEventsOnDrag) return;
-    if (!win->m_hasVMT) 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;

 
 

-    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
-    int value = (int)(win->m_hAdjust->value+0.5);
+    g_blockEventsOnScroll = FALSE;

 
 

-    wxScrollWinEvent event( command, value, wxHORIZONTAL );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    if (win->m_isScrolling)
+    {
+        wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
+        int value = -1;
+        int dir = -1;
+
+        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
+        if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
+        {
+            value = (int)(win->m_hAdjust->value+0.5);
+            dir = wxHORIZONTAL;
+        }
+        if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
+        {
+            value = (int)(win->m_vAdjust->value+0.5);
+            dir = wxVERTICAL;
+        }
+
+        wxScrollWinEvent event( command, value, dir );
+        event.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( event );
+    }
+
+    win->m_isScrolling = FALSE;
+
+    return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// this wxWindowBase function is implemented here (in platform-specific file)
+// because it is static and so couldn't be made virtual
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::FindFocus()
+{
+    // the cast is necessary when we compile in wxUniversal mode
+    return (wxWindow *)g_focusWindow;

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

-// "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 )
+/* 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(m_widget), wxWindow *win )

 {
 {

+    DEBUG_MAIN_THREAD
+

     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 

-//  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_delayedBackgroundColour)
+        win->SetBackgroundColour( win->GetBackgroundColour() );
+
+    if (win->m_delayedForegroundColour)
+        win->SetForegroundColour( win->GetForegroundColour() );

 
 

-    win->SetScrolling( TRUE );
+    wxWindowCreateEvent event( win );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );

 
     return FALSE;
 }
 
 //-----------------------------------------------------------------------------
 
     return FALSE;
 }
 
 //-----------------------------------------------------------------------------

-// "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 *WXUNUSED(alloc),
+                               wxWindow *win )

 {
 {

+    if (g_isIdle)
+        wxapp_install_idle_handler();

 
 

-//  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_hasScrolling) return;

 
 

-    win->SetScrolling( FALSE );
+    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;

 
 

-    return FALSE;
+    win->m_oldClientWidth = client_width;
+    win->m_oldClientHeight = client_height;
+
+    if (!win->m_nativeSizeEvent)
+    {
+        wxSizeEvent event( win->GetSize(), win->GetId() );
+        event.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( event );
+    }

 }
 
 }
 

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

 
 

-wxWindow *wxWindowBase::FindFocus()
+#ifdef HAVE_XIM
+    #define WXUNUSED_UNLESS_XIM(param)  param
+#else
+    #define WXUNUSED_UNLESS_XIM(param)  WXUNUSED(param)
+#endif
+
+/* Resize XIM window */
+
+static
+void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
+                                 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
+                                 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )

 {
 {

-    return g_focusWindow;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+#ifdef HAVE_XIM
+    if (!win->m_ic)
+        return;
+
+    if  (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
+    {
+        gint width, height;
+
+        gdk_window_get_size (widget->window, &width, &height);
+        win->m_icattr->preedit_area.width = width;
+        win->m_icattr->preedit_area.height = height;
+        gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
+    }
+#endif // HAVE_XIM

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

-// "realize" from m_widget
+// "realize" from m_wxwindow

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

-/* we cannot set colours and fonts before the widget has
-   been realized, so we do this directly after realization */
+/* Initialize XIM support */
+
+static gint
+gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
+                                wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
+{
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+#ifdef HAVE_XIM
+    if (win->m_ic) return FALSE;
+    if (!widget) return FALSE;
+    if (!gdk_im_ready()) return FALSE;
+
+    win->m_icattr = gdk_ic_attr_new();
+    if (!win->m_icattr) return FALSE;
+
+    gint width, height;
+    GdkEventMask mask;
+    GdkColormap *colormap;
+    GdkICAttr *attr = win->m_icattr;
+    unsigned attrmask = GDK_IC_ALL_REQ;
+    GdkIMStyle style;
+    GdkIMStyle supported_style = (GdkIMStyle)
+                                  (GDK_IM_PREEDIT_NONE |
+                                   GDK_IM_PREEDIT_NOTHING |
+                                   GDK_IM_PREEDIT_POSITION |
+                                   GDK_IM_STATUS_NONE |
+                                   GDK_IM_STATUS_NOTHING);
+
+    if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
+        supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
+
+    attr->style = style = gdk_im_decide_style (supported_style);
+    attr->client_window = widget->window;
+
+    if ((colormap = gtk_widget_get_colormap (widget)) !=
+            gtk_widget_get_default_colormap ())
+    {
+        attrmask |= GDK_IC_PREEDIT_COLORMAP;
+        attr->preedit_colormap = colormap;
+    }
+
+    attrmask |= GDK_IC_PREEDIT_FOREGROUND;
+    attrmask |= GDK_IC_PREEDIT_BACKGROUND;
+    attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
+    attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
+
+    switch (style & GDK_IM_PREEDIT_MASK)
+    {
+        case GDK_IM_PREEDIT_POSITION:
+            if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
+            {
+                g_warning ("over-the-spot style requires fontset");
+                break;
+            }
+
+            gdk_window_get_size (widget->window, &width, &height);

 
 

-static gint
-gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
-{
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+            attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
+            attr->spot_location.x = 0;
+            attr->spot_location.y = height;
+            attr->preedit_area.x = 0;
+            attr->preedit_area.y = 0;
+            attr->preedit_area.width = width;
+            attr->preedit_area.height = height;
+            attr->preedit_fontset = widget->style->font;

 
 

-    if (win->m_delayedFont)
-        win->SetFont( win->GetFont() );
+            break;
+    }

 
 

-    if (win->m_delayedBackgroundColour)
-        win->SetBackgroundColour( win->GetBackgroundColour() );
+      win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);

 
 

-    if (win->m_delayedForegroundColour)
-        win->SetForegroundColour( win->GetForegroundColour() );
+      if (win->m_ic == NULL)
+          g_warning ("Can't create input context.");
+      else
+      {
+          mask = gdk_window_get_events (widget->window);
+          mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
+          gdk_window_set_events (widget->window, mask);

 
 

-    wxWindowCreateEvent event( win );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+          if (GTK_WIDGET_HAS_FOCUS(widget))
+              gdk_im_begin (win->m_ic, widget->window);
+      }
+#endif // HAVE_XIM

 
     return FALSE;
 }
 
 //-----------------------------------------------------------------------------
 
     return FALSE;
 }
 
 //-----------------------------------------------------------------------------

-// 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 */


@@ -1671,18 +2332,25 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 // global functions
 //-----------------------------------------------------------------------------
 
 // global functions
 //-----------------------------------------------------------------------------
 

-wxWindow* wxGetActiveWindow()
+wxWindow *wxGetActiveWindow()

 {
 {

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

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

-// 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();
 {
     // common init
     InitBase();


@@ -1690,6 +2358,7 @@ void wxWindow::Init()
     // 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;


@@ -1704,7 +2373,7 @@ void wxWindow::Init()
 
     m_noExpose = FALSE;
     m_nativeSizeEvent = FALSE;
 
     m_noExpose = FALSE;
     m_nativeSizeEvent = FALSE;

-
+    

     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
 


@@ -1720,34 +2389,51 @@ void wxWindow::Init()
 
     m_isStaticBox = FALSE;
     m_isRadioButton = FALSE;
 
     m_isStaticBox = FALSE;
     m_isRadioButton = FALSE;

+    m_isListBox = FALSE;

     m_isFrame = FALSE;
     m_acceptsFocus = FALSE;
 
     m_isFrame = FALSE;
     m_acceptsFocus = FALSE;
 

+    m_clipPaintRegion = FALSE;
+

     m_cursor = *wxSTANDARD_CURSOR;
     m_cursor = *wxSTANDARD_CURSOR;

+
+    m_delayedForegroundColour = FALSE;
+    m_delayedBackgroundColour = FALSE;
+
+#ifdef HAVE_XIM
+    m_ic = (GdkIC*) NULL;
+    m_icattr = (GdkICAttr*) NULL;
+#endif

 }
 
 }
 

-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") );
+        wxFAIL_MSG( wxT("wxWindowGTK creation failed") );

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -1756,18 +2442,9 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     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);
 
     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 );
+    GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );

     scroll_class->scrollbar_spacing = 0;
 
     gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
     scroll_class->scrollbar_spacing = 0;
 
     gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );


@@ -1777,12 +2454,9 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     m_wxwindow = gtk_pizza_new();
 
 
     m_wxwindow = gtk_pizza_new();
 

-#ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
-#endif
-

     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 

+#ifndef __WXUNIVERSAL__

 #if (GTK_MINOR_VERSION > 0)
     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
 
 #if (GTK_MINOR_VERSION > 0)
     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
 


@@ -1818,6 +2492,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
 #endif // GTK_MINOR_VERSION
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
 #endif // GTK_MINOR_VERSION

+#endif // __WXUNIVERSAL__

 
     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
     m_acceptsFocus = TRUE;
 
     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
     m_acceptsFocus = TRUE;


@@ -1869,15 +2544,12 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
 
     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
 

-    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 );
-

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

+        
+    m_focusWidget = m_wxwindow;

 
     PostCreation();
 
 
     PostCreation();
 


@@ -1886,8 +2558,14 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     return TRUE;
 }
 
     return TRUE;
 }
 

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

 {
 {

+    if (g_focusWindow == this)
+        g_focusWindow = NULL;
+
+    if (g_activeFrame == this)
+        g_activeFrame = NULL;
+

     m_isBeingDeleted = TRUE;
     m_hasVMT = FALSE;
 
     m_isBeingDeleted = TRUE;
     m_hasVMT = FALSE;
 


@@ -1899,9 +2577,20 @@ wxWindow::~wxWindow()
     if (m_parent)
         m_parent->RemoveChild( this );
 
     if (m_parent)
         m_parent->RemoveChild( this );
 

+#ifdef HAVE_XIM
+    if (m_ic)
+        gdk_ic_destroy (m_ic);
+    if (m_icattr)
+        gdk_ic_attr_destroy (m_icattr);
+#endif
+

     if (m_widgetStyle)
     {
     if (m_widgetStyle)
     {

-        gtk_style_unref( m_widgetStyle );
+#if DISABLE_STYLE_IF_BROKEN_THEME
+        // don't delete if it's a pixmap theme style
+        if (!m_widgetStyle->engine_data)
+            gtk_style_unref( m_widgetStyle );
+#endif

         m_widgetStyle = (GtkStyle*) NULL;
     }
 
         m_widgetStyle = (GtkStyle*) NULL;
     }
 


@@ -1918,7 +2607,7 @@ 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.") );
 
 {
     wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
 


@@ -1950,45 +2639,97 @@ bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize
     return TRUE;
 }
 
     return TRUE;
 }
 

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

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

-
+    

     if (m_wxwindow)
     {
         if (!m_noExpose)
         {
     if (m_wxwindow)
     {
         if (!m_noExpose)
         {

-            /* these get reported to wxWindows -> wxPaintEvent */
+            // these get reported to wxWindows -> wxPaintEvent
+
+            gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
+

             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 );
             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 (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
+            {
+                gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
+                    GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
+            }

         }
 
         }
 

-#if (GTK_MINOR_VERSION > 0)
-        /* these are called when the "sunken" or "raised" borders are drawn */
+        // 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 );
         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

     }
 
     }
 

+    // focus handling
+
+    if (m_focusWidget == NULL)
+        m_focusWidget = m_widget;
+
+#if 0
+    if (GetClassInfo() && GetClassInfo()->GetClassName())
+        wxPrintf( GetClassInfo()->GetClassName() );
+    wxPrintf( ".\n" );
+#endif
+
+    gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
+        GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
+
+    gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
+         GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)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 */
     gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
                             GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
 
        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 );
 

+    if (m_wxwindow)
+    {
+        // Catch native resize events
+        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
+                            GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
+
+        // Initialize XIM support
+        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
+                            GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
+
+        // And resize XIM window
+        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
+                            GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
+    }
+
+    if (!GTK_IS_COMBO(m_widget))
+    {
+        // This is needed if we want to add our windows into native
+        // GTK control, 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. FIXME
+        // when moving to GTK 2.0.
+        gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
+                            GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this );
+    }
+

     m_hasVMT = TRUE;
 }
 
     m_hasVMT = TRUE;
 }
 

-void wxWindow::ConnectWidget( GtkWidget *widget )
+void wxWindowGTK::ConnectWidget( GtkWidget *widget )

 {
     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
 {
     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );


@@ -2005,12 +2746,6 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
 

-    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
-      GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
-      GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
-

     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
 


@@ -2018,7 +2753,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
 }
 
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
 }
 

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

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


@@ -2027,14 +2762,31 @@ bool wxWindow::Destroy()
     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)
+{
+    gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
+}
+
+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") );
+
+/*
+    printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
+*/

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

+    int currentX, currentY;
+    GetPosition(&currentX, &currentY);
+    if (x == -1)
+        x = currentX;
+    if (y == -1)
+        y = currentY;
+    AdjustForParentClientOrigin(x, y, sizeFlags);
+

     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
     {
         /* don't set the size for children of wxNotebook, just take the values. */
     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
     {
         /* don't set the size for children of wxNotebook, just take the values. */


@@ -2087,12 +2839,21 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
             bottom_border = 5;
         }
 
             bottom_border = 5;
         }
 

-        gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow),
-                              m_widget,
-                              m_x-border,
-                              m_y-border,
-                              m_width+2*border,
-                              m_height+border+bottom_border );
+        DoMoveWindow( m_x-border,
+                      m_y-border,
+                      m_width+2*border,
+                      m_height+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 );

     }
 
 /*
     }
 
 /*


@@ -2112,7 +2873,7 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
     m_resizing = FALSE;
 }
 

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

 {
     if ( g_sendActivateEvent != -1 )
     {
 {
     if ( g_sendActivateEvent != -1 )
     {


@@ -2121,10 +2882,20 @@ void wxWindow::OnInternalIdle()
         // do it only once
         g_sendActivateEvent = -1;
 
         // do it only once
         g_sendActivateEvent = -1;
 

-        wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
-        event.SetEventObject(this);
+        wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
+    }

 
 

-        (void)GetEventHandler()->ProcessEvent(event);
+    if ( g_activeFrameLostFocus )
+    {
+        if ( g_activeFrame )
+        {
+            wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
+            wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
+            event.SetEventObject(g_activeFrame);
+            g_activeFrame->GetEventHandler()->ProcessEvent(event);
+            g_activeFrame = NULL;
+        }
+        g_activeFrameLostFocus = FALSE;

     }
 
     wxCursor cursor = m_cursor;
     }
 
     wxCursor cursor = m_cursor;


@@ -2164,7 +2935,7 @@ void wxWindow::OnInternalIdle()
     UpdateWindowUI();
 }
 
     UpdateWindowUI();
 }
 

-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") );
 


@@ -2172,7 +2943,7 @@ 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") );
 


@@ -2185,24 +2956,7 @@ void wxWindow::DoSetClientSize( int width, int height )
         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
+#ifndef __WXUNIVERSAL__

         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
             /* when using GTK 1.2 we set the shadow border size to 2 */
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
             /* when using GTK 1.2 we set the shadow border size to 2 */


@@ -2215,38 +2969,44 @@ void wxWindow::DoSetClientSize( int width, int height )
             dw += 1 * 2;
             dh += 1 * 2;
         }
             dw += 1 * 2;
             dh += 1 * 2;
         }

-#endif
+#endif // __WXUNIVERSAL__

 
 

-        if (HasScrolling())
+        if (m_hasScrolling)

         {
         {

-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);

 
 

-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
+            GtkRequisition vscroll_req;
+            vscroll_req.width = 2;
+            vscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
+                (scroll_window->vscrollbar, &vscroll_req );

 
 

-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+            GtkRequisition hscroll_req;
+            hscroll_req.width = 2;
+            hscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
+                (scroll_window->hscrollbar, &hscroll_req );
+
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );

 
             if (scroll_window->vscrollbar_visible)
             {
 
             if (scroll_window->vscrollbar_visible)
             {

-                dw += 15;   /* dw += vscrollbar->allocation.width; */
+                dw += vscroll_req.width;

                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {
                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {

-                dh += 15;   /* dh += hscrollbar->allocation.height; */
+                dh += hscroll_req.height;

                 dh += scroll_class->scrollbar_spacing;
             }
                 dh += scroll_class->scrollbar_spacing;
             }

-       }
+        }

 
        SetSize( width+dw, height+dh );
     }
 }
 
 
        SetSize( width+dw, height+dh );
     }
 }
 

-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") );
 


@@ -2260,24 +3020,7 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
         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
+#ifndef __WXUNIVERSAL__

         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
             /* when using GTK 1.2 we set the shadow border size to 2 */
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
             /* when using GTK 1.2 we set the shadow border size to 2 */


@@ -2290,28 +3033,35 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
             dw += 1 * 2;
             dh += 1 * 2;
         }
             dw += 1 * 2;
             dh += 1 * 2;
         }

-#endif
-        if (HasScrolling())
+#endif // __WXUNIVERSAL__
+
+        if (m_hasScrolling)

         {
         {

-/*
-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);

 
 

-            we use this instead:  range.slider_width = 11 + 2*2pts edge
-*/
+            GtkRequisition vscroll_req;
+            vscroll_req.width = 2;
+            vscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
+                (scroll_window->vscrollbar, &vscroll_req );

 
 

-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+            GtkRequisition hscroll_req;
+            hscroll_req.width = 2;
+            hscroll_req.height = 2;
+            (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
+                (scroll_window->hscrollbar, &hscroll_req );
+
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );

 
             if (scroll_window->vscrollbar_visible)
             {
 
             if (scroll_window->vscrollbar_visible)
             {

-                dw += 15;   /* dw += vscrollbar->allocation.width; */
+                dw += vscroll_req.width;

                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {
                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {

-                dh += 15;   /* dh += hscrollbar->allocation.height; */
+                dh += hscroll_req.height;

                 dh += scroll_class->scrollbar_spacing;
             }
         }
                 dh += scroll_class->scrollbar_spacing;
             }
         }


@@ -2319,9 +3069,16 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
         if (width) (*width) = m_width - dw;
         if (height) (*height) = m_height - dh;
     }
         if (width) (*width) = m_width - dw;
         if (height) (*height) = m_height - dh;
     }

+
+/*
+    printf( "GetClientSize, name %s ", GetName().c_str() );
+    if (width) printf( " width = %d", (*width) );
+    if (height) printf( " height = %d", (*height) );
+    printf( "\n" );
+*/

 }
 
 }
 

-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") );
 


@@ -2333,12 +3090,12 @@ void wxWindow::DoGetPosition( int *x, int *y ) const
         dx = pizza->xoffset;
         dy = pizza->yoffset;
     }
         dx = pizza->xoffset;
         dy = pizza->yoffset;
     }

-
+    

     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") );
 


@@ -2367,7 +3124,7 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
     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") );
 


@@ -2396,7 +3153,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
     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") );
 


@@ -2414,7 +3171,24 @@ bool wxWindow::Show( bool show )
     return TRUE;
 }
 
     return TRUE;
 }
 

-bool wxWindow::Enable( bool enable )
+static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
+{
+    win->OnParentEnable(enable);
+
+    // Recurse, so that children have the opportunity to Do The Right Thing
+    // and reset colours that have been messed up by a parent's (really ancestor's)
+    // Enable call
+    for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxWindow *child = node->GetData();
+        if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
+            wxWindowNotifyEnable(child, enable);
+    }
+}
+
+bool wxWindowGTK::Enable( bool enable )

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


@@ -2428,10 +3202,12 @@ bool wxWindow::Enable( bool enable )
     if ( m_wxwindow )
         gtk_widget_set_sensitive( m_wxwindow, enable );
 
     if ( m_wxwindow )
         gtk_widget_set_sensitive( m_wxwindow, enable );
 

+    wxWindowNotifyEnable(this, enable);
+

     return TRUE;
 }
 
     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") );
 


@@ -2442,7 +3218,7 @@ int wxWindow::GetCharHeight() const
     return font->ascent + font->descent;
 }
 
     return font->ascent + font->descent;
 }
 

-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") );
 


@@ -2453,7 +3229,7 @@ int wxWindow::GetCharWidth() const
     return gdk_string_width( font, "H" );
 }
 
     return gdk_string_width( font, "H" );
 }
 

-void wxWindow::GetTextExtent( const wxString& string,
+void wxWindowGTK::GetTextExtent( const wxString& string,

                               int *x,
                               int *y,
                               int *descent,
                               int *x,
                               int *y,
                               int *descent,


@@ -2472,18 +3248,20 @@ void wxWindow::GetTextExtent( const wxString& string,
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 

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

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

-    
+

     if (m_wxwindow)
     {
         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
     if (m_wxwindow)
     {
         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))

+        {
+            // see comment in gtk_window_focus_out_callback()
+            gs_widgetLastFocus = m_wxwindow;

             gtk_widget_grab_focus (m_wxwindow);
             gtk_widget_grab_focus (m_wxwindow);

-        return;
+        }

     }
     }

-
-    if (m_widget)
+    else if (m_widget)

     {
         if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
         {
     {
         if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
         {


@@ -2500,17 +3278,17 @@ void wxWindow::SetFocus()
     }
 }
 
     }
 }
 

-bool wxWindow::AcceptsFocus() const
+bool wxWindowGTK::AcceptsFocus() const

 {
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 
 {
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 

-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) );
 
 
     wxASSERT( GTK_IS_WIDGET(m_widget) );
 


@@ -2541,7 +3319,7 @@ bool wxWindow::Reparent( wxWindowBase *newParentBase )
     return TRUE;
 }
 
     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") );
 


@@ -2556,7 +3334,7 @@ void wxWindow::DoAddChild(wxWindow *child)
     (*m_insertCallback)(this, child);
 }
 
     (*m_insertCallback)(this, child);
 }
 

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

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


@@ -2565,7 +3343,7 @@ void wxWindow::Raise()
     gdk_window_raise( m_widget->window );
 }
 
     gdk_window_raise( m_widget->window );
 }
 

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

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


@@ -2574,14 +3352,23 @@ void wxWindow::Lower()
     gdk_window_lower( m_widget->window );
 }
 
     gdk_window_lower( m_widget->window );
 }
 

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

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

-    return wxWindowBase::SetCursor( cursor );
+    if (cursor == m_cursor)
+       return FALSE;
+
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (cursor == wxNullCursor)
+       return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
+    else
+       return wxWindowBase::SetCursor( cursor );

 }
 
 }
 

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

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


@@ -2598,12 +3385,17 @@ void wxWindow::WarpPointer( int x, int y )
         gdk_window_warp_pointer( window, x, y );
 }
 
         gdk_window_warp_pointer( window, x, y );
 }
 

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

 {
 {

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

     if (!m_widget->window) return;
 
     if (!m_widget->window) return;
 

+    // temporarily hide the caret to avoid nasty interactions between caret
+    // drawing and the window contents redraw
+#if 0 // def wxUSE_CARET -- doesn't seem to help :-(
+    wxCaretSuspend cs((wxWindow *)this);
+#endif // wxUSE_CARET
+

     if (eraseBackground && m_wxwindow && m_wxwindow->window)
     {
         if (rect)
     if (eraseBackground && m_wxwindow && m_wxwindow->window)
     {
         if (rect)


@@ -2625,41 +3417,72 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     {
         if (m_wxwindow)
         {
     {
         if (m_wxwindow)
         {

+
+/*

             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );

-

             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );

-

             gtk_pizza_set_clear( pizza, old_clear );
             gtk_pizza_set_clear( pizza, old_clear );

+*/
+            GdkEventExpose gdk_event;
+            gdk_event.type = GDK_EXPOSE;
+            gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
+            gdk_event.count = 0;
+            gdk_event.area.x = 0;
+            gdk_event.area.y = 0;
+            gdk_event.area.width = m_wxwindow->allocation.width;
+            gdk_event.area.height = m_wxwindow->allocation.height;
+            gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );

         }
         else
         }
         else

+        {

             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );

+        }

     }
     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;

 
         if (m_wxwindow)
         {
 
         if (m_wxwindow)
         {

+/*

             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
 
             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
 

+            GdkRectangle gdk_rect;
+            gdk_rect.x = rect->x;
+            gdk_rect.y = rect->y;
+            gdk_rect.width = rect->width;
+            gdk_rect.height = rect->height;

             gtk_widget_draw( m_wxwindow, &gdk_rect );
             gtk_widget_draw( m_wxwindow, &gdk_rect );

+            gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );

 
             gtk_pizza_set_clear( pizza, old_clear );
 
             gtk_pizza_set_clear( pizza, old_clear );

+*/
+            GdkEventExpose gdk_event;
+            gdk_event.type = GDK_EXPOSE;
+            gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
+            gdk_event.count = 0;
+            gdk_event.area.x = rect->x;
+            gdk_event.area.y = rect->y;
+            gdk_event.area.width = rect->width;
+            gdk_event.area.height = rect->height;
+            gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );

         }
         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;

             gtk_widget_draw( m_widget, &gdk_rect );
             gtk_widget_draw( m_widget, &gdk_rect );

+        }

     }
 }
 
     }
 }
 

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

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


@@ -2667,26 +3490,26 @@ void wxWindow::Clear()
 
     if (m_wxwindow && m_wxwindow->window)
     {
 
     if (m_wxwindow && m_wxwindow->window)
     {

-        gdk_window_clear( m_wxwindow->window );
+//        gdk_window_clear( m_wxwindow->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 );
+        m_tooltip->Apply( (wxWindow *)this );

 }
 
 }
 

-void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
+void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )

 {
     gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
 }
 #endif // wxUSE_TOOLTIPS
 
 {
     gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
 }
 #endif // wxUSE_TOOLTIPS
 

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

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


@@ -2709,12 +3532,11 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         // but it couldn't get applied as the
         // widget hasn't been realized yet.
         m_delayedBackgroundColour = TRUE;
         // but it couldn't get applied as the
         // widget hasn't been realized yet.
         m_delayedBackgroundColour = TRUE;

-
-        // pretend we have done something
-        return TRUE;

     }
 
     }
 

-    if (m_wxwindow)
+    if ((m_wxwindow) &&
+        (m_wxwindow->window) &&
+        (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE)))

     {
         /* wxMSW doesn't clear the window here. I don't do that either to
           provide compatibility. call Clear() to do the job. */
     {
         /* wxMSW doesn't clear the window here. I don't do that either to
           provide compatibility. call Clear() to do the job. */


@@ -2723,22 +3545,12 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         gdk_window_set_background( window, m_backgroundColour.GetColor() );
     }
 
         gdk_window_set_background( window, m_backgroundColour.GetColor() );
     }
 

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

 
     return 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") );
 


@@ -2761,65 +3573,137 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
         // but it couldn't get applied as the
         // widget hasn't been realized yet.
         m_delayedForegroundColour = TRUE;
         // but it couldn't get applied as the
         // widget hasn't been realized yet.
         m_delayedForegroundColour = TRUE;

-
-        // pretend we have done something
-        return TRUE;

     }
 
     }
 

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

 
     return TRUE;
 }
 
 
     return TRUE;
 }
 

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

 {
 {

-    if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
+    if (m_widgetStyle)
+    {
+        GtkStyle *remake = gtk_style_copy( m_widgetStyle );
+#ifdef __WXGTK20__
+        /* FIXME: is this necessary? */
+        _G_TYPE_IGC(remake, GtkObjectClass) = _G_TYPE_IGC(m_widgetStyle, GtkObjectClass);
+#else
+        remake->klass = m_widgetStyle->klass;
+#endif

 
 

-    m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
+        gtk_style_unref( m_widgetStyle );
+        m_widgetStyle = remake;
+    }
+    else
+    {
+        GtkStyle *def = gtk_rc_get_style( m_widget );
+
+        if (!def)
+            def = gtk_widget_get_default_style();
+
+        m_widgetStyle = gtk_style_copy( def );
+#ifdef __WXGTK20__
+        /* FIXME: is this necessary? */
+        _G_TYPE_IGC(m_widgetStyle, GtkObjectClass) = _G_TYPE_IGC(def, GtkObjectClass);
+#else
+        m_widgetStyle->klass = def->klass;
+#endif
+    }

 
     return m_widgetStyle;
 }
 
 
     return m_widgetStyle;
 }
 

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

 {
 {

+#if DISABLE_STYLE_IF_BROKEN_THEM
+    if (m_widget->style->engine_data)
+    {
+        static bool s_warningPrinted = FALSE;
+        if (!s_warningPrinted)
+        {
+            printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
+            s_warningPrinted = TRUE;
+        }
+        m_widgetStyle = m_widget->style;
+        return;
+    }
+#endif
+

     GtkStyle *style = GetWidgetStyle();
 
     GtkStyle *style = GetWidgetStyle();
 

-    gdk_font_unref( style->font );
-    style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+    if (m_font != wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT ))
+    {
+        gdk_font_unref( style->font );
+        style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+    }

 
     if (m_foregroundColour.Ok())
     {
         m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
 
     if (m_foregroundColour.Ok())
     {
         m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );

-        style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
-        style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
-        style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
+        if (m_foregroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT))
+        {
+            style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
+            style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
+            style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
+        }
+        else
+        {
+            // Try to restore the gtk default style.  This is still a little
+            // oversimplified for what is probably really needed here for controls
+            // other than buttons, but is better than not being able to (re)set a
+            // control's foreground colour to *wxBLACK -- RL
+            GtkStyle *def = gtk_rc_get_style( m_widget );
+
+            if (!def)
+                def = gtk_widget_get_default_style();
+
+            style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
+            style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
+            style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
+        }

     }
 
     if (m_backgroundColour.Ok())
     {
         m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
     }
 
     if (m_backgroundColour.Ok())
     {
         m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );

-        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();
+        if (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE))
+        {
+            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();
+        }
+        else
+        {
+            // Try to restore the gtk default style.  This is still a little
+            // oversimplified for what is probably really needed here for controls
+            // other than buttons, but is better than not being able to (re)set a
+            // control's background colour to default grey and means resetting a
+            // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
+            // behavior -- RL
+            GtkStyle *def = gtk_rc_get_style( m_widget );
+
+            if (!def)
+                def = gtk_widget_get_default_style();
+
+            style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
+            style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
+            style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
+            style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
+            style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
+            style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
+            style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
+            style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
+        }

     }
 }
 
     }
 }
 

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

 {
 }
 
 {
 }
 


@@ -2827,12 +3711,14 @@ void wxWindow::ApplyWidgetStyle()
 // Pop-up menu stuff
 //-----------------------------------------------------------------------------
 
 // Pop-up menu stuff
 //-----------------------------------------------------------------------------
 

+#if wxUSE_MENUS_NATIVE
+

 static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting  )
 {
     *is_waiting = FALSE;
 }
 
 static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting  )
 {
     *is_waiting = FALSE;
 }
 

-static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
+static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )

 {
     menu->SetInvokingWindow( win );
     wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
 {
     menu->SetInvokingWindow( win );
     wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();


@@ -2848,19 +3734,32 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
     }
 }
 
     }
 }
 

+// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
+// wxPopupMenuPositionCallback()
+//
+// should be safe even in the MT case as the user can hardly popup 2 menus
+// simultaneously, can he?

 static gint gs_pop_x = 0;
 static gint gs_pop_y = 0;
 
 static gint gs_pop_x = 0;
 static gint gs_pop_y = 0;
 

-static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
-                              gint *x, gint *y,
-                              wxWindow *win )
+static void wxPopupMenuPositionCallback( GtkMenu *menu,
+                                         gint *x, gint *y,
+                                         gpointer WXUNUSED(user_data) )

 {
 {

-    win->ClientToScreen( &gs_pop_x, &gs_pop_y );
-    *x = gs_pop_x;
-    *y = gs_pop_y;
+    // ensure that the menu appears entirely on screen
+    GtkRequisition req;
+    gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
+
+    wxSize sizeScreen = wxGetDisplaySize();
+
+    gint xmax = sizeScreen.x - req.width,
+         ymax = sizeScreen.y - req.height;
+
+    *x = gs_pop_x < xmax ? gs_pop_x : xmax;
+    *y = gs_pop_y < ymax ? gs_pop_y : ymax;

 }
 
 }
 

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

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


@@ -2872,6 +3771,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 
     gs_pop_x = x;
     gs_pop_y = y;
 
     gs_pop_x = x;
     gs_pop_y = y;

+    ClientToScreen( &gs_pop_x, &gs_pop_y );

 
     bool is_waiting = TRUE;
 
 
     bool is_waiting = TRUE;
 


@@ -2880,12 +3780,12 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 
     gtk_menu_popup(
                   GTK_MENU(menu->m_menu),
 
     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
+                  (GtkWidget *) NULL,           // parent menu shell
+                  (GtkWidget *) NULL,           // parent menu item
+                  wxPopupMenuPositionCallback,  // function to position it
+                  NULL,                         // client data
+                  0,                            // button used to activate it
+                  gs_timeLastClick              // the time of activation

                 );
 
     while (is_waiting)
                 );
 
     while (is_waiting)


@@ -2897,9 +3797,11 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
     return TRUE;
 }
 
     return TRUE;
 }
 

+#endif // wxUSE_MENUS_NATIVE
+

 #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") );
 


@@ -2915,7 +3817,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;


@@ -2923,7 +3825,7 @@ GtkWidget* wxWindow::GetConnectWidget()
     return connect_widget;
 }
 
     return connect_widget;
 }
 

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

 {
     if (m_wxwindow)
         return (window == GTK_PIZZA(m_wxwindow)->bin_window);
 {
     if (m_wxwindow)
         return (window == GTK_PIZZA(m_wxwindow)->bin_window);


@@ -2931,7 +3833,7 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
     return (window == m_widget->window);
 }
 
     return (window == m_widget->window);
 }
 

-bool wxWindow::SetFont( const wxFont &font )
+bool wxWindowGTK::SetFont( const wxFont &font )

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


@@ -2955,19 +3857,21 @@ bool wxWindow::SetFont( const wxFont &font )
     return TRUE;
 }
 
     return TRUE;
 }
 

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

 {
     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)
         window = GTK_PIZZA(m_wxwindow)->bin_window;
     else
         window = GetConnectWidget()->window;
 
     GdkWindow *window = (GdkWindow*) NULL;
     if (m_wxwindow)
         window = GTK_PIZZA(m_wxwindow)->bin_window;
     else
         window = GetConnectWidget()->window;
 

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

 
     gdk_pointer_grab( window, FALSE,
                       (GdkEventMask)
 
     gdk_pointer_grab( window, FALSE,
                       (GdkEventMask)


@@ -2976,16 +3880,17 @@ void wxWindow::CaptureMouse()
                           GDK_POINTER_MOTION_HINT_MASK |
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                           GDK_POINTER_MOTION_HINT_MASK |
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,

-                      m_cursor.GetCursor(),
+                      cursor->GetCursor(),

                       (guint32)GDK_CURRENT_TIME );
     g_captureWindow = this;
                       (guint32)GDK_CURRENT_TIME );
     g_captureWindow = this;

+    g_captureWindowHasMouse = TRUE;

 }
 
 }
 

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

 {
     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") );

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


@@ -2997,15 +3902,21 @@ void wxWindow::ReleaseMouse()
         return;
 
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
         return;
 
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );

-    g_captureWindow = (wxWindow*) NULL;
+    g_captureWindow = (wxWindowGTK*) NULL;

 }
 
 }
 

-bool wxWindow::IsRetained() const
+/* static */
+wxWindow *wxWindowBase::GetCapture()
+{
+    return (wxWindow *)g_captureWindow;
+}
+
+bool wxWindowGTK::IsRetained() const

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

-void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
+void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,

       int range, bool refresh )
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
       int range, bool refresh )
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );


@@ -3069,7 +3980,7 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
         gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
 }
 
         gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
 }
 

-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") );
 


@@ -3096,23 +4007,32 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         m_vAdjust->value = fpos;
     }
 
         m_vAdjust->value = fpos;
     }
 

-/*
-    if (!m_isScrolling)
+    if (m_wxwindow->window)

     {
     {

-*/
-        if (m_wxwindow->window)
+        if (orient == wxHORIZONTAL)

         {
         {

-            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_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
+                (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
+
+            gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
+
+            gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
+                (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
+        }
+        else
+        {
+            gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
+                (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
+
+            gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
+
+            gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
+                (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );

         }
         }

-/*

     }
     }

-*/

 }
 
 }
 

-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") );
 


@@ -3124,7 +4044,7 @@ int wxWindow::GetScrollThumb( int orient ) const
         return (int)(m_vAdjust->page_size+0.5);
 }
 
         return (int)(m_vAdjust->page_size+0.5);
 }
 

-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") );
 


@@ -3136,7 +4056,7 @@ int wxWindow::GetScrollPos( int orient ) const
         return (int)(m_vAdjust->value+0.5);
 }
 
         return (int)(m_vAdjust->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") );
 


@@ -3148,68 +4068,109 @@ int wxWindow::GetScrollRange( int orient ) const
         return (int)(m_vAdjust->upper+0.5);
 }
 
         return (int)(m_vAdjust->upper+0.5);
 }
 

-void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
+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") );
 
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 

+    if ((dx == 0) && (dy == 0)) return;
+
+    m_clipPaintRegion = TRUE;

     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );

+    m_clipPaintRegion = FALSE;

 
 /*
 
 /*

-    if (!m_scrollGC)
+    if (m_children.GetCount() > 0)

     {
     {

-        m_scrollGC = gdk_gc_new( m_wxwindow->window );
-        gdk_gc_set_exposures( m_scrollGC, TRUE );
+        gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );

     }
     }

-
-    wxNode *node = m_children.First();
-    while (node)
+    else

     {
     {

-        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();
-    }
+        GtkPizza *pizza = GTK_PIZZA(m_wxwindow);

 
 

-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
-    int w = cw - abs(dx);
-    int h = ch - abs(dy);
+        pizza->xoffset -= dx;
+        pizza->yoffset -= dy;

 
 

-    if ((h < 0) || (w < 0))
-    {
-        Refresh();
-    }
-    else
-    {
-        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;
+        GdkGC *m_scrollGC = gdk_gc_new( pizza->bin_window );
+        gdk_gc_set_exposures( m_scrollGC, TRUE );

 
 

-        gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
-            m_wxwindow->window, s_x, s_y, w, h );
+        int cw = 0;
+        int ch = 0;
+        GetClientSize( &cw, &ch );
+        int w = cw - abs(dx);
+        int h = ch - abs(dy);

 
 

-        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);
+        if ((h < 0) || (w < 0))
+        {
+            Refresh();
+        }
+        else
+        {
+            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;
+
+            gdk_window_copy_area( pizza->bin_window, m_scrollGC, d_x, d_y,
+                pizza->bin_window, s_x, s_y, w, h );
+
+            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);
+
+            Refresh( TRUE, &rect );
+        }

 
 

-        Refresh( TRUE, &rect );
+        gdk_gc_unref( m_scrollGC );

     }
 */
 }
 
     }
 */
 }
 

-void wxWindow::SetScrolling(bool scroll)
+// 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;
+}
+
+// Get the current mouse position.
+wxPoint wxGetMousePosition()

 {
 {

-    m_isScrolling = g_blockEventsOnScroll = scroll;
+  /* 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);
+    if (!windowAtPtr)
+      return wxPoint(-999, -999);
+
+    Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr);
+    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);
+

 }
 }

+