GetLabelTop should return the stripped label, for compatibility.

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 291b13c614a85d31b66bbcae887501068072b80d..a113e7105fddd884147f1c9246714768fafe6572 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
 //-----------------------------------------------------------------------------


@@ -469,8 +475,6 @@ gtk_window_expose_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     // This callback gets called in drawing-idle time under
     // GTK 2.0, so we don't need to defer anything to idle
     // time anymore.
     // This callback gets called in drawing-idle time under
     // GTK 2.0, so we don't need to defer anything to idle
     // time anymore.


@@ -982,8 +986,6 @@ gtk_window_key_press_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

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


@@ -1133,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;


@@ -1145,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;


@@ -1153,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


@@ -1200,8 +1206,6 @@ gtk_window_key_release_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

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


@@ -1233,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;


@@ -1378,8 +1375,6 @@ int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     if (!m_hasVMT)
         return FALSE;
     if (g_blockEventsOnDrag)
     if (!m_hasVMT)
         return FALSE;
     if (g_blockEventsOnDrag)


@@ -1445,7 +1440,7 @@ 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())
+    if (win->m_wxwindow && (g_focusWindow != win) && win->IsFocusable())

     {
         gtk_widget_grab_focus( win->m_wxwindow );
     }
     {
         gtk_widget_grab_focus( win->m_wxwindow );
     }


@@ -1547,13 +1542,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 )
     {


@@ -1587,6 +1575,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())
+    {
+        gtk_widget_grab_focus( win->m_wxwindow );
+    }
+

     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


@@ -1738,7 +1732,7 @@ gtk_window_motion_notify_callback( GtkWidget *widget,
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

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

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


@@ -1746,8 +1740,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     if (gdk_event->direction != GDK_SCROLL_UP &&
         gdk_event->direction != GDK_SCROLL_DOWN)
     {
     if (gdk_event->direction != GDK_SCROLL_UP &&
         gdk_event->direction != GDK_SCROLL_DOWN)
     {


@@ -1755,15 +1747,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)


@@ -1771,14 +1755,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);
 }
 


@@ -1804,8 +1780,6 @@ gtk_window_focus_in_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     if (win->m_imData)
         gtk_im_context_focus_in(win->m_imData->context);
 
     if (win->m_imData)
         gtk_im_context_focus_in(win->m_imData->context);
 


@@ -1856,8 +1830,6 @@ gtk_window_focus_out_callback( GtkWidget *widget,
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     if (win->m_imData)
         gtk_im_context_focus_out(win->m_imData->context);
 
     if (win->m_imData)
         gtk_im_context_focus_out(win->m_imData->context);
 


@@ -1880,12 +1852,14 @@ gtk_window_focus_out_callback( GtkWidget *widget,
     }
 #endif // wxUSE_CARET
 
     }
 #endif // wxUSE_CARET
 

-    gboolean ret = FALSE;
-

     // don't send the window a kill focus event if it thinks that it doesn't
     // have focus already
     if ( win->m_hasFocus )
     {
     // don't send the window a kill focus event if it thinks that it doesn't
     // have focus already
     if ( win->m_hasFocus )
     {

+        // the event handler might delete the window when it loses focus, so
+        // check whether this is a custom window before calling it
+        const bool has_wxwindow = win->m_wxwindow != NULL;
+

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


@@ -1893,14 +1867,13 @@ gtk_window_focus_out_callback( GtkWidget *widget,
 
         (void)win->GTKProcessEvent( event );
 
 
         (void)win->GTKProcessEvent( event );
 

-        ret = TRUE;
+        // Disable default focus handling for custom windows
+        // since the default GTK+ handler issues a repaint
+        if ( has_wxwindow )
+            return TRUE;

     }
 
     }
 

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

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -1976,8 +1949,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;


@@ -1985,17 +1956,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);
 }


@@ -2021,9 +1982,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;

     }
 }
 
     }
 }
 


@@ -2036,8 +1995,6 @@ gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    // don't need to install idle handler, its done from "event" signal
-

     g_blockEventsOnScroll = true;
     win->m_mouseButtonDown = true;
 
     g_blockEventsOnScroll = true;
     win->m_mouseButtonDown = true;
 


@@ -2091,17 +2048,11 @@ 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 )
 {
     DEBUG_MAIN_THREAD
 
 static void
 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
 {
     DEBUG_MAIN_THREAD
 

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-

     if (win->m_imData)
     {
         GtkPizza *pizza = GTK_PIZZA( m_widget );
     if (win->m_imData)
     {
         GtkPizza *pizza = GTK_PIZZA( m_widget );


@@ -2109,6 +2060,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 );


@@ -2123,9 +2084,6 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
                                GtkAllocation *alloc,
                                wxWindow *win )
 {
                                GtkAllocation *alloc,
                                wxWindow *win )
 {

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-

     int client_width = 0;
     int client_height = 0;
     win->GetClientSize( &client_width, &client_height );
     int client_width = 0;
     int client_height = 0;
     win->GetClientSize( &client_width, &client_height );


@@ -2182,7 +2140,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,


@@ -2214,6 +2172,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);


@@ -2248,9 +2208,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;


@@ -2268,7 +2226,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 =


@@ -2276,7 +2233,7 @@ void wxWindowGTK::Init()
 
     m_resizing = false;
 
 
     m_resizing = false;
 

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

 
     m_hasFocus = false;
 
 
     m_hasFocus = false;
 


@@ -2321,64 +2278,95 @@ bool wxWindowGTK::Create( wxWindow *parent,
         return false;
     }
 
         return false;
     }
 

-    m_insertCallback = wxInsertChildInWindow;
-
-    m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
-
-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
-
-    GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-    scroll_class->scrollbar_spacing = 0;
-
-    if (HasFlag(wxALWAYS_SHOW_SB))
+    if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))

     {
     {

-        gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
+        m_wxwindow = gtk_pizza_new_no_scroll();
+
+#ifndef __WXUNIVERSAL__
+        if (HasFlag(wxSIMPLE_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+        else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+#endif // __WXUNIVERSAL__

 
 

-        scrolledWindow->hscrollbar_visible = TRUE;
-        scrolledWindow->vscrollbar_visible = TRUE;
+        m_widget = m_wxwindow;

     }
     else
     {
     }
     else
     {

-        gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-    }
-
-    m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
-    m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
-    if (GetLayoutDirection() == wxLayout_RightToLeft)
-        gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
-
-    m_wxwindow = gtk_pizza_new();
+        m_wxwindow = gtk_pizza_new();

 
 #ifndef __WXUNIVERSAL__
 
 #ifndef __WXUNIVERSAL__

-    if (HasFlag(wxSIMPLE_BORDER))
-        gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
-    else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
-        gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+        if (HasFlag(wxSIMPLE_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+        else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+            gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);

 #endif // __WXUNIVERSAL__
 
 #endif // __WXUNIVERSAL__
 

-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+        m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );

 
 

-    // connect various scroll-related events
-    for ( int dir = 0; dir < ScrollDir_Max; dir++ )
-    {
-        // these handlers block mouse events to any window during scrolling
-        // such as motion events and prevent GTK and wxWidgets from fighting
-        // over where the slider should be
-        g_signal_connect(m_scrollBar[dir], "button_press_event",
+        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
+        scroll_class->scrollbar_spacing = 0;
+
+        // There is a conflict with default bindings at GTK+
+        // level between scrolled windows and notebooks both of which want to use
+        // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
+        // direction and notebooks for changing pages -- we decide that if we don't
+        // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
+        // means we can get working keyboard navigation in notebooks
+        if ( !HasFlag(wxHSCROLL) )
+        {
+            GtkBindingSet *
+                bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
+            if ( bindings )
+            {
+                gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
+                gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
+            }
+        }
+
+        if (HasFlag(wxALWAYS_SHOW_SB))
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
+
+            scrolledWindow->hscrollbar_visible = TRUE;
+            scrolledWindow->vscrollbar_visible = TRUE;
+        }
+        else
+        {
+            gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+        }
+
+        m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
+        m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+            gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
+
+        gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+
+        // connect various scroll-related events
+        for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+        {
+            // these handlers block mouse events to any window during scrolling
+            // such as motion events and prevent GTK and wxWidgets from fighting
+            // over where the slider should be
+            g_signal_connect(m_scrollBar[dir], "button_press_event",

                          G_CALLBACK(gtk_scrollbar_button_press_event), this);
                          G_CALLBACK(gtk_scrollbar_button_press_event), this);

-        g_signal_connect(m_scrollBar[dir], "button_release_event",
+            g_signal_connect(m_scrollBar[dir], "button_release_event",

                          G_CALLBACK(gtk_scrollbar_button_release_event), this);
 
                          G_CALLBACK(gtk_scrollbar_button_release_event), this);
 

-        gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
+            gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",

                                 G_CALLBACK(gtk_scrollbar_event_after), this);
                                 G_CALLBACK(gtk_scrollbar_event_after), this);

-        g_signal_handler_block(m_scrollBar[dir], handler_id);
+            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",
+            // these handlers get notified when scrollbar slider moves
+            g_signal_connect_after(m_scrollBar[dir], "value_changed",

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

-    }
+        }

 
 

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

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


@@ -2424,7 +2412,7 @@ wxWindowGTK::~wxWindowGTK()
     // delete before the widgets to avoid a crash on solaris
     delete m_imData;
 
     // delete before the widgets to avoid a crash on solaris
     delete m_imData;
 

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

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


@@ -2439,7 +2427,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.


@@ -2508,9 +2499,7 @@ void wxWindowGTK::PostCreation()
 
     if ( !AcceptsFocusFromKeyboard() )
     {
 
     if ( !AcceptsFocusFromKeyboard() )
     {

-        GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-        if ( m_wxwindow )
-            GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
+        SetCanFocus(false);

 
         g_signal_connect(m_widget, "focus",
                             G_CALLBACK(wx_window_focus_callback), this);
 
         g_signal_connect(m_widget, "focus",
                             G_CALLBACK(wx_window_focus_callback), this);


@@ -2534,6 +2523,7 @@ void wxWindowGTK::PostCreation()
                           G_CALLBACK (gtk_window_size_callback), this);
     }
 
                           G_CALLBACK (gtk_window_size_callback), this);
     }
 

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


@@ -2541,17 +2531,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


@@ -2612,6 +2603,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") );


@@ -2644,21 +2652,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


@@ -2701,12 +2701,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 );
     }


@@ -2789,7 +2789,7 @@ void wxWindowGTK::OnInternalIdle()
            windows above so that checking for the current cursor is
            not possible. */
 
            windows above so that checking for the current cursor is
            not possible. */
 

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

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


@@ -2827,25 +2827,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


@@ -2906,8 +2890,8 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const
             int org_y = 0;
             gdk_window_get_origin( source, &org_x, &org_y );
 
             int org_y = 0;
             gdk_window_get_origin( source, &org_x, &org_y );
 

-            if (GetParent())
-                GetParent()->ScreenToClient(&org_x, &org_y);
+            if (m_parent)
+                m_parent->ScreenToClient(&org_x, &org_y);

 
             wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
             wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
 
             wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
             wx_const_cast(wxWindowGTK*, this)->m_y = org_y;


@@ -3026,7 +3010,7 @@ void wxWindowGTK::DoEnable( bool enable )
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     gtk_widget_set_sensitive( m_widget, enable );
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     gtk_widget_set_sensitive( m_widget, enable );

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

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


@@ -3177,11 +3161,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 );
         }


@@ -3218,6 +3204,22 @@ void wxWindowGTK::SetFocus()
     }
 }
 
     }
 }
 

+void wxWindowGTK::SetCanFocus(bool canFocus)
+{
+    if ( canFocus )
+        GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
+    else
+        GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
+
+    if ( m_wxwindow && (m_widget != m_wxwindow) )
+    {
+        if ( canFocus )
+            GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+        else
+            GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
+    }
+}
+

 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
 {
     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
 {
     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );


@@ -3265,11 +3267,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 );
 


@@ -3281,22 +3280,20 @@ void wxWindowGTK::AddChild(wxWindowBase *child)
 {
     wxWindowBase::AddChild(child);
     m_dirtyTabOrder = true;
 {
     wxWindowBase::AddChild(child);
     m_dirtyTabOrder = true;

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();

 }
 
 void wxWindowGTK::RemoveChild(wxWindowBase *child)
 {
     wxWindowBase::RemoveChild(child);
     m_dirtyTabOrder = true;
 }
 
 void wxWindowGTK::RemoveChild(wxWindowBase *child)
 {
     wxWindowBase::RemoveChild(child);
     m_dirtyTabOrder = true;

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();

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


@@ -3306,7 +3303,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);
 }


@@ -3337,7 +3334,7 @@ void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
 
     GTKSetLayout(m_widget, dir);
 
 
     GTKSetLayout(m_widget, dir);
 

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

         GTKSetLayout(m_wxwindow, dir);
 }
 
         GTKSetLayout(m_wxwindow, dir);
 }
 


@@ -3354,8 +3351,31 @@ void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
 {
     wxWindowBase::DoMoveInTabOrder(win, move);
     m_dirtyTabOrder = true;
 {
     wxWindowBase::DoMoveInTabOrder(win, move);
     m_dirtyTabOrder = true;

-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    wxTheApp->WakeUpIdle();
+}
+
+bool wxWindowGTK::DoNavigateIn(int flags)
+{
+    if ( flags & wxNavigationKeyEvent::WinChange )
+    {
+        wxFAIL_MSG( _T("not implemented") );
+
+        return false;
+    }
+    else // navigate inside the container
+    {
+        wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
+        wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
+
+        GtkDirectionType dir;
+        dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
+                                                      : GTK_DIR_TAB_BACKWARD;
+
+        gboolean rc;
+        g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
+
+        return rc == TRUE;
+    }

 }
 
 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
 }
 
 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const


@@ -3605,7 +3625,7 @@ void wxWindowGTK::GtkUpdate()
 {
     if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
         gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
 {
     if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
         gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );

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

         gdk_window_process_updates( m_widget->window, FALSE );
 
     // for consistency with other platforms (and also because it's convenient
         gdk_window_process_updates( m_widget->window, FALSE );
 
     // for consistency with other platforms (and also because it's convenient


@@ -3757,17 +3777,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
 


@@ -3915,11 +3927,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)
         {


@@ -3932,9 +3949,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
     }


@@ -4079,8 +4098,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") );
+    GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+    wxCHECK_RET( sb, _T("this window is not scrollable") );

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


@@ -4097,7 +4116,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;


@@ -4108,15 +4127,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") );
+    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;


@@ -4124,36 +4143,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") );
+    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") );
+    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") );
+    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


@@ -4169,9 +4190,6 @@ wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    if (g_isIdle)
-        wxapp_install_idle_handler();
-

     wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
 
     const int barIndex = range == m_scrollBar[1];
     wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
 
     const int barIndex = range == m_scrollBar[1];


@@ -4221,7 +4239,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)