[ 1793012 ] wxSpinCtrl::SetValue() doesn't update internal counter

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index f7c8878b378ebc275257468aab9f560fab6278f0..e8b8ed17199df2c4bd92977964fb616459fdd0ac 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -190,8 +190,10 @@
 // data
 //-----------------------------------------------------------------------------
 
 // data
 //-----------------------------------------------------------------------------
 

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

 extern wxCursor   g_globalCursor;
 
 // mouse capture state: the window which has it and if the mouse is currently
 extern wxCursor   g_globalCursor;
 
 // mouse capture state: the window which has it and if the mouse is currently


@@ -422,6 +424,8 @@ void wxgtk_window_size_request_callback(GtkWidget *widget,
 }
 }
 
 }
 }
 

+#if wxUSE_COMBOBOX
+

 extern "C" {
 static
 void wxgtk_combo_size_request_callback(GtkWidget *widget,
 extern "C" {
 static
 void wxgtk_combo_size_request_callback(GtkWidget *widget,


@@ -457,6 +461,8 @@ void wxgtk_combo_size_request_callback(GtkWidget *widget,
 }
 }
 
 }
 }
 

+#endif // wxUSE_COMBOBOX
+

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


@@ -1129,9 +1135,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
         wxFillOtherKeyEventFields(event,
                                   window, window->m_imData->lastKeyEvent);
     }
         wxFillOtherKeyEventFields(event,
                                   window, window->m_imData->lastKeyEvent);
     }

+    else
+    {
+        event.SetEventObject( window );
+    }

 
 

-    const wxWxCharBuffer data(wxGTK_CONV_BACK_SYS(str));
-    if( !data )
+    const wxString data(wxGTK_CONV_BACK_SYS(str));
+    if( data.empty() )

         return;
 
     bool ret = false;
         return;
 
     bool ret = false;


@@ -1141,7 +1151,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
     while (parent && !parent->IsTopLevel())
         parent = parent->GetParent();
 
     while (parent && !parent->IsTopLevel())
         parent = parent->GetParent();
 

