]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk/window.cpp
wxGPE updates to HEAD.
[wxWidgets.git] / src / gtk / window.cpp
index feb8f2ffcec4545d817b04c0fdb3465f692560da..a6d5457225bf7cc5d933a634f5c04eff0ebf3a0d 100644 (file)
@@ -8,15 +8,17 @@
 /////////////////////////////////////////////////////////////////////////////
 
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "window.h"
 #endif
 
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
 #ifdef __VMS
 #define XWarpPointer XWARPPOINTER
 #endif
 
-#include "wx/defs.h"
 #include "wx/window.h"
 #include "wx/dcclient.h"
 #include "wx/frame.h"
@@ -255,9 +257,9 @@ wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
 // send any activate events at all
 static int        g_sendActivateEvent = -1;
 
-/* hack: we need something to pass to gtk_menu_popup, so we store the time of
-   the last click here */
-static guint32 gs_timeLastClick = 0;
+// hack: we need something to pass to gtk_menu_popup, so we store the time of
+// the last click here
+static guint32 gs_timeLastClick = 0; 
 
 extern bool g_mainThreadLocked;
 
@@ -345,7 +347,7 @@ wxWindow *wxFindFocusedChild(wxWindowGTK *win)
     if ( winFocus == win )
         return (wxWindow *)win;
 
-    for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
+    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
           node;
           node = node->GetNext() )
     {
@@ -477,12 +479,18 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
 // "size_request" of m_widget
 //-----------------------------------------------------------------------------
 
-static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition *requisition, wxWindow *win )
+// make it extern because wxStatitText needs to disconnect this one
+extern "C"
+void wxgtk_window_size_request_callback(GtkWidget *widget,
+                                        GtkRequisition *requisition,
+                                        wxWindow *win)
 {
-    int w,h;
+    int w, h;
     win->GetSize( &w, &h );
-    if (w < 2) w = 2;
-    if (h < 2) h = 2;
+    if (w < 2)
+        w = 2;
+    if (h < 2)
+        h = 2;
 
     requisition->height = h;
     requisition->width = w;
@@ -520,6 +528,18 @@ static int gtk_window_expose_callback( GtkWidget *widget,
                                          (int)gdk_event->area.width,
                                          (int)gdk_event->area.height );
     }
+    
+    gtk_paint_box
+    (
+        win->m_wxwindow->style,
+        pizza->bin_window,
+        GTK_STATE_NORMAL,
+        GTK_SHADOW_OUT,
+        (GdkRectangle*) NULL,
+        win->m_wxwindow,
+        (char *)"button", // const_cast
+        20,20,24,24
+    );
 #endif
 
     win->GetUpdateRegion() = wxRegion( gdk_event->region );
@@ -591,10 +611,11 @@ static void gtk_window_draw_callback( GtkWidget *widget,
     if (g_isIdle)
         wxapp_install_idle_handler();
 
-    // The wxNO_FULL_REPAINT_ON_RESIZE flag only works if
-    // there are no child windows.
-    if ((win->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) &&
-        (win->GetChildren().GetCount() == 0))
+    // if there are any children we must refresh everything
+    //
+    // VZ: why?
+    if ( !win->HasFlag(wxFULL_REPAINT_ON_RESIZE) &&
+            win->GetChildren().IsEmpty() )
     {
         return;
     }
@@ -1065,7 +1086,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
     return TRUE;
 }
 
-#ifndef __WXGTK20__
+
 static gint gtk_window_key_press_callback( GtkWidget *widget,
                                            GdkEventKey *gdk_event,
                                            wxWindow *win )
@@ -1115,42 +1136,58 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
     // will only be sent if it is not in an accelerator table.
     if (!ret)
     {
-        // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
+        long key_code;
         KeySym keysym = gdk_event->keyval;
-        long key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
-        if ( !key_code )
+#ifdef __WXGTK20__
+        // In GTK 2.0, we need to hand over the key event to an input method
+        // and the IM will emit a "commit" event containing the actual utf8
+        // character.  In that case the EVT_CHAR events will be sent from
+        // there.  But only do it this way for non-KeySym keys.
+        key_code = wxTranslateKeySymToWXKey(gdk_event->keyval, FALSE /* isChar */);
+        if ( !key_code && win->m_imContext )
         {
-            if ( gdk_event->length == 1 )
-            {
-                key_code = (unsigned char)gdk_event->string[0];
-            }
-            else if ( wxIsAsciiKeysym(keysym) )
-            {
-                // ASCII key
-                key_code = (unsigned char)keysym;
-            }
+            gtk_im_context_filter_keypress ( (GtkIMContext*) win->m_imContext, gdk_event );
+            ret = TRUE;
         }
-
-        if ( key_code )
+        else
+#endif
         {
-            wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
-
-            event.m_keyCode = key_code;
-
-            // Implement OnCharHook by checking ancesteror top level windows
-            wxWindow *parent = win;
-            while (parent && !parent->IsTopLevel())
-            parent = parent->GetParent();
-            if (parent)
+            // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
+            key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
+            if ( !key_code )
             {
-                event.SetEventType( wxEVT_CHAR_HOOK );
-                ret = parent->GetEventHandler()->ProcessEvent( event );
+                if ( gdk_event->length == 1 )
+                {
+                    key_code = (unsigned char)gdk_event->string[0];
+                }
+                else if ( wxIsAsciiKeysym(keysym) )
+                {
+                    // ASCII key
+                    key_code = (unsigned char)keysym;
+                }
             }
 
-            if (!ret)
+            if ( key_code )
             {
-                event.SetEventType(wxEVT_CHAR);
-                ret = win->GetEventHandler()->ProcessEvent( event );
+                wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
+
+                event.m_keyCode = key_code;
+
+                // Implement OnCharHook by checking ancesteror top level windows
+                wxWindow *parent = win;
+                while (parent && !parent->IsTopLevel())
+                    parent = parent->GetParent();
+                if (parent)
+                {
+                    event.SetEventType( wxEVT_CHAR_HOOK );
+                    ret = parent->GetEventHandler()->ProcessEvent( event );
+                }
+
+                if (!ret)
+                {
+                    event.SetEventType(wxEVT_CHAR);
+                    ret = win->GetEventHandler()->ProcessEvent( event );
+                }
             }
         }
     }
@@ -1221,135 +1258,11 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
 
     return FALSE;
 }
-#endif
 
 #ifdef __WXGTK20__
-static gint gtk_window_key_press_callback( GtkWidget *widget,
-                                           GdkEventKey *gdk_event,
-                                           wxWindow *win )
-{
-    if (g_isIdle)
-        wxapp_install_idle_handler();
-
-    if (!win->m_hasVMT)
-        return FALSE;
-    if (g_blockEventsOnDrag)
-        return FALSE;
-
-    bool ret = FALSE;
-    bool dont_use_IM = FALSE;
-
-    wxKeyEvent event( wxEVT_KEY_DOWN );
-    long keycode = wxTranslateKeySymToWXKey( gdk_event->keyval, FALSE );
-    if (keycode)
-    {
-        // We were able to decode the key press without
-        // any input method, so don't use it.
-        dont_use_IM = TRUE;
-
-        // now fill all the other fields
-        int x = 0;
-        int y = 0;
-        GdkModifierType state;
-        if (gdk_event->window)
-            gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
-
-        event.SetTimestamp( gdk_event->time );
-        event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
-        event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
-        event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
-        event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
-        event.m_keyCode = keycode;
-        event.m_scanCode = gdk_event->keyval;
-        event.m_rawCode = (wxUint32) gdk_event->keyval;
-        event.m_rawFlags = 0;
-        event.m_x = x;
-        event.m_y = y;
-        event.SetEventObject( win );
-
-        // send key down event
-        ret = win->GetEventHandler()->ProcessEvent( event );
-
-        if (!ret)
-        {
-            // Implement OnCharHook by checking ancesteror top level windows
-            wxWindow *parent = win;
-            while (parent && !parent->IsTopLevel())
-            parent = parent->GetParent();
-            if (parent)
-            {
-                event.SetEventType( wxEVT_CHAR_HOOK );
-                ret = parent->GetEventHandler()->ProcessEvent( event );
-            }
-
-            if (!ret)
-            {
-                event.SetEventType(wxEVT_CHAR);
-                ret = win->GetEventHandler()->ProcessEvent( event );
-            }
-        }
-
-        // win is a control: tab can be propagated up
-        if ( !ret &&
-             ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
-            win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
-        {
-            wxNavigationKeyEvent new_event;
-            new_event.SetEventObject( win->GetParent() );
-            // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
-            new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
-            // CTRL-TAB changes the (parent) window, i.e. switch notebook page
-            new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
-            new_event.SetCurrentFocus( win );
-            ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
-        }
-
-        if ( !ret &&
-             (gdk_event->keyval == GDK_Escape) )
-        {
-            wxWindow *winForCancel = win, *btnCancel = NULL;
-            while ( winForCancel )
-            {
-                btnCancel = winForCancel->FindWindow(wxID_CANCEL);
-                if ( btnCancel ) break;
-
-                if ( winForCancel->IsTopLevel() ) break;
-
-                winForCancel = winForCancel->GetParent();
-            }
-
-            if ( btnCancel )
-            {
-                wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
-                event.SetEventObject(btnCancel);
-                ret = btnCancel->GetEventHandler()->ProcessEvent(event);
-            }
-        }
-    }
-
-    if (ret)
-    {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
-        return TRUE;
-    }
-
-    if (!dont_use_IM && win->m_imContext)
-    {
-        // In GTK 2.0, we need to hand over the key
-        // event to an input method and the IM will
-        // emit a "commit" event containing the
-        // actual utf8 character.
-        gtk_im_context_filter_keypress ( (GtkIMContext*) win->m_imContext, gdk_event );
-
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
 static void gtk_wxwindow_commit_cb (GtkIMContext *context,
-                                                  const gchar  *str,
-                                                  wxWindow     *window)
+                           const gchar  *str,
+                           wxWindow     *window)
 {
     bool ret = FALSE;
 
@@ -1369,23 +1282,25 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context,
     event.m_keyCode = uniChar;
 #endif
 
-    if (!ret)
-    {
-        // Implement OnCharHook by checking ancesteror top level windows
-        wxWindow *parent = window;
-        while (parent && !parent->IsTopLevel())
+
+    // TODO:  We still need to set all the extra attributes of the
+    //        event, modifiers and such...
+
+
+    // Implement OnCharHook by checking ancestor top level windows
+    wxWindow *parent = window;
+    while (parent && !parent->IsTopLevel())
         parent = parent->GetParent();
-        if (parent)
-        {
-            event.SetEventType( wxEVT_CHAR_HOOK );
-            ret = parent->GetEventHandler()->ProcessEvent( event );
-        }
+    if (parent)
+    {
+        event.SetEventType( wxEVT_CHAR_HOOK );
+        ret = parent->GetEventHandler()->ProcessEvent( event );
+    }
 
-        if (!ret)
-        {
-            event.SetEventType(wxEVT_CHAR);
-            ret = window->GetEventHandler()->ProcessEvent( event );
-        }
+    if (!ret)
+    {
+        event.SetEventType(wxEVT_CHAR);
+        ret = window->GetEventHandler()->ProcessEvent( event );
     }
 }
 #endif
@@ -1511,12 +1426,12 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
         yy += pizza->yoffset;
     }
 
-    wxNode *node = win->GetChildren().First();
+    wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
     while (node)
     {
-        wxWindowGTK *child = (wxWindowGTK*)node->Data();
+        wxWindowGTK *child = node->GetData();
 
-        node = node->Next();
+        node = node->GetNext();
         if (!child->IsShown())
             continue;
 
@@ -1526,7 +1441,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
             int xx1 = child->m_x;
             int yy1 = child->m_y;
             int xx2 = child->m_x + child->m_width;
-            int yy2 = child->m_x + child->m_height;
+            int yy2 = child->m_y + child->m_height;
 
             // left
             if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
@@ -1607,7 +1522,8 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
         GdkEvent *peek_event = gdk_event_peek();
         if (peek_event)
         {
-            if (peek_event->type == GDK_2BUTTON_PRESS)
+            if ((peek_event->type == GDK_2BUTTON_PRESS) ||
+                (peek_event->type == GDK_3BUTTON_PRESS))
             {
                 gdk_event_free( peek_event );
                 return TRUE;
@@ -1621,47 +1537,83 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
 
     wxEventType event_type = wxEVT_NULL;
 
+#ifdef __WXGTK20__
+    if ( gdk_event->type == GDK_2BUTTON_PRESS &&
+            gdk_event->button >= 1 && gdk_event->button <= 3 )
+    {
+        // Reset GDK internal timestamp variables in order to disable GDK
+        // triple click events. GDK will then next time believe no button has
+        // been clicked just before, and send a normal button click event.
+        GdkDisplay* display = gtk_widget_get_display (widget);
+        display->button_click_time[1] = 0;
+        display->button_click_time[0] = 0;
+    }
+#endif // GTK 2+
+
     if (gdk_event->button == 1)
     {
+        // note that GDK generates triple click events which are not supported
+        // by wxWindows but still have to be passed to the app as otherwise
+        // clicks would simply go missing
         switch (gdk_event->type)
         {
-            case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
-            default:  break;
+            // we shouldn't get triple clicks at all for GTK2 because we
+            // suppress them artificially using the code above but we still
+            // should map them to something for GTK1 and not just ignore them
+            // as this would lose clicks
+            case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
+            case GDK_BUTTON_PRESS:
+                event_type = wxEVT_LEFT_DOWN;
+                break;
+
+            case GDK_2BUTTON_PRESS:
+                event_type = wxEVT_LEFT_DCLICK;
+                break;
+
+            default:
+                // just to silence gcc warnings
+                ;
         }
     }
     else if (gdk_event->button == 2)
     {
         switch (gdk_event->type)
         {
-            case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
-            default:  break;
+            case GDK_3BUTTON_PRESS:
+            case GDK_BUTTON_PRESS:
+                event_type = wxEVT_MIDDLE_DOWN;
+                break;
+
+            case GDK_2BUTTON_PRESS:
+                event_type = wxEVT_MIDDLE_DCLICK;
+                break;
+
+            default:
+                ;
         }
     }
     else if (gdk_event->button == 3)
     {
         switch (gdk_event->type)
         {
-            case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
-            case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
-            default:  break;
-        }
-    }
-    else if (gdk_event->button == 4)
-    {
-        switch (gdk_event->type)
-        {
-            case GDK_BUTTON_PRESS: event_type = wxEVT_MOUSEWHEEL; break;
-            default:  break;
+            case GDK_3BUTTON_PRESS:
+            case GDK_BUTTON_PRESS:
+                event_type = wxEVT_RIGHT_DOWN;
+                break;
+
+            case GDK_2BUTTON_PRESS:
+                event_type = wxEVT_RIGHT_DCLICK;
+                break;
+
+            default:
+                ;
         }
     }
-    else if (gdk_event->button == 5)
+    else if (gdk_event->button == 4 || gdk_event->button == 5)
     {
-        switch (gdk_event->type)
+        if (gdk_event->type == GDK_BUTTON_PRESS )
         {
-            case GDK_BUTTON_PRESS: event_type = wxEVT_MOUSEWHEEL; break;
-            default:  break;
+            event_type = wxEVT_MOUSEWHEEL;
         }
     }
 
@@ -1835,6 +1787,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
     {
         // synthetize a mouse enter or leave event if needed
         GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+        // This seems to be necessary and actually been added to
+        // GDK itself in version 2.0.X
+        gdk_flush();
+
         bool hasMouse = winUnderMouse == gdk_event->window;
         if ( hasMouse != g_captureWindowHasMouse )
         {
@@ -1862,6 +1818,61 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
     return FALSE;
 }
 
+#ifdef __WXGTK20__
+//-----------------------------------------------------------------------------
+// "mouse_wheel_event"
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_wheel_callback (GtkWidget * widget,
+                                       GdkEventScroll * gdk_event,
+                                       wxWindowGTK * win)
+{
+    DEBUG_MAIN_THREAD
+
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    wxEventType event_type = wxEVT_NULL;
+    if (gdk_event->direction == GDK_SCROLL_UP)
+        event_type = wxEVT_MOUSEWHEEL;
+    else if (gdk_event->direction == GDK_SCROLL_DOWN)
+        event_type = wxEVT_MOUSEWHEEL;
+    else
+        return FALSE;
+    
+    wxMouseEvent event( event_type );
+    // Can't use InitMouse macro because scroll events don't have button
+    event.SetTimestamp( gdk_event->time );
+    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    if (gdk_event->direction == GDK_SCROLL_UP)
+        event.m_wheelRotation = 120;
+    else
+        event.m_wheelRotation = -120;
+
+    wxPoint pt = win->GetClientAreaOrigin();
+    event.m_x = (wxCoord)gdk_event->x - pt.x;
+    event.m_y = (wxCoord)gdk_event->y - pt.y;
+
+    event.SetEventObject( win );
+    event.SetId( win->GetId() );
+    event.SetTimestamp( gdk_event->time );
+    
+    if (win->GetEventHandler()->ProcessEvent( event ))
+    {
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
+        return TRUE;
+    }
+
+    return FALSE;
+}
+#endif
+
 //-----------------------------------------------------------------------------
 // "focus_in_event"
 //-----------------------------------------------------------------------------
@@ -1912,7 +1923,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget,
 
     wxLogTrace(TRACE_FOCUS,
                _T("%s: focus in"), win->GetName().c_str());
-    
+
 #ifdef HAVE_XIM
     if (win->m_ic)
         gdk_im_begin(win->m_ic, win->m_wxwindow->window);
@@ -2058,6 +2069,9 @@ gint gtk_window_enter_callback( GtkWidget *widget,
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
+    // Event was emitted after a grab
+    if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
+
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     int x = 0;
@@ -2095,6 +2109,9 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
+    // Event was emitted after an ungrab
+    if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
+
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
@@ -2275,21 +2292,6 @@ wxWindow *wxWindowBase::FindFocus()
     return (wxWindow *)g_focusWindow;
 }
 
-//-----------------------------------------------------------------------------
-// "destroy" event
-//-----------------------------------------------------------------------------
-
-// VZ: Robert commented the code using out so it generates warnings: should
-//     be either fixed or removed completely
-#if 0
-
-static void gtk_window_destroy_callback( GtkWidget* widget, wxWindow *win )
-{
-    wxWindowDestroyEvent event(win);
-    win->GetEventHandler()->ProcessEvent(event);
-}
-
-#endif // 0
 
 //-----------------------------------------------------------------------------
 // "realize" from m_widget
@@ -2305,11 +2307,11 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
 
     if (g_isIdle)
         wxapp_install_idle_handler();
-
-    if (win->m_delayedBackgroundColour)
+        
+    if (win->m_delayedBackgroundColour && !win->GetThemeEnabled())
         win->GtkSetBackgroundColour( win->GetBackgroundColour() );
 
-    if (win->m_delayedForegroundColour)
+    if (win->m_delayedForegroundColour && !win->GetThemeEnabled())
         win->GtkSetForegroundColour( win->GetForegroundColour() );
 
 #ifdef __WXGTK20__
@@ -2534,9 +2536,6 @@ wxWindow *wxGetActiveWindow()
 
 void wxWindowGTK::Init()
 {
-    // common init
-    InitBase();
-
     // GTK specific
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
@@ -2561,8 +2560,10 @@ void wxWindowGTK::Init()
 
     m_hAdjust = (GtkAdjustment*) NULL;
     m_vAdjust = (GtkAdjustment*) NULL;
-    m_oldHorizontalPos = 0.0;
+    m_oldHorizontalPos =
     m_oldVerticalPos = 0.0;
+    m_oldClientWidth =
+    m_oldClientHeight = 0;
 
     m_resizing = FALSE;
     m_widgetStyle = (GtkStyle*) NULL;
@@ -2735,6 +2736,8 @@ bool wxWindowGTK::Create( wxWindow *parent,
 
 wxWindowGTK::~wxWindowGTK()
 {
+    SendDestroyEvent();
+
     if (g_focusWindow == this)
         g_focusWindow = NULL;
 
@@ -2752,9 +2755,6 @@ wxWindowGTK::~wxWindowGTK()
 
     DestroyChildren();
 
-    if (m_parent)
-        m_parent->RemoveChild( this );
-
 #ifdef HAVE_XIM
     if (m_ic)
         gdk_ic_destroy (m_ic);
@@ -2836,13 +2836,13 @@ void wxWindowGTK::PostCreation()
             gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
                 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
 
-            if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
+            if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
             {
                 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
                     GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
             }
 #else
-            // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
+            // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
 #endif
 
 #ifdef __WXGTK20__
@@ -2904,7 +2904,7 @@ void wxWindowGTK::PostCreation()
                             GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
     }
 
-    if (!GTK_IS_COMBO(m_widget))
+    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
@@ -2912,7 +2912,8 @@ void wxWindowGTK::PostCreation()
         // 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 );
+                            GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
+                            (gpointer) this );
     }
 
     m_hasVMT = TRUE;
@@ -2935,16 +2936,16 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
 
+#ifdef __WXGTK20__
+    gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
+      GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
+#endif
+
     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
-
-    // This keeps crashing on me. RR.
-    //
-    // gtk_signal_connect( GTK_OBJECT(widget), "destroy",
-    //  GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
 }
 
 bool wxWindowGTK::Destroy()
@@ -2975,9 +2976,9 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
 
     int currentX, currentY;
     GetPosition(&currentX, &currentY);
-    if (x == -1)
+    if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         x = currentX;
-    if (y == -1)
+    if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         y = currentY;
     AdjustForParentClientOrigin(x, y, sizeFlags);
 
@@ -3134,7 +3135,8 @@ void wxWindowGTK::OnInternalIdle()
         }
     }
 
-    UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
 }
 
 void wxWindowGTK::DoGetSize( int *width, int *height ) const
@@ -3385,7 +3387,7 @@ static void wxWindowNotifyEnable(wxWindowGTK* win, bool 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();
+    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
           node;
           node = node->GetNext() )
     {
@@ -3438,7 +3440,7 @@ int wxWindowGTK::GetCharHeight() const
     pango_layout_line_get_extents(line, NULL, &rect);
 
     g_object_unref( G_OBJECT( layout ) );
-    
+
     return (int) (rect.height / PANGO_SCALE);
 #else
     GdkFont *font = m_font.GetInternalFont( 1.0 );
@@ -3464,19 +3466,19 @@ int wxWindowGTK::GetCharWidth() const
     PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
     PangoLayout *layout = pango_layout_new(context);
     pango_layout_set_font_description(layout, desc);
-    pango_layout_set_text(layout, "H", 1);
+    pango_layout_set_text(layout, "g", 1);
     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
 
     PangoRectangle rect;
     pango_layout_line_get_extents(line, NULL, &rect);
 
     g_object_unref( G_OBJECT( layout ) );
-    
+
     return (int) (rect.width / PANGO_SCALE);
 #else
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
-    return gdk_string_width( font, "H" );
+    return gdk_string_width( font, "g" );
 #endif
 }
 
@@ -3719,6 +3721,18 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
     if (g_isIdle)
         wxapp_install_idle_handler();
 
+    wxRect myRect(0,0,0,0);
+    if (m_wxwindow && rect)
+    {
+        myRect.SetSize(wxSize( m_wxwindow->allocation.width,
+                               m_wxwindow->allocation.height));
+        myRect.Intersect(*rect);
+        if (!myRect.width || !myRect.height)
+            // nothing to do, rectangle is empty
+            return;
+        rect = &myRect;
+    }
+
     if (eraseBackground && m_wxwindow && m_wxwindow->window)
     {
         if (rect)
@@ -3952,7 +3966,7 @@ void wxWindowGTK::GtkSendPaintEvents()
     m_updateRegion.Clear();
 }
 
-void wxWindowGTK::Clear()
+void wxWindowGTK::ClearBackground()
 {
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
@@ -4147,7 +4161,13 @@ void wxWindowGTK::SetWidgetStyle()
 
     if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
     {
-        SET_STYLE_FONT(style, m_font.GetInternalFont( 1.0 ));
+#ifdef __WXGTK20__
+        pango_font_description_free( style->font_desc );
+        style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
+#else
+        gdk_font_unref( style->font );
+        style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+#endif
     }
 
     if (m_foregroundColour.Ok())
@@ -4234,7 +4254,7 @@ void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting  )
 static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
 {
     menu->SetInvokingWindow( win );
-    wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
+    wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
     while (node)
     {
         wxMenuItem *menuitem = node->GetData();
@@ -4303,13 +4323,16 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
                   wxPopupMenuPositionCallback,  // function to position it
                   NULL,                         // client data
                   0,                            // button used to activate it
+#ifdef __WXGTK20__
+                  gtk_get_current_event_time()
+#else
                   gs_timeLastClick              // the time of activation
+#endif
                 );
 
     while (is_waiting)
     {
-        while (gtk_events_pending())
-            gtk_main_iteration();
+        gtk_main_iteration();
     }
 
     return TRUE;
@@ -4353,9 +4376,7 @@ bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
 
 bool wxWindowGTK::SetFont( const wxFont &font )
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
-
-    if (!wxWindowBase::SetFont(font))
+    if (!wxWindowBase::SetFont(font) || !m_widget)
     {
         return FALSE;
     }