X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/30083ad8e7c0eb9ea3dcf4f2588149eeb7fe3e32..952a3bd46dc50f95c462606fac8214573022f612:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index a9a67e6c68..030666ca70 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -19,16 +19,11 @@ #ifndef WX_PRECOMP #include "wx/log.h" #include "wx/app.h" - #include "wx/frame.h" + #include "wx/toplevel.h" #include "wx/dcclient.h" #include "wx/menu.h" #include "wx/settings.h" #include "wx/msgdlg.h" - #include "wx/textctrl.h" - #include "wx/radiobut.h" - #include "wx/toolbar.h" - #include "wx/combobox.h" - #include "wx/layout.h" #include "wx/math.h" #endif @@ -36,6 +31,7 @@ #include "wx/tooltip.h" #include "wx/caret.h" #include "wx/fontutil.h" +#include "wx/sysopt.h" #ifdef __WXDEBUG__ #include "wx/thread.h" @@ -116,19 +112,19 @@ can find in m_widget (defined in wxWindow) When the class has a client area for drawing into and for containing children - it has to handle the client area widget (of the type GtkPizza, defined in - win_gtk.c), but there could be any number of widgets, handled by a class + it has to handle the client area widget (of the type wxPizza, defined in + win_gtk.cpp), but there could be any number of widgets, handled by a class. The common rule for all windows is only, that the widget that interacts with the rest of GTK must be referenced in m_widget and all other widgets must be children of this widget on the GTK level. The top-most widget, which also represents the client area, must be in the m_wxwindow field and must be of - the type GtkPizza. + the type wxPizza. As I said, the window classes that display a GTK native widget only have one widget, so in the case of e.g. the wxButton class m_widget holds a pointer to a GtkButton widget. But windows with client areas (for drawing and children) have a m_widget field that is a pointer to a GtkScrolled- - Window and a m_wxwindow field that is pointer to a GtkPizza and this + Window and a m_wxwindow field that is pointer to a wxPizza and this one is (in the GTK sense) a child of the GtkScrolledWindow. If the m_wxwindow field is set, then all input to this widget is inter- @@ -142,10 +138,10 @@ clicking on a scrollbar belonging to scrolled window will inevitably move the window. In wxWidgets, the scrollbar will only emit an event, send this to (normally) a wxScrolledWindow and that class will call ScrollWindow() - which actually moves the window and its sub-windows. Note that GtkPizza + which actually moves the window and its sub-windows. Note that wxPizza memorizes how much it has been scrolled but that wxWidgets forgets this so that the two coordinates systems have to be kept in synch. This is done - in various places using the pizza->xoffset and pizza->yoffset values. + in various places using the pizza->m_scroll_x and pizza->m_scroll_y values. III) @@ -190,8 +186,10 @@ // 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 @@ -314,101 +312,15 @@ static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h) } } -static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) -{ - // wxUniversal widgets draw the borders and scrollbars themselves -#ifndef __WXUNIVERSAL__ - if (!win->m_hasVMT) - return; - - int dx = 0; - int dy = 0; - if (GTK_WIDGET_NO_WINDOW (widget)) - { - dx += widget->allocation.x; - dy += widget->allocation.y; - } - - int x = dx; - int y = dy; - - int dw = 0; - int dh = 0; - if (win->m_hasScrolling) - { - GetScrollbarWidth(widget, dw, dh); - - if (win->GetLayoutDirection() == wxLayout_RightToLeft) - { - // This is actually wrong for old GTK+ version - // which do not display the scrollbar on the - // left side in RTL - x += dw; - } - } - - int w = widget->allocation.width-dw; - int h = widget->allocation.height-dh; - - if (win->HasFlag(wxRAISED_BORDER)) - { - gtk_paint_shadow (widget->style, - widget->window, - GTK_STATE_NORMAL, - GTK_SHADOW_OUT, - NULL, NULL, NULL, // FIXME: No clipping? - x, y, w, h ); - return; - } - - if (win->HasFlag(wxSUNKEN_BORDER)) - { - gtk_paint_shadow (widget->style, - widget->window, - GTK_STATE_NORMAL, - GTK_SHADOW_IN, - NULL, NULL, NULL, // FIXME: No clipping? - x, y, w, h ); - return; - } - - if (win->HasFlag(wxSIMPLE_BORDER)) - { - GdkGC *gc; - gc = gdk_gc_new( widget->window ); - gdk_gc_set_foreground( gc, &widget->style->black ); - gdk_draw_rectangle( widget->window, gc, FALSE, x, y, w-1, h-1 ); - g_object_unref (gc); - return; - } -#endif // __WXUNIVERSAL__ -} - -//----------------------------------------------------------------------------- -// "expose_event" of m_widget -//----------------------------------------------------------------------------- - -extern "C" { -static gboolean -gtk_window_own_expose_callback( GtkWidget *widget, - GdkEventExpose *gdk_event, - wxWindowGTK *win ) -{ - if (gdk_event->count == 0) - draw_frame(widget, win); - return false; -} -} - //----------------------------------------------------------------------------- // "size_request" of m_widget //----------------------------------------------------------------------------- // make it extern because wxStaticText needs to disconnect this one extern "C" { -void wxgtk_window_size_request_callback(GtkWidget *widget, +void wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget), GtkRequisition *requisition, - wxWindow *win) + wxWindow * win) { int w, h; win->GetSize( &w, &h ); @@ -422,11 +334,13 @@ void wxgtk_window_size_request_callback(GtkWidget *widget, } } +#if wxUSE_COMBOBOX + extern "C" { static -void wxgtk_combo_size_request_callback(GtkWidget *widget, +void wxgtk_combo_size_request_callback(GtkWidget * WXUNUSED(widget), GtkRequisition *requisition, - wxComboBox *win) + wxWindow* win) { // This callback is actually hooked into the text entry // of the combo box, not the GtkHBox. @@ -457,6 +371,8 @@ void wxgtk_combo_size_request_callback(GtkWidget *widget, } } +#endif // wxUSE_COMBOBOX + //----------------------------------------------------------------------------- // "expose_event" of m_wxwindow //----------------------------------------------------------------------------- @@ -469,20 +385,9 @@ gtk_window_expose_callback( GtkWidget *widget, { 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. - - GtkPizza *pizza = GTK_PIZZA( widget ); - if (gdk_event->window != pizza->bin_window) - { - // block expose events on GTK_WIDGET(pizza)->window, - // all drawing is done on pizza->bin_window - return true; - } - + // if this event is for the border-only GdkWindow + if (gdk_event->window != widget->window) + return false; #if 0 if (win->GetName()) @@ -518,6 +423,53 @@ gtk_window_expose_callback( GtkWidget *widget, } } +//----------------------------------------------------------------------------- +// "expose_event" from m_widget, for drawing border +//----------------------------------------------------------------------------- + +#ifndef __WXUNIVERSAL__ +extern "C" { +static gboolean +expose_event_border(GtkWidget* widget, GdkEventExpose* event, wxWindow* win) +{ + // if this event is not for the GdkWindow the border is drawn on + if (win->m_wxwindow == win->m_widget && event->window == widget->window) + return false; + + int x = 0; + int y = 0; + // GtkScrolledWindow is GTK_NO_WINDOW + if (GTK_WIDGET_NO_WINDOW(widget)) + { + x = widget->allocation.x; + y = widget->allocation.y; + } + int w = win->m_wxwindow->allocation.width; + int h = win->m_wxwindow->allocation.height; + if (win->HasFlag(wxBORDER_SIMPLE)) + { + GdkGC* gc; + gc = gdk_gc_new(event->window); + gdk_gc_set_foreground(gc, &widget->style->black); + gdk_draw_rectangle(event->window, gc, false, x, y, w - 1, h - 1); + g_object_unref(gc); + } + else + { + GtkShadowType shadow = GTK_SHADOW_IN; + if (win->HasFlag(wxBORDER_RAISED)) + shadow = GTK_SHADOW_OUT; + gtk_paint_shadow( + widget->style, event->window, GTK_STATE_NORMAL, + shadow, &event->area, widget, NULL, x, y, w, h); + } + + // no further painting is needed for border-only GdkWindow + return win->m_wxwindow == win->m_widget; +} +} +#endif // !__WXUNIVERSAL__ + //----------------------------------------------------------------------------- // "key_press_event" from any window //----------------------------------------------------------------------------- @@ -982,13 +934,16 @@ gtk_window_key_press_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!win->m_hasVMT) return FALSE; if (g_blockEventsOnDrag) return FALSE; + // GTK+ sends keypress events to the focus widget and then + // to all its parent and grandparent widget. We only want + // the key events from the focus widget. + if (!GTK_WIDGET_HAS_FOCUS(widget)) + return FALSE; wxKeyEvent event( wxEVT_KEY_DOWN ); bool ret = false; @@ -1006,18 +961,7 @@ gtk_window_key_press_callback( GtkWidget *widget, return_after_IM = true; } - // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw): - // When we get a key_press event here, it could be originate - // from the current widget or its child widgets. However, only the widget - // with the INPUT FOCUS can generate the INITIAL key_press event. That is, - // if the CURRENT widget doesn't have the FOCUS at all, this event definitely - // originated from its child widgets and shouldn't be passed to IM context. - // In fact, what a GTK+ IM should do is filtering keyEvents and convert them - // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current - // widgets has both IM context and input focus, the event should be filtered - // by gtk_im_context_filter_keypress(). - // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns. - if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win )) + if ((!ret) && (win->m_imData != NULL)) { // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API // docs, if IM filter returns true, no further processing should be done. @@ -1114,37 +1058,13 @@ gtk_window_key_press_callback( GtkWidget *widget, } } - // win is a control: tab can be propagated up - if ( !ret && - ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) && -// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may -// have this style, yet choose not to process this particular TAB in which -// case TAB must still work as a navigational character -// JS: enabling again to make consistent with other platforms -// (with wxTE_PROCESS_TAB you have to call Navigate to get default -// navigation behaviour) -#if wxUSE_TEXTCTRL - (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) && -#endif - 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 ); - } - return ret; } } extern "C" { static void -gtk_wxwindow_commit_cb (GtkIMContext *context, +gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context), const gchar *str, wxWindow *window) { @@ -1157,9 +1077,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, 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; @@ -1169,7 +1093,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, 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; @@ -1177,7 +1101,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; + event.m_keyCode = (char)*pstr; #endif // wxUSE_UNICODE // To conform to the docs we need to translate Ctrl-alpha @@ -1218,14 +1142,12 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, extern "C" { static gboolean -gtk_window_key_release_callback( GtkWidget *widget, +gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), GdkEventKey *gdk_event, wxWindowGTK *win ) { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!win->m_hasVMT) return FALSE; @@ -1257,22 +1179,15 @@ template void InitMouseEvent(wxWindowGTK *win, 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; @@ -1281,7 +1196,7 @@ template void InitMouseEvent(wxWindowGTK *win, if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft)) { // origin in the upper right corner - int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) ); + int window_width = win->m_wxwindow->allocation.width; event.m_x = window_width - event.m_x; } @@ -1331,9 +1246,9 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) if (win->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow); - xx += gtk_pizza_get_xoffset( pizza ); - yy += gtk_pizza_get_yoffset( pizza ); + wxPizza* pizza = WX_PIZZA(win->m_wxwindow); + xx += pizza->m_scroll_x; + yy += pizza->m_scroll_y; } wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); @@ -1402,8 +1317,6 @@ int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!m_hasVMT) return FALSE; if (g_blockEventsOnDrag) @@ -1469,11 +1382,6 @@ gtk_window_button_press_callback( GtkWidget *widget, g_lastButtonNumber = gdk_event->button; - if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus()) - { - gtk_widget_grab_focus( win->m_wxwindow ); - } - // GDK sends surplus button down events // before a double click event. We // need to filter these out. @@ -1497,10 +1405,7 @@ gtk_window_button_press_callback( GtkWidget *widget, wxEventType event_type = wxEVT_NULL; - // GdkDisplay is a GTK+ 2.2.0 thing -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0) if ( gdk_event->type == GDK_2BUTTON_PRESS && - !gtk_check_version(2,2,0) && gdk_event->button >= 1 && gdk_event->button <= 3 ) { // Reset GDK internal timestamp variables in order to disable GDK @@ -1510,7 +1415,6 @@ gtk_window_button_press_callback( GtkWidget *widget, display->button_click_time[1] = 0; display->button_click_time[0] = 0; } -#endif // GTK 2+ if (gdk_event->button == 1) { @@ -1571,13 +1475,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 ) { @@ -1611,6 +1508,12 @@ gtk_window_button_press_callback( GtkWidget *widget, 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 @@ -1683,9 +1586,9 @@ gtk_window_button_release_callback( GtkWidget *widget, event.SetId( win->GetId() ); bool ret = win->GTKProcessEvent(event); - + g_lastMouseEvent = NULL; - + return ret; } @@ -1694,7 +1597,7 @@ gtk_window_button_release_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_motion_notify_callback( GtkWidget *widget, +gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget), GdkEventMotion *gdk_event, wxWindowGTK *win ) { @@ -1762,7 +1665,7 @@ gtk_window_motion_notify_callback( GtkWidget *widget, } //----------------------------------------------------------------------------- -// "scroll_event", (mouse wheel event) +// "scroll_event" (mouse wheel event) //----------------------------------------------------------------------------- static gboolean @@ -1770,8 +1673,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) { 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) { @@ -1779,15 +1680,7 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) } 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) @@ -1795,14 +1688,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) 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); } @@ -1822,14 +1707,12 @@ static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win) //----------------------------------------------------------------------------- static gboolean -gtk_window_focus_in_callback( GtkWidget *widget, +gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget), GdkEventFocus *WXUNUSED(event), wxWindow *win ) { 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); @@ -1874,14 +1757,12 @@ gtk_window_focus_in_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_focus_out_callback( GtkWidget *widget, - GdkEventFocus *gdk_event, +gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget), + GdkEventFocus * WXUNUSED(gdk_event), wxWindowGTK *win ) { 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); @@ -1904,12 +1785,14 @@ gtk_window_focus_out_callback( GtkWidget *widget, } #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 ) { + // 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() ); @@ -1917,14 +1800,31 @@ gtk_window_focus_out_callback( GtkWidget *widget, (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; +} +static gboolean +wx_window_focus_callback(GtkWidget *widget, + GtkDirectionType WXUNUSED(direction), + wxWindowGTK *win) +{ + // the default handler for focus signal in GtkScrolledWindow sets + // focus to the window itself even if it doesn't accept focus, i.e. has no + // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing + // the signal from reaching gtk_scrolled_window_focus() if we don't have + // any children which might accept focus (we know we don't accept the focus + // ourselves as this signal is only connected in this case) + if ( win->GetChildren().empty() ) + g_signal_stop_emission_by_name(widget, "focus"); + + // we didn't change the focus return FALSE; } @@ -1981,8 +1881,6 @@ gtk_window_leave_callback( GtkWidget *widget, 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; @@ -1990,17 +1888,7 @@ gtk_window_leave_callback( GtkWidget *widget, 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); } @@ -2026,9 +1914,7 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient); event.SetEventObject(win); - win->m_blockValueChanged[dir] = true; win->GTKProcessEvent(event); - win->m_blockValueChanged[dir] = false; } } @@ -2041,8 +1927,6 @@ gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win) { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - g_blockEventsOnScroll = true; win->m_mouseButtonDown = true; @@ -2062,9 +1946,10 @@ gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win) const int orient = wxWindow::OrientFromScrollDir( win->ScrollDirFromRange(range)); - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient); - event.SetEventObject(win); - win->GTKProcessEvent(event); + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE, + win->GetScrollPos(orient), orient); + evt.SetEventObject(win); + win->GTKProcessEvent(evt); } } @@ -2096,22 +1981,25 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w // "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 ) +gtk_window_realized_callback(GtkWidget* widget, wxWindow* win) { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); - if (win->m_imData) { - GtkPizza *pizza = GTK_PIZZA( m_widget ); gtk_im_context_set_client_window( win->m_imData->context, - pizza->bin_window ); + widget->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 ); @@ -2120,42 +2008,120 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) } //----------------------------------------------------------------------------- -// "size_allocate" +// "size_allocate" from m_wxwindow or m_widget //----------------------------------------------------------------------------- -static -void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), - GtkAllocation *alloc, - wxWindow *win ) +static void +size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win) { - if (g_isIdle) - wxapp_install_idle_handler(); + int w = alloc->width; + int h = alloc->height; + if (win->m_wxwindow) + { + int border_x, border_y; + WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y); + w -= 2 * border_x; + h -= 2 * border_y; + if (w < 0) w = 0; + if (h < 0) h = 0; + } + if (win->m_oldClientWidth != w || win->m_oldClientHeight != h) + { + win->m_oldClientWidth = w; + win->m_oldClientHeight = h; + // this callback can be connected to m_wxwindow, + // so always get size from m_widget->allocation + win->m_width = win->m_widget->allocation.width; + win->m_height = win->m_widget->allocation.height; + if (!win->m_nativeSizeEvent) + { + wxSizeEvent event(win->GetSize(), win->GetId()); + event.SetEventObject(win); + win->GTKProcessEvent(event); + } + } +} - int client_width = 0; - int client_height = 0; - win->GetClientSize( &client_width, &client_height ); - if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight)) - return; +//----------------------------------------------------------------------------- +// "grab_broken" +//----------------------------------------------------------------------------- - if ( !client_width && !client_height ) +#if GTK_CHECK_VERSION(2, 8, 0) +static gboolean +gtk_window_grab_broken( GtkWidget*, + GdkEventGrabBroken *event, + wxWindow *win ) +{ + // Mouse capture has been lost involuntarily, notify the application + if(!event->keyboard && wxWindow::GetCapture() == win) { - // the window is currently unmapped, don't generate size events - return; + wxMouseCaptureLostEvent evt( win->GetId() ); + evt.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( evt ); } + return false; +} +#endif - win->m_oldClientWidth = client_width; - win->m_oldClientHeight = client_height; +//----------------------------------------------------------------------------- +// "style_set" +//----------------------------------------------------------------------------- - if (!win->m_nativeSizeEvent) +static +void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget), + GtkStyle *previous_style, + wxWindow* win ) +{ + //wxLogDebug(wxT("gtk_window_style_set_callback")); + if (win && previous_style) { - wxSizeEvent event( win->GetSize(), win->GetId() ); - event.SetEventObject( win ); + wxString name(win->GetName()); + //wxLogDebug(wxT("gtk_window_style_set_callback %s"), name.c_str()); + wxSysColourChangedEvent event; + event.SetEventObject(win); + win->GTKProcessEvent( event ); } } } // extern "C" +// Connect/disconnect style-set + +void wxConnectStyleSet(wxWindow* win) +{ + if (win->m_wxwindow) + g_signal_connect (win->m_wxwindow, "style_set", + G_CALLBACK (gtk_window_style_set_callback), win); +} + +void wxDisconnectStyleSet(wxWindow* win) +{ + if (win->m_wxwindow) + g_signal_handlers_disconnect_by_func (win->m_wxwindow, + (gpointer) gtk_window_style_set_callback, + win); +} + +// Helper to suspend colour change event event processing while we change a widget's style +class wxSuspendStyleEvents +{ +public: + wxSuspendStyleEvents(wxWindow* win) + { + m_win = win; + if (win->IsTopLevel()) + wxDisconnectStyleSet(win); + } + ~wxSuspendStyleEvents() + { + if (m_win->IsTopLevel()) + wxConnectStyleSet(m_win); + } + + wxWindow* m_win; +}; + // ---------------------------------------------------------------------------- // this wxWindowBase function is implemented here (in platform-specific file) // because it is static and so couldn't be made virtual @@ -2182,16 +2148,14 @@ static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child ) { /* the window might have been scrolled already, do we have to adapt the position */ - GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow); - child->m_x += gtk_pizza_get_xoffset( pizza ); - child->m_y += gtk_pizza_get_yoffset( pizza ); + wxPizza* pizza = WX_PIZZA(parent->m_wxwindow); + child->m_x += pizza->m_scroll_x; + child->m_y += pizza->m_scroll_y; - gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y, - child->m_width, - child->m_height ); + gtk_widget_set_size_request( + child->m_widget, child->m_width, child->m_height); + gtk_fixed_put( + GTK_FIXED(parent->m_wxwindow), child->m_widget, child->m_x, child->m_y); } //----------------------------------------------------------------------------- @@ -2219,6 +2183,8 @@ wxMouseState wxGetMouseState() 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); @@ -2253,9 +2219,7 @@ void wxWindowGTK::Init() m_width = 0; m_height = 0; - m_sizeSet = false; m_hasVMT = false; - m_needParent = true; m_isBeingDeleted = false; m_showOnIdle= false; @@ -2266,24 +2230,19 @@ void wxWindowGTK::Init() m_hasScrolling = false; m_isScrolling = false; m_mouseButtonDown = false; - m_blockScrollEvent = false; // initialize scrolling stuff for ( int dir = 0; dir < ScrollDir_Max; dir++ ) { m_scrollBar[dir] = NULL; m_scrollPos[dir] = 0; - m_blockValueChanged[dir] = false; } m_oldClientWidth = m_oldClientHeight = 0; - m_resizing = false; - - m_insertCallback = (wxInsertChildFunction) NULL; + m_insertCallback = wxInsertChildInWindow; - m_acceptsFocus = false; m_hasFocus = false; m_clipPaintRegion = false; @@ -2327,68 +2286,77 @@ bool wxWindowGTK::Create( wxWindow *parent, return false; } - m_insertCallback = wxInsertChildInWindow; - - m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); - GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); - - 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)) - { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); - - scrolledWindow->hscrollbar_visible = TRUE; - scrolledWindow->vscrollbar_visible = TRUE; - } + m_wxwindow = wxPizza::New(m_windowStyle); + if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL)) + m_widget = m_wxwindow; else { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); - } + m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); + gtk_container_set_resize_mode(GTK_CONTAINER(m_widget), GTK_RESIZE_QUEUE); - 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 ); + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); - m_wxwindow = gtk_pizza_new(); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); + scroll_class->scrollbar_spacing = 0; -#ifndef __WXUNIVERSAL__ - if (HasFlag(wxSIMPLE_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1); - else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2); -#endif // __WXUNIVERSAL__ + // There is a conflict with default bindings at GTK+ + // level between scrolled windows and notebooks both of which want to use + // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal + // direction and notebooks for changing pages -- we decide that if we don't + // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it + // means we can get working keyboard navigation in notebooks + if ( !HasFlag(wxHSCROLL) ) + { + GtkBindingSet * + bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget)); + if ( bindings ) + { + gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK); + gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK); + } + } - gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); + if (HasFlag(wxALWAYS_SHOW_SB)) + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); - GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); - m_acceptsFocus = true; + scrolledWindow->hscrollbar_visible = TRUE; + scrolledWindow->vscrollbar_visible = TRUE; + } + else + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); + } - // 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", + 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_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); - 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_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); - } + } - gtk_widget_show( m_wxwindow ); + gtk_widget_show( m_wxwindow ); + } if (m_parent) m_parent->DoAddChild( this ); @@ -2434,7 +2402,7 @@ wxWindowGTK::~wxWindowGTK() // 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; @@ -2449,7 +2417,10 @@ wxWindowGTK::~wxWindowGTK() 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. @@ -2476,7 +2447,7 @@ void wxWindowGTK::PostCreation() G_CALLBACK (gtk_window_expose_callback), this); if (GetLayoutDirection() == wxLayout_LeftToRight) - gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) ); + gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE)); } // Create input method handler @@ -2488,9 +2459,14 @@ void wxWindowGTK::PostCreation() g_signal_connect (m_imData->context, "commit", G_CALLBACK (gtk_wxwindow_commit_cb), this); - // these are called when the "sunken" or "raised" borders are drawn - g_signal_connect (m_widget, "expose_event", - G_CALLBACK (gtk_window_own_expose_callback), this); + // border drawing +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxBORDER_SIMPLE | wxBORDER_RAISED | wxBORDER_SUNKEN)) + { + g_signal_connect(m_widget, "expose_event", + G_CALLBACK(expose_event_border), this); + } +#endif } // focus handling @@ -2516,6 +2492,14 @@ void wxWindowGTK::PostCreation() } } + if ( !AcceptsFocusFromKeyboard() ) + { + SetCanFocus(false); + + g_signal_connect(m_widget, "focus", + G_CALLBACK(wx_window_focus_callback), this); + } + // connect to the various key and mouse handlers GtkWidget *connect_widget = GetConnectWidget(); @@ -2527,13 +2511,37 @@ void wxWindowGTK::PostCreation() g_signal_connect (connect_widget, "realize", G_CALLBACK (gtk_window_realized_callback), this); + if (!IsTopLevel()) + { + g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate", + G_CALLBACK(size_allocate), this); + } + if (m_wxwindow) { - // Catch native resize events - g_signal_connect (m_wxwindow, "size_allocate", - G_CALLBACK (gtk_window_size_callback), this); +#if GTK_CHECK_VERSION(2, 8, 0) + 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 ) + { +#if GTK_CHECK_VERSION(2, 8, 0) + 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); @@ -2541,17 +2549,18 @@ void wxWindowGTK::PostCreation() 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 - 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 ? - } + } else #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 @@ -2594,6 +2603,10 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) G_CALLBACK (gtk_window_enter_callback), this); g_signal_connect (widget, "leave_notify_event", G_CALLBACK (gtk_window_leave_callback), this); + + if (IsTopLevel() && m_wxwindow) + g_signal_connect (m_wxwindow, "style_set", + G_CALLBACK (gtk_window_style_set_callback), this); } bool wxWindowGTK::Destroy() @@ -2607,9 +2620,26 @@ bool wxWindowGTK::Destroy() void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { + gtk_widget_set_size_request(m_widget, width, height); // inform the parent to perform the move - gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); + WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y); +} +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 ) @@ -2617,9 +2647,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") ); - if (m_resizing) return; /* I don't like recursions */ - m_resizing = true; - int currentX, currentY; GetPosition(¤tX, ¤tY); if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) @@ -2639,51 +2666,19 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags height = sizeBest.y; } + const wxSize oldSize(m_width, m_height); if (width != -1) m_width = width; 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 - GtkWidget *widget = GTK_WIDGET(m_widget); - gtk_widget_set_size_request (widget, m_width, m_height); - } - else -#endif - if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook - { - // don't set the size for children of wxNotebook, just take the values. - m_x = x; - m_y = y; - m_width = width; - m_height = height; - } - else + if (m_parent->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); - if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0) - { - if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza ); - if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza ); - } - else - { - m_x = x + gtk_pizza_get_xoffset( pizza ); - m_y = y + gtk_pizza_get_yoffset( pizza ); - } + wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow); + m_x = x + pizza->m_scroll_x; + m_y = y + pizza->m_scroll_y; int left_border = 0; int right_border = 0; @@ -2701,42 +2696,30 @@ 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; - 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 ); } - if (m_hasScrolling) + if (m_width != oldSize.x || m_height != oldSize.y) { - /* Sometimes the client area changes size without the - whole windows's size changing, but if the whole - windows's size doesn't change, no wxSizeEvent will - normally be sent. Here we add an extra test if - the client test has been changed and this will - be used then. */ + // update these variables to keep size_allocate handler + // from sending another size event for this change GetClientSize( &m_oldClientWidth, &m_oldClientHeight ); - } - -/* - wxPrintf( "OnSize sent from " ); - if (GetClassInfo() && GetClassInfo()->GetClassName()) - wxPrintf( GetClassInfo()->GetClassName() ); - wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height ); -*/ - if (!m_nativeSizeEvent) - { - wxSizeEvent event( wxSize(m_width,m_height), GetId() ); - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( event ); + gtk_widget_queue_resize(m_widget); + if (!m_nativeSizeEvent) + { + wxSizeEvent event( wxSize(m_width,m_height), GetId() ); + event.SetEventObject( this ); + GetEventHandler()->ProcessEvent( event ); + } } - - m_resizing = false; } bool wxWindowGTK::GtkShowFromOnIdle() @@ -2789,9 +2772,9 @@ void wxWindowGTK::OnInternalIdle() 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; + GdkWindow *window = m_wxwindow->window; if (window) gdk_window_set_cursor( window, cursor.GetCursor() ); @@ -2811,7 +2794,7 @@ void wxWindowGTK::OnInternalIdle() } } - if (wxUpdateUIEvent::CanUpdate(this)) + if (wxUpdateUIEvent::CanUpdate(this) && IsShown()) UpdateWindowUI(wxUPDATE_UI_FROMIDLE); } @@ -2827,25 +2810,9 @@ void wxWindowGTK::DoSetClientSize( int width, int height ) { 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 @@ -2863,9 +2830,10 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const if (m_hasScrolling) GetScrollbarWidth(m_widget, dw, dh); - const int border = GTK_CONTAINER(m_wxwindow)->border_width; - dw += 2 * border; - dh += 2 * border; + int border_x, border_y; + WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y); + dw += 2 * border_x; + dh += 2 * border_y; w -= dw; h -= dh; @@ -2885,18 +2853,18 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const int dx = 0; int dy = 0; - if (m_parent && m_parent->m_wxwindow) + if (!IsTopLevel() && m_parent && m_parent->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); - dx = gtk_pizza_get_xoffset( pizza ); - dy = gtk_pizza_get_yoffset( pizza ); + wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow); + dx = pizza->m_scroll_x; + dy = pizza->m_scroll_y; } if (m_x == -1 && m_y == -1) { GdkWindow *source = (GdkWindow *) NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = m_wxwindow->window; else source = m_widget->window; @@ -2906,8 +2874,8 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const 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; @@ -2926,7 +2894,7 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const GdkWindow *source = (GdkWindow *) NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = m_wxwindow->window; else source = m_widget->window; @@ -2963,7 +2931,7 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const GdkWindow *source = (GdkWindow *) NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = m_wxwindow->window; else source = m_widget->window; @@ -3021,40 +2989,13 @@ bool wxWindowGTK::Show( bool show ) return true; } -static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable) +void wxWindowGTK::DoEnable( bool enable ) { - win->OnParentEnable(enable); - - // Recurse, so that children have the opportunity to Do The Right Thing - // and reset colours that have been messed up by a parent's (really ancestor's) - // Enable call - for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); - node; - node = node->GetNext() ) - { - wxWindow *child = node->GetData(); - if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame))) - wxWindowNotifyEnable(child, enable); - } -} - -bool wxWindowGTK::Enable( bool enable ) -{ - wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); - - if (!wxWindowBase::Enable(enable)) - { - // nothing to do - return false; - } + 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 ); - - wxWindowNotifyEnable(this, enable); - - return true; } int wxWindowGTK::GetCharHeight() const @@ -3064,9 +3005,7 @@ int wxWindowGTK::GetCharHeight() const wxFont font = GetFont(); wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") ); - PangoContext *context = NULL; - if (m_widget) - context = gtk_widget_get_pango_context( m_widget ); + PangoContext* context = gtk_widget_get_pango_context(m_widget); if (!context) return 0; @@ -3092,9 +3031,7 @@ int wxWindowGTK::GetCharWidth() const wxFont font = GetFont(); wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") ); - PangoContext *context = NULL; - if (m_widget) - context = gtk_widget_get_pango_context( m_widget ); + PangoContext* context = gtk_widget_get_pango_context(m_widget); if (!context) return 0; @@ -3195,16 +3132,26 @@ void wxWindowGTK::SetFocus() if (m_wxwindow) { + // wxWindow::SetFocus() should really set the focus to + // this control, whatever the flags are + if (!GTK_WIDGET_CAN_FOCUS(m_wxwindow)) + GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow)) { gtk_widget_grab_focus (m_wxwindow); } } - else if (m_widget) + else { + // wxWindow::SetFocus() should really set the focus to + // this control, whatever the flags are + if (!GTK_WIDGET_CAN_FOCUS(m_widget)) + GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS); + if (GTK_IS_CONTAINER(m_widget)) { - if (IsKindOf(CLASSINFO(wxRadioButton))) + if (GTK_IS_RADIO_BUTTON(m_widget)) { gtk_widget_grab_focus (m_widget); return; @@ -3245,9 +3192,20 @@ void wxWindowGTK::SetFocus() } } -bool wxWindowGTK::AcceptsFocus() const +void wxWindowGTK::SetCanFocus(bool canFocus) { - return m_acceptsFocus && wxWindowBase::AcceptsFocus(); + if ( canFocus ) + GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS); + else + GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS); + + if ( m_wxwindow && (m_widget != m_wxwindow) ) + { + if ( canFocus ) + GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + else + GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + } } bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) @@ -3297,11 +3255,8 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) void wxWindowGTK::DoAddChild(wxWindowGTK *child) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); - wxASSERT_MSG( (child != NULL), wxT("invalid child window") ); - wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") ); - /* add to list */ AddChild( child ); @@ -3313,22 +3268,20 @@ void wxWindowGTK::AddChild(wxWindowBase *child) { 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; - if (g_isIdle) - wxapp_install_idle_handler(); + wxTheApp->WakeUpIdle(); } /* 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; } @@ -3338,7 +3291,7 @@ void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir) { 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); } @@ -3369,7 +3322,7 @@ void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir) GTKSetLayout(m_widget, dir); - if (m_wxwindow) + if (m_wxwindow && (m_wxwindow != m_widget)) GTKSetLayout(m_wxwindow, dir); } @@ -3378,7 +3331,7 @@ wxWindowGTK::AdjustForLayoutDirection(wxCoord x, wxCoord WXUNUSED(width), wxCoord WXUNUSED(widthTotal)) const { - // We now mirrors the coordinates of RTL windows in GtkPizza + // We now mirror the coordinates of RTL windows in wxPizza return x; } @@ -3386,8 +3339,31 @@ void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move) { 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 @@ -3538,7 +3514,7 @@ void wxWindowGTK::WarpPointer( int x, int y ) GdkWindow *window = (GdkWindow*) NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -3589,7 +3565,8 @@ bool wxWindowGTK::ScrollPages(int pages) return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages); } -void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) +void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground), + const wxRect *rect) { if (!m_widget) return; @@ -3598,7 +3575,7 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) if (m_wxwindow) { - if (!GTK_PIZZA(m_wxwindow)->bin_window) return; + if (m_wxwindow->window == NULL) return; GdkRectangle gdk_rect, *p; @@ -3618,7 +3595,7 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) p = NULL; } - gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE ); + gdk_window_invalidate_rect(m_wxwindow->window, p, true); } } @@ -3635,9 +3612,9 @@ void wxWindowGTK::Update() 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_widget && m_widget->window) + if (m_wxwindow && m_wxwindow->window) + gdk_window_process_updates(m_wxwindow->window, false); + if (m_widget && m_widget->window && (m_wxwindow != m_widget)) gdk_window_process_updates( m_widget->window, FALSE ); // for consistency with other platforms (and also because it's convenient @@ -3684,8 +3661,7 @@ void wxWindowGTK::GtkSendPaintEvents() m_updateRegion.Clear(); gint width; - gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window, - NULL, NULL, &width, NULL, NULL ); + gdk_drawable_get_size(m_wxwindow->window, &width, NULL); wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) @@ -3703,9 +3679,6 @@ void wxWindowGTK::GtkSendPaintEvents() } } - // widget to draw on - GtkPizza *pizza = GTK_PIZZA (m_wxwindow); - if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM)) { // find ancestor from which to steal background @@ -3725,7 +3698,7 @@ void wxWindowGTK::GtkSendPaintEvents() rect.height = upd.GetHeight(); gtk_paint_flat_box( parent->m_widget->style, - pizza->bin_window, + m_wxwindow->window, (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), GTK_SHADOW_NONE, &rect, @@ -3742,6 +3715,14 @@ void wxWindowGTK::GtkSendPaintEvents() wxWindowDC dc( (wxWindow*)this ); dc.SetClippingRegion( m_updateRegion ); + // Work around gtk-qt <= 0.60 bug whereby the window colour + // remains grey + if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1) + { + dc.SetBackground(wxBrush(GetBackgroundColour())); + dc.Clear(); + } + wxEraseEvent erase_event( GetId(), &dc ); erase_event.SetEventObject( this ); @@ -3789,17 +3770,9 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip ) 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 @@ -3869,45 +3842,54 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) pango_font_description_copy( m_font.GetNativeFontInfo()->description ); } + int flagsNormal = 0, + flagsPrelight = 0, + flagsActive = 0, + flagsInsensitive = 0; + if ( m_foregroundColour.Ok() ) { const GdkColor *fg = m_foregroundColour.GetColor(); - style->fg[GTK_STATE_NORMAL] = *fg; - style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG; + style->fg[GTK_STATE_NORMAL] = + style->text[GTK_STATE_NORMAL] = *fg; + flagsNormal |= GTK_RC_FG | GTK_RC_TEXT; - style->fg[GTK_STATE_PRELIGHT] = *fg; - style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG; + style->fg[GTK_STATE_PRELIGHT] = + style->text[GTK_STATE_PRELIGHT] = *fg; + flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT; - style->fg[GTK_STATE_ACTIVE] = *fg; - style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG; + style->fg[GTK_STATE_ACTIVE] = + style->text[GTK_STATE_ACTIVE] = *fg; + flagsActive |= GTK_RC_FG | GTK_RC_TEXT; } if ( m_backgroundColour.Ok() ) { const GdkColor *bg = m_backgroundColour.GetColor(); - style->bg[GTK_STATE_NORMAL] = *bg; + style->bg[GTK_STATE_NORMAL] = style->base[GTK_STATE_NORMAL] = *bg; - style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags) - (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE); + flagsNormal |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_PRELIGHT] = *bg; + style->bg[GTK_STATE_PRELIGHT] = style->base[GTK_STATE_PRELIGHT] = *bg; - style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags) - (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE); + flagsPrelight |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_ACTIVE] = *bg; + style->bg[GTK_STATE_ACTIVE] = style->base[GTK_STATE_ACTIVE] = *bg; - style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags) - (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE); + flagsActive |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_INSENSITIVE] = *bg; + style->bg[GTK_STATE_INSENSITIVE] = style->base[GTK_STATE_INSENSITIVE] = *bg; - style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags) - (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE); + flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE; } + style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal; + style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight; + style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive; + style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive; + return style; } @@ -3926,6 +3908,8 @@ void wxWindowGTK::ApplyWidgetStyle(bool forceStyle) void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) { + wxSuspendStyleEvents s(static_cast(this)); + if (m_wxwindow) gtk_widget_modify_style(m_wxwindow, style); else @@ -3938,11 +3922,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) if (style == wxBG_STYLE_CUSTOM) { - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + GdkWindow *window; + if ( m_wxwindow ) + { + window = m_wxwindow->window; + } else - window = GetConnectWidget()->window; + { + GtkWidget * const w = GetConnectWidget(); + window = w ? w->window : NULL; + } if (window) { @@ -3955,9 +3944,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) #endif m_needsStyleChange = false; } - else + else // window not realized yet + { // Do in OnIdle, because the window is not yet available m_needsStyleChange = true; + } // Don't apply widget style, or we get a grey background } @@ -4007,7 +3998,7 @@ bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const { - return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window; + return m_wxwindow ? m_wxwindow->window : m_widget->window; } bool wxWindowGTK::SetFont( const wxFont &font ) @@ -4030,7 +4021,7 @@ void wxWindowGTK::DoCaptureMouse() GdkWindow *window = (GdkWindow*) NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -4063,7 +4054,7 @@ void wxWindowGTK::DoReleaseMouse() GdkWindow *window = (GdkWindow*) NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -4073,6 +4064,14 @@ void wxWindowGTK::DoReleaseMouse() gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); } +void wxWindowGTK::GTKReleaseMouseAndNotify() +{ + DoReleaseMouse(); + wxMouseCaptureLostEvent evt(GetId()); + evt.SetEventObject( this ); + GetEventHandler()->ProcessEvent( evt ); +} + /* static */ wxWindow *wxWindowBase::GetCapture() { @@ -4084,26 +4083,15 @@ bool wxWindowGTK::IsRetained() const return false; } -void wxWindowGTK::BlockScrollEvent() -{ - wxASSERT(!m_blockScrollEvent); - m_blockScrollEvent = true; -} - -void wxWindowGTK::UnblockScrollEvent() -{ - wxASSERT(m_blockScrollEvent); - m_blockScrollEvent = false; -} - void wxWindowGTK::SetScrollbar(int orient, int pos, int thumbVisible, int range, bool WXUNUSED(update)) { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); + const int dir = ScrollDirFromOrient(orient); + GtkRange* const sb = m_scrollBar[dir]; + wxCHECK_RET( sb, _T("this window is not scrollable") ); if (range > 0) { @@ -4116,67 +4104,65 @@ void wxWindowGTK::SetScrollbar(int orient, thumbVisible = 1; } - if (pos > range - thumbVisible) - 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->upper = range; - SetScrollPos(orient, pos); - gtk_adjustment_changed(adj); + adj->value = pos; + + g_signal_handlers_block_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); + + gtk_range_set_range(sb, 0, range); + m_scrollPos[dir] = sb->adjustment->value; + + g_signal_handlers_unblock_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); } 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) { - const int dir = ScrollDirFromOrient(orient); - GtkAdjustment* adj = m_scrollBar[dir]->adjustment; - const int max = int(adj->upper - adj->page_size); - if (pos > max) - pos = max; - if (pos < 0) - pos = 0; - m_scrollPos[dir] = adj->value = pos; - - // If a "value_changed" signal emission is not already in progress - if (!m_blockValueChanged[dir]) - { - gtk_adjustment_value_changed(adj); - } + g_signal_handlers_block_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); + + gtk_range_set_value(sb, pos); + m_scrollPos[dir] = sb->adjustment->value; + + g_signal_handlers_unblock_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); } } 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 { - 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 { - 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 @@ -4192,9 +4178,6 @@ wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range) { 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]; @@ -4247,10 +4230,7 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) m_clipPaintRegion = true; - if (GetLayoutDirection() == wxLayout_RightToLeft) - gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy ); - else - gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); + WX_PIZZA(m_wxwindow)->scroll(dx, dy); m_clipPaintRegion = false; @@ -4290,8 +4270,11 @@ void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle) gtkstyle = GTK_SHADOW_OUT; else if (wxstyle & wxBORDER_SUNKEN) gtkstyle = GTK_SHADOW_IN; +#if 0 + // Now obsolete else if (wxstyle & wxBORDER_DOUBLE) gtkstyle = GTK_SHADOW_ETCHED_IN; +#endif else //default gtkstyle = GTK_SHADOW_IN; @@ -4355,3 +4338,11 @@ void wxRemoveGrab(wxWindow* window) { gtk_grab_remove( (GtkWidget*) window->GetHandle() ); } + +GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const +{ + GdkWindow* window = NULL; + if (m_wxwindow) + window = m_wxwindow->window; + return window; +}