-    for( const wxChar* pstr = data; *pstr; pstr++ )
+    for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )

     {
 #if wxUSE_UNICODE
         event.m_uniChar = *pstr;
     {
 #if wxUSE_UNICODE
         event.m_uniChar = *pstr;


@@ -1149,7 +1159,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context,
         event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
         wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
 #else
         event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
         wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
 #else

-        event.m_keyCode = *pstr;
+        event.m_keyCode = (char)*pstr;

 #endif  // wxUSE_UNICODE
 
         // To conform to the docs we need to translate Ctrl-alpha
 #endif  // wxUSE_UNICODE
 
         // To conform to the docs we need to translate Ctrl-alpha


@@ -1227,22 +1237,15 @@ template<typename T> void InitMouseEvent(wxWindowGTK *win,
                                          T *gdk_event)
 {
     event.SetTimestamp( gdk_event->time );
                                          T *gdk_event)
 {
     event.SetTimestamp( gdk_event->time );

-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
-    {
-       event.m_linesPerAction = 3;
-       event.m_wheelDelta = 120;
-       if (((GdkEventButton*)gdk_event)->button == 4)
-           event.m_wheelRotation = 120;
-       else if (((GdkEventButton*)gdk_event)->button == 5)
-           event.m_wheelRotation = -120;
-    }
+    event.m_shiftDown = gdk_event->state & GDK_SHIFT_MASK;
+    event.m_controlDown = gdk_event->state & GDK_CONTROL_MASK;
+    event.m_altDown = gdk_event->state & GDK_MOD1_MASK;
+    event.m_metaDown = gdk_event->state & GDK_MOD2_MASK;
+    event.m_leftDown = gdk_event->state & GDK_BUTTON1_MASK;
+    event.m_middleDown = gdk_event->state & GDK_BUTTON2_MASK;
+    event.m_rightDown = gdk_event->state & GDK_BUTTON3_MASK;
+    event.m_aux1Down = gdk_event->state & GDK_BUTTON4_MASK;
+    event.m_aux2Down = gdk_event->state & GDK_BUTTON5_MASK;

 
     wxPoint pt = win->GetClientAreaOrigin();
     event.m_x = (wxCoord)gdk_event->x - pt.x;
 
     wxPoint pt = win->GetClientAreaOrigin();
     event.m_x = (wxCoord)gdk_event->x - pt.x;


@@ -1437,11 +1440,6 @@ gtk_window_button_press_callback( GtkWidget *widget,
 
     g_lastButtonNumber = gdk_event->button;
 
 
     g_lastButtonNumber = gdk_event->button;
 

-    if (win->m_wxwindow && (g_focusWindow != win) && win->CanAcceptFocus())
-    {
-        gtk_widget_grab_focus( win->m_wxwindow );
-    }
-

     // GDK sends surplus button down events
     // before a double click event. We
     // need to filter these out.
     // GDK sends surplus button down events
     // before a double click event. We
     // need to filter these out.


@@ -1539,13 +1537,6 @@ gtk_window_button_press_callback( GtkWidget *widget,
                 ;
         }
     }
                 ;
         }
     }

-    else if (gdk_event->button == 4 || gdk_event->button == 5)
-    {
-        if (gdk_event->type == GDK_BUTTON_PRESS )
-        {
-            event_type = wxEVT_MOUSEWHEEL;
-        }
-    }

 
     if ( event_type == wxEVT_NULL )
     {
 
     if ( event_type == wxEVT_NULL )
     {


@@ -1579,6 +1570,12 @@ gtk_window_button_press_callback( GtkWidget *widget,
     if ( ret )
         return TRUE;
 
     if ( ret )
         return TRUE;
 

+    if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && 
+        (g_focusWindow != win) /* && win->IsFocusable() */)
+    {
+        win->SetFocus();
+    }
+

     if (event_type == wxEVT_RIGHT_DOWN)
     {
         // generate a "context menu" event: this is similar to right mouse
     if (event_type == wxEVT_RIGHT_DOWN)
     {
         // generate a "context menu" event: this is similar to right mouse


@@ -1730,7 +1727,7 @@ gtk_window_motion_notify_callback( GtkWidget *widget,
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

-// "scroll_event", (mouse wheel event)
+// "scroll_event" (mouse wheel event)

 //-----------------------------------------------------------------------------
 
 static gboolean
 //-----------------------------------------------------------------------------
 
 static gboolean


@@ -1745,15 +1742,7 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
     }
 
     wxMouseEvent event(wxEVT_MOUSEWHEEL);
     }
 
     wxMouseEvent event(wxEVT_MOUSEWHEEL);

-    // Can't use InitMouse macro because scroll events don't have button
-    event.SetTimestamp( gdk_event->time );
-    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
-    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
-    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
-    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
-    event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    InitMouseEvent(win, event, gdk_event);

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


@@ -1761,14 +1750,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
     else
         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 );
-

     return win->GTKProcessEvent(event);
 }
 
     return win->GTKProcessEvent(event);
 }
 


@@ -1884,7 +1865,9 @@ gtk_window_focus_out_callback( GtkWidget *widget,
         // Disable default focus handling for custom windows
         // since the default GTK+ handler issues a repaint
         if ( has_wxwindow )
         // Disable default focus handling for custom windows
         // since the default GTK+ handler issues a repaint
         if ( has_wxwindow )

+       {

             return TRUE;
             return TRUE;

+       }

     }
 
     // continue with normal processing
     }
 
     // continue with normal processing


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

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

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


@@ -1972,17 +1953,7 @@ gtk_window_leave_callback( GtkWidget *widget,
 
     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) != 0;
-    event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
-    event.m_altDown = (state & GDK_MOD1_MASK) != 0;
-    event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
-    event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
-    event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
-    event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
-
-    wxPoint pt = win->GetClientAreaOrigin();
-    event.m_x = x + pt.x;
-    event.m_y = y + pt.y;
+    InitMouseEvent(win, event, gdk_event);

 
     return win->GTKProcessEvent(event);
 }
 
     return win->GTKProcessEvent(event);
 }


@@ -2008,9 +1979,7 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
         wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
         event.SetEventObject(win);
 
         wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
         event.SetEventObject(win);
 

-        win->m_blockValueChanged[dir] = true;

         win->GTKProcessEvent(event);
         win->GTKProcessEvent(event);

-        win->m_blockValueChanged[dir] = false;

     }
 }
 
     }
 }
 


@@ -2076,9 +2045,6 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 

-/* We cannot set colours and fonts before the widget has
-   been realized, so we do this directly after realization. */
-

 static void
 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
 {
 static void
 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
 {


@@ -2091,6 +2057,16 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
                                           pizza->bin_window );
     }
 
                                           pizza->bin_window );
     }
 

+    // We cannot set colours and fonts before the widget
+    // been realized, so we do this directly after realization
+    // or otherwise in idle time
+
+    if (win->m_needsStyleChange)
+    {
+        win->SetBackgroundStyle(win->GetBackgroundStyle());
+        win->m_needsStyleChange = false;
+    }
+

     wxWindowCreateEvent event( win );
     event.SetEventObject( win );
     win->GTKProcessEvent( event );
     wxWindowCreateEvent event( win );
     event.SetEventObject( win );
     win->GTKProcessEvent( event );


@@ -2128,6 +2104,27 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
     }
 }
 
     }
 }
 

+//-----------------------------------------------------------------------------
+// "grab_broken" 
+//-----------------------------------------------------------------------------
+
+#ifdef __WXGTK210__
+static void
+gtk_window_grab_broken( GtkWidget *m_widget,
+                        GdkEventGrabBroken *event,
+                        wxWindow *win )
+{
+    // Mouse capture has been lost involuntarily, notify the application
+    if( !event->keyboard && win && wxWindow::GetCapture() == win )
+    {
+        wxMouseCaptureLostEvent evt( win->GetId() );
+        evt.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( evt );
+    }
+}
+#endif
+
+

 } // extern "C"
 
 // ----------------------------------------------------------------------------
 } // extern "C"
 
 // ----------------------------------------------------------------------------


@@ -2161,7 +2158,7 @@ static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
     child->m_y += gtk_pizza_get_yoffset( pizza );
 
     gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
     child->m_y += gtk_pizza_get_yoffset( pizza );
 
     gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),

-                     GTK_WIDGET(child->m_widget),
+                     child->m_widget,

                      child->m_x,
                      child->m_y,
                      child->m_width,
                      child->m_x,
                      child->m_y,
                      child->m_width,


@@ -2193,6 +2190,8 @@ wxMouseState wxGetMouseState()
     ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
     ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
     ms.SetRightDown(mask & GDK_BUTTON3_MASK);
     ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
     ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
     ms.SetRightDown(mask & GDK_BUTTON3_MASK);

+    ms.SetAux1Down(mask & GDK_BUTTON4_MASK);
+    ms.SetAux2Down(mask & GDK_BUTTON5_MASK);

 
     ms.SetControlDown(mask & GDK_CONTROL_MASK);
     ms.SetShiftDown(mask & GDK_SHIFT_MASK);
 
     ms.SetControlDown(mask & GDK_CONTROL_MASK);
     ms.SetShiftDown(mask & GDK_SHIFT_MASK);


@@ -2227,9 +2226,7 @@ void wxWindowGTK::Init()
     m_width = 0;
     m_height = 0;
 
     m_width = 0;
     m_height = 0;
 

-    m_sizeSet = false;

     m_hasVMT = false;
     m_hasVMT = false;

-    m_needParent = true;

     m_isBeingDeleted = false;
 
     m_showOnIdle= false;
     m_isBeingDeleted = false;
 
     m_showOnIdle= false;


@@ -2247,7 +2244,6 @@ void wxWindowGTK::Init()
     {
         m_scrollBar[dir] = NULL;
         m_scrollPos[dir] = 0;
     {
         m_scrollBar[dir] = NULL;
         m_scrollPos[dir] = 0;

-        m_blockValueChanged[dir] = false;

     }
 
     m_oldClientWidth =
     }
 
     m_oldClientWidth =


@@ -2255,7 +2251,7 @@ void wxWindowGTK::Init()
 
     m_resizing = false;
 
 
     m_resizing = false;
 

-    m_insertCallback = (wxInsertChildFunction) NULL;
+    m_insertCallback = wxInsertChildInWindow;

 
     m_hasFocus = false;
 
 
     m_hasFocus = false;
 


@@ -2300,9 +2296,6 @@ bool wxWindowGTK::Create( wxWindow *parent,
         return false;
     }
 
         return false;
     }
 

-    m_insertCallback = wxInsertChildInWindow;
-
-

     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
     {
         m_wxwindow = gtk_pizza_new_no_scroll();
     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
     {
         m_wxwindow = gtk_pizza_new_no_scroll();


@@ -2386,7 +2379,7 @@ bool wxWindowGTK::Create( wxWindow *parent,
             g_signal_handler_block(m_scrollBar[dir], handler_id);
 
             // these handlers get notified when scrollbar slider moves
             g_signal_handler_block(m_scrollBar[dir], handler_id);
 
             // these handlers get notified when scrollbar slider moves

-            g_signal_connect(m_scrollBar[dir], "value_changed",
+            g_signal_connect_after(m_scrollBar[dir], "value_changed",

                          G_CALLBACK(gtk_scrollbar_value_changed), this);
         }
 
                          G_CALLBACK(gtk_scrollbar_value_changed), this);
         }
 


@@ -2452,7 +2445,10 @@ wxWindowGTK::~wxWindowGTK()
 
 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
 {
 
 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
 {

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

 
     // Use either the given size, or the default if -1 is given.
     // See wxWindowBase for these functions.
 
     // Use either the given size, or the default if -1 is given.
     // See wxWindowBase for these functions.


@@ -2543,8 +2539,29 @@ void wxWindowGTK::PostCreation()
         // Catch native resize events
         g_signal_connect (m_wxwindow, "size_allocate",
                           G_CALLBACK (gtk_window_size_callback), this);
         // Catch native resize events
         g_signal_connect (m_wxwindow, "size_allocate",
                           G_CALLBACK (gtk_window_size_callback), this);

+#ifdef __WXGTK210__
+        if (!gtk_check_version(2,8,0))
+        {
+            // Make sure we can notify the app when mouse capture is lost
+            g_signal_connect (m_wxwindow, "grab_broken_event",
+                          G_CALLBACK (gtk_window_grab_broken), this);
+        }
+#endif

     }
 
     }
 

+    if ( connect_widget != m_wxwindow )
+    {
+#ifdef __WXGTK210__
+        if (!gtk_check_version(2,8,0))
+        {
+            // Make sure we can notify app code when mouse capture is lost
+            g_signal_connect (connect_widget, "grab_broken_event",
+                        G_CALLBACK (gtk_window_grab_broken), this);
+        }
+#endif
+    }
+
+#if wxUSE_COMBOBOX

     if (GTK_IS_COMBO(m_widget))
     {
         GtkCombo *gcombo = GTK_COMBO(m_widget);
     if (GTK_IS_COMBO(m_widget))
     {
         GtkCombo *gcombo = GTK_COMBO(m_widget);


@@ -2552,17 +2569,18 @@ void wxWindowGTK::PostCreation()
         g_signal_connect (gcombo->entry, "size_request",
                           G_CALLBACK (wxgtk_combo_size_request_callback),
                           this);
         g_signal_connect (gcombo->entry, "size_request",
                           G_CALLBACK (wxgtk_combo_size_request_callback),
                           this);

-    }
+    } else
+#endif // wxUSE_COMBOBOX

 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
 #ifdef GTK_IS_FILE_CHOOSER_BUTTON

-    else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
+    if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))

     {
         // If we connect to the "size_request" signal of a GtkFileChooserButton
         // then that control won't be sized properly when placed inside sizers
         // (this can be tested removing this elseif and running XRC or WIDGETS samples)
         // FIXME: what should be done here ?
     {
         // If we connect to the "size_request" signal of a GtkFileChooserButton
         // then that control won't be sized properly when placed inside sizers
         // (this can be tested removing this elseif and running XRC or WIDGETS samples)
         // FIXME: what should be done here ?

-    }
+    } else

 #endif
 #endif

-    else if ( !IsTopLevel() ) // top level windows use their own callback
+    if ( !IsTopLevel() ) // top level windows use their own callback

     {
         // This is needed if we want to add our windows into native
         // GTK controls, such as the toolbar. With this callback, the
     {
         // This is needed if we want to add our windows into native
         // GTK controls, such as the toolbar. With this callback, the


@@ -2623,6 +2641,23 @@ void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
 
 }
 
 
 }
 

+void wxWindowGTK::ConstrainSize()
+{
+#ifdef __WXGPE__
+    // GPE's window manager doesn't like size hints at all, esp. when the user
+    // has to use the virtual keyboard, so don't constrain size there
+    if (!IsTopLevel())
+#endif
+    {
+        const wxSize minSize = GetMinSize();
+        const wxSize maxSize = GetMaxSize();
+        if (minSize.x > 0 && m_width  < minSize.x) m_width  = minSize.x;
+        if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
+        if (maxSize.x > 0 && m_width  > maxSize.x) m_width  = maxSize.x;
+        if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
+    }
+}
+

 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );


@@ -2655,21 +2690,13 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
     if (height != -1)
         m_height = height;
 
     if (height != -1)
         m_height = height;
 

-    int minWidth  = GetMinWidth(),
-        minHeight = GetMinHeight(),
-        maxWidth  = GetMaxWidth(),
-        maxHeight = GetMaxHeight();
-
-    if ((minWidth  != -1) && (m_width  < minWidth )) m_width  = minWidth;
-    if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
-    if ((maxWidth  != -1) && (m_width  > maxWidth )) m_width  = maxWidth;
-    if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
+    ConstrainSize();

 
 #if wxUSE_TOOLBAR_NATIVE
     if (wxDynamicCast(GetParent(), wxToolBar))
     {
        // don't take the x,y values, they're wrong because toolbar sets them
 
 #if wxUSE_TOOLBAR_NATIVE
     if (wxDynamicCast(GetParent(), wxToolBar))
     {
        // don't take the x,y values, they're wrong because toolbar sets them

-       GtkWidget  *widget = GTK_WIDGET(m_widget);
+       GtkWidget  *widget = m_widget;

        gtk_widget_set_size_request (widget, m_width, m_height);
     }
     else
        gtk_widget_set_size_request (widget, m_width, m_height);
     }
     else


@@ -2712,12 +2739,12 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
                 right_border += default_border->right;
                 top_border += default_border->top;
                 bottom_border += default_border->bottom;
                 right_border += default_border->right;
                 top_border += default_border->top;
                 bottom_border += default_border->bottom;

-                g_free( default_border );
+                gtk_border_free( default_border );

             }
         }
 
             }
         }
 

-        DoMoveWindow( m_x-top_border,
-                      m_y-left_border,
+        DoMoveWindow( m_x - left_border,
+                      m_y - top_border,

                       m_width+left_border+right_border,
                       m_height+top_border+bottom_border );
     }
                       m_width+left_border+right_border,
                       m_height+top_border+bottom_border );
     }


@@ -2838,25 +2865,9 @@ void wxWindowGTK::DoSetClientSize( int width, int height )
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 

-    if (m_wxwindow)
-    {
-        int dw = 0;
-        int dh = 0;
-
-        if (m_hasScrolling)
-        {
-            GetScrollbarWidth(m_widget, dw, dh);
-        }
-
-        const int border = GTK_CONTAINER(m_wxwindow)->border_width;
-        dw += 2 * border;
-        dh += 2 * border;
-
-        width += dw;
-        height += dh;
-    }
-
-    SetSize(width, height);
+    const wxSize size = GetSize();
+    const wxSize clientSize = GetClientSize();
+    SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));

 }
 
 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
 }
 
 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const


@@ -3188,11 +3199,13 @@ void wxWindowGTK::SetFocus()
     {
         if (GTK_IS_CONTAINER(m_widget))
         {
     {
         if (GTK_IS_CONTAINER(m_widget))
         {

+#if wxUSE_RADIOBTN

             if (IsKindOf(CLASSINFO(wxRadioButton)))
             {
                 gtk_widget_grab_focus (m_widget);
                 return;
             }
             if (IsKindOf(CLASSINFO(wxRadioButton)))
             {
                 gtk_widget_grab_focus (m_widget);
                 return;
             }

+#endif // wxUSE_RADIOBTN

 
             gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
         }
 
             gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
         }


@@ -3292,11 +3305,8 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );

-

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

-    wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
-

     /* add to list */
     AddChild( child );
 
     /* add to list */
     AddChild( child );
 


@@ -3321,7 +3331,7 @@ void wxWindowGTK::RemoveChild(wxWindowBase *child)
 /* static */
 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
 {
 /* static */
 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
 {

-    return gtk_widget_get_direction(GTK_WIDGET(widget)) == GTK_TEXT_DIR_RTL
+    return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL

                 ? wxLayout_RightToLeft
                 : wxLayout_LeftToRight;
 }
                 ? wxLayout_RightToLeft
                 : wxLayout_LeftToRight;
 }


@@ -3331,7 +3341,7 @@ void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
 {
     wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
 
 {
     wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
 

-    gtk_widget_set_direction(GTK_WIDGET(widget),
+    gtk_widget_set_direction(widget,

                              dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
                                                          : GTK_TEXT_DIR_LTR);
 }
                              dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
                                                          : GTK_TEXT_DIR_LTR);
 }


@@ -3392,7 +3402,7 @@ bool wxWindowGTK::DoNavigateIn(int flags)
     }
     else // navigate inside the container
     {
     }
     else // navigate inside the container
     {

-        wxWindow *parent = wxGetTopLevelParent(this);
+        wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);

         wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
 
         GtkDirectionType dir;
         wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
 
         GtkDirectionType dir;


@@ -3805,17 +3815,9 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
         m_tooltip->Apply( (wxWindow *)this );
 }
 
         m_tooltip->Apply( (wxWindow *)this );
 }
 

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

 {
 {

-    if (tip)
-    {
-        wxString tmp( tip );
-        gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
-    }
-    else
-    {
-        gtk_tooltips_set_tip( tips, GetConnectWidget(), NULL, NULL);
-    }
+    gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);

 }
 #endif // wxUSE_TOOLTIPS
 
 }
 #endif // wxUSE_TOOLTIPS
 


@@ -3963,11 +3965,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
 
     if (style == wxBG_STYLE_CUSTOM)
     {
 
     if (style == wxBG_STYLE_CUSTOM)
     {

-        GdkWindow *window = (GdkWindow*) NULL;
-        if (m_wxwindow)
+        GdkWindow *window;
+        if ( m_wxwindow )
+        {

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

+        }

         else
         else

-            window = GetConnectWidget()->window;
+        {
+            GtkWidget * const w = GetConnectWidget();
+            window = w ? w->window : NULL;
+        }

 
         if (window)
         {
 
         if (window)
         {


@@ -3980,9 +3987,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
 #endif
             m_needsStyleChange = false;
         }
 #endif
             m_needsStyleChange = false;
         }

-        else
+        else // window not realized yet
+        {

             // Do in OnIdle, because the window is not yet available
             m_needsStyleChange = true;
             // Do in OnIdle, because the window is not yet available
             m_needsStyleChange = true;

+        }

 
         // Don't apply widget style, or we get a grey background
     }
 
         // Don't apply widget style, or we get a grey background
     }


@@ -4098,6 +4107,14 @@ void wxWindowGTK::DoReleaseMouse()
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
 }
 
     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
 }
 

+void wxWindowGTK::GTKReleaseMouseAndNotify()
+{
+    DoReleaseMouse();
+    wxMouseCaptureLostEvent evt(GetId());
+    evt.SetEventObject( this );
+    GetEventHandler()->ProcessEvent( evt );
+}
+

 /* static */
 wxWindow *wxWindowBase::GetCapture()
 {
 /* static */
 wxWindow *wxWindowBase::GetCapture()
 {


@@ -4127,9 +4144,8 @@ void wxWindowGTK::SetScrollbar(int orient,
                                int range,
                                bool WXUNUSED(update))
 {
                                int range,
                                bool WXUNUSED(update))
 {

-    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
-    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
-    wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );

 
     if (range > 0)
     {
 
     if (range > 0)
     {


@@ -4146,7 +4162,7 @@ void wxWindowGTK::SetScrollbar(int orient,
         pos = range - thumbVisible;
     if (pos < 0)
         pos = 0;
         pos = range - thumbVisible;
     if (pos < 0)
         pos = 0;

-    GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment;
+    GtkAdjustment * const adj = sb->adjustment;

     adj->step_increment = 1;
     adj->page_increment =
     adj->page_size = thumbVisible;
     adj->step_increment = 1;
     adj->page_increment =
     adj->page_size = thumbVisible;


@@ -4157,16 +4173,15 @@ void wxWindowGTK::SetScrollbar(int orient,
 
 void wxWindowGTK::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_wxwindow != NULL, wxT("window needs client area for scrolling") );
-    wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
+    const int dir = ScrollDirFromOrient(orient);
+    GtkRange * const sb = m_scrollBar[dir];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );

 
     // This check is more than an optimization. Without it, the slider
     //   will not move smoothly while tracking when using wxScrollHelper.
     if (GetScrollPos(orient) != pos)
     {
 
     // This check is more than an optimization. Without it, the slider
     //   will not move smoothly while tracking when using wxScrollHelper.
     if (GetScrollPos(orient) != pos)
     {

-        const int dir = ScrollDirFromOrient(orient);
-        GtkAdjustment* adj = m_scrollBar[dir]->adjustment;
+        GtkAdjustment* adj = sb->adjustment;

         const int max = int(adj->upper - adj->page_size);
         if (pos > max)
             pos = max;
         const int max = int(adj->upper - adj->page_size);
         if (pos > max)
             pos = max;


@@ -4174,39 +4189,38 @@ void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
             pos = 0;
         m_scrollPos[dir] = adj->value = pos;
 
             pos = 0;
         m_scrollPos[dir] = adj->value = pos;
 

-        // If a "value_changed" signal emission is not already in progress
-        if (!m_blockValueChanged[dir])
-        {
-            gtk_adjustment_value_changed(adj);
-        }
+        g_signal_handlers_block_by_func(m_scrollBar[dir],
+            (gpointer)gtk_scrollbar_value_changed, this);
+
+        gtk_adjustment_value_changed(adj);
+
+        g_signal_handlers_unblock_by_func(m_scrollBar[dir],
+            (gpointer)gtk_scrollbar_value_changed, this);

     }
 }
 
 int wxWindowGTK::GetScrollThumb(int orient) const
 {
     }
 }
 
 int wxWindowGTK::GetScrollThumb(int orient) const
 {

-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
-    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );

 
 

-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size);
+    return int(sb->adjustment->page_size);

 }
 
 int wxWindowGTK::GetScrollPos( int orient ) const
 {
 }
 
 int wxWindowGTK::GetScrollPos( int orient ) const
 {

-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
-    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );

 
 

-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->value + 0.5);
+    return int(sb->adjustment->value + 0.5);

 }
 
 int wxWindowGTK::GetScrollRange( int orient ) const
 {
 }
 
 int wxWindowGTK::GetScrollRange( int orient ) const
 {

-    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
-    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
-    wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );

 
 

-    return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper);
+    return int(sb->adjustment->upper);

 }
 
 // Determine if increment is the same as +/-x, allowing for some small
 }
 
 // Determine if increment is the same as +/-x, allowing for some small


@@ -4271,7 +4285,7 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
     // No scrolling requested.
     if ((dx == 0) && (dy == 0)) return;
 
     // No scrolling requested.
     if ((dx == 0) && (dy == 0)) return;

-
+    

     m_clipPaintRegion = true;
 
     if (GetLayoutDirection() == wxLayout_RightToLeft)
     m_clipPaintRegion = true;
 
     if (GetLayoutDirection() == wxLayout_RightToLeft)