X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/76b49cf49ba9ee9f3eeec9730cb4bc4569ab17f1..14e9ff98e683a46d71e2fe19306f2c26086ddb21:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index d7d79ebf1a..a6544f8fe6 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -22,17 +22,20 @@ #include "wx/app.h" #include "wx/utils.h" #include "wx/frame.h" + #include "wx/dcclient.h" + #include "wx/menu.h" + #include "wx/dialog.h" + #include "wx/settings.h" + #include "wx/msgdlg.h" + #include "wx/textctrl.h" + #include "wx/toolbar.h" + #include "wx/combobox.h" + #include "wx/layout.h" + #include "wx/statusbr.h" + #include "wx/math.h" #endif -#include "wx/dcclient.h" -#include "wx/layout.h" -#include "wx/dialog.h" -#include "wx/msgdlg.h" #include "wx/module.h" -#include "wx/combobox.h" -#if wxUSE_TOOLBAR_NATIVE -#include "wx/toolbar.h" -#endif #if wxUSE_DRAG_AND_DROP #include "wx/dnd.h" @@ -46,20 +49,12 @@ #include "wx/caret.h" #endif // wxUSE_CARET -#if wxUSE_TEXTCTRL - #include "wx/textctrl.h" -#endif - -#include "wx/menu.h" -#include "wx/statusbr.h" -#include "wx/settings.h" #include "wx/fontutil.h" #ifdef __WXDEBUG__ #include "wx/thread.h" #endif -#include "wx/math.h" #include // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0 @@ -127,7 +122,7 @@ extern GtkContainerClass *pizza_parent_class; 6) Display a border (sunken, raised, simple or none). Normally one might expect, that one wxWidgets window would always correspond - to one GTK widget. Under GTK, there is no such allround widget that has all + to one GTK widget. Under GTK, there is no such all-round widget that has all the functionality. Moreover, the GTK defines a client area as a different widget from the actual widget you are handling. Last but not least some special classes (e.g. wxFrame) handle different categories of widgets and @@ -172,14 +167,14 @@ extern GtkContainerClass *pizza_parent_class; 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 subchildren. Note that GtkPizza + which actually moves the window and its sub-windows. Note that GtkPizza 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. III) - Singularily the most broken code in GTK is the code that is supposed to + Singularly the most broken code in GTK is the code that is supposed to inform subwindows (child windows) about new positions. Very often, duplicate events are sent without changes in size or position, equally often no events are sent at all (All this is due to a bug in the GtkContainer code @@ -220,13 +215,10 @@ extern GtkContainerClass *pizza_parent_class; // data //----------------------------------------------------------------------------- -extern wxList wxPendingDelete; extern bool g_blockEventsOnDrag; extern bool g_blockEventsOnScroll; extern wxCursor g_globalCursor; -static GdkGC *g_eraseGC = NULL; - // mouse capture state: the window which has it and if the mouse is currently // inside it static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL; @@ -397,7 +389,7 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) gdk_draw_rectangle( widget->window, gc, FALSE, dx, dy, widget->allocation.width-dw-1, widget->allocation.height-dh-1 ); - g_object_unref (G_OBJECT (gc)); + g_object_unref (gc); return; } #endif // __WXUNIVERSAL__ @@ -486,8 +478,7 @@ gtk_window_expose_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // 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 @@ -537,6 +528,18 @@ gtk_window_expose_callback( GtkWidget *widget, // "key_press_event" from any window //----------------------------------------------------------------------------- +// These are used when transforming Ctrl-alpha to ascii values 1-26 +inline bool wxIsLowerChar(int code) +{ + return (code >= 'a' && code <= 'z' ); +} + +inline bool wxIsUpperChar(int code) +{ + return (code >= 'A' && code <= 'Z' ); +} + + // set WXTRACE to this to see the key event codes on the console #define TRACE_KEYS _T("keyevent") @@ -973,7 +976,7 @@ struct wxGtkIMData } ~wxGtkIMData() { - g_object_unref(context); + g_object_unref (context); } }; @@ -985,8 +988,7 @@ gtk_window_key_press_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // don't need to install idle handler, its done from "event" signal if (!win->m_hasVMT) return FALSE; @@ -1088,9 +1090,13 @@ gtk_window_key_press_callback( GtkWidget *widget, // To conform to the docs we need to translate Ctrl-alpha // characters to values in the range 1-26. - if (event.ControlDown() && key_code >= 'a' && key_code <= 'z' ) + if ( event.ControlDown() && + ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) )) { - event.m_keyCode = key_code - 'a' + 1; + if ( wxIsLowerChar(key_code) ) + event.m_keyCode = key_code - 'a' + 1; + if ( wxIsUpperChar(key_code) ) + event.m_keyCode = key_code - 'A' + 1; #if wxUSE_UNICODE event.m_uniChar = event.m_keyCode; #endif @@ -1114,10 +1120,6 @@ 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)) && @@ -1142,50 +1144,7 @@ gtk_window_key_press_callback( GtkWidget *widget, ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event ); } - // generate wxID_CANCEL if has been pressed (typically in dialogs) - if ( !ret && - (gdk_event->keyval == GDK_Escape) ) - { - // however only do it if we have a Cancel button in the dialog, - // otherwise the user code may get confused by the events from a - // non-existing button and, worse, a wxButton might get button event - // from another button which is not really expected - wxWindow *winForCancel = win, - *btnCancel = NULL; - while ( winForCancel ) - { - btnCancel = winForCancel->FindWindow(wxID_CANCEL); - if ( btnCancel ) - { - // found a cancel button - break; - } - - if ( winForCancel->IsTopLevel() ) - { - // no need to look further - break; - } - - // maybe our parent has a cancel button? - winForCancel = winForCancel->GetParent(); - } - - if ( btnCancel ) - { - wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); - eventClick.SetEventObject(btnCancel); - ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick); - } - } - - if (ret) - { - g_signal_stop_emission_by_name (widget, "key_press_event"); - return TRUE; - } - - return FALSE; + return ret; } } @@ -1229,8 +1188,14 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, // To conform to the docs we need to translate Ctrl-alpha // characters to values in the range 1-26. - if (event.ControlDown() && *pstr >= 'a' && *pstr <= 'z' ) + if ( event.ControlDown() && + ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) )) { + if ( wxIsLowerChar(*pstr) ) + event.m_keyCode = *pstr - 'a' + 1; + if ( wxIsUpperChar(*pstr) ) + event.m_keyCode = *pstr - 'A' + 1; + event.m_keyCode = *pstr - 'a' + 1; #if wxUSE_UNICODE event.m_uniChar = event.m_keyCode; @@ -1265,8 +1230,7 @@ gtk_window_key_release_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // don't need to install idle handler, its done from "event" signal if (!win->m_hasVMT) return FALSE; @@ -1281,11 +1245,7 @@ gtk_window_key_release_callback( GtkWidget *widget, return FALSE; } - if ( !win->GetEventHandler()->ProcessEvent( event ) ) - return FALSE; - - g_signal_stop_emission_by_name (widget, "key_release_event"); - return TRUE; + return win->GetEventHandler()->ProcessEvent(event); } } @@ -1427,42 +1387,82 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) return win; } +// ---------------------------------------------------------------------------- +// common event handlers helpers +// ---------------------------------------------------------------------------- + +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) + return TRUE; + if (g_blockEventsOnScroll) + return TRUE; + + if (!GTKIsOwnWindow(event->window)) + return FALSE; + + return -1; +} + +// overloads for all GDK event types we use here: we need to have this as +// GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact, +// derives from it in the sense that the structs have the same layout +#define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \ + static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \ + { \ + return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \ + } + +wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton) +wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion) +wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing) + +#undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD + +#define wxCOMMON_CALLBACK_PROLOGUE(event, win) \ + const int rc = wxGtkCallbackCommonPrologue(event, win); \ + if ( rc != -1 ) \ + return rc + +// send the wxChildFocusEvent and wxFocusEvent, common code of +// gtk_window_focus_in_callback() and SetFocus() +static bool DoSendFocusEvents(wxWindow *win) +{ + // Notify the parent keeping track of focus for the kbd navigation + // purposes that we got it. + wxChildFocusEvent eventChildFocus(win); + (void)win->GetEventHandler()->ProcessEvent(eventChildFocus); + + wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId()); + eventFocus.SetEventObject(win); + + return win->GetEventHandler()->ProcessEvent(eventFocus); +} + +// all event handlers must have C linkage as they're called from GTK+ C code +extern "C" +{ + //----------------------------------------------------------------------------- // "button_press_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - -/* - wxPrintf( wxT("1) OnButtonPress from ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(".\n") ); -*/ - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return TRUE; - if (g_blockEventsOnScroll) return TRUE; - - if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus()) { gtk_widget_grab_focus( win->m_wxwindow ); -/* - wxPrintf( wxT("GrabFocus from ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(".\n") ); -*/ } // GDK sends surplus button down events @@ -1597,7 +1597,6 @@ gtk_window_button_press_callback( GtkWidget *widget, if (win->GetEventHandler()->ProcessEvent( event )) { - g_signal_stop_emission_by_name (widget, "button_press_event"); return TRUE; } @@ -1620,28 +1619,17 @@ gtk_window_button_press_callback( GtkWidget *widget, return FALSE; } -} //----------------------------------------------------------------------------- // "button_release_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; - if (g_blockEventsOnScroll) return FALSE; - - if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); wxEventType event_type = wxEVT_NULL; @@ -1660,7 +1648,7 @@ gtk_window_button_release_callback( GtkWidget *widget, break; default: - // unknwon button, don't process + // unknown button, don't process return FALSE; } @@ -1679,36 +1667,19 @@ gtk_window_button_release_callback( GtkWidget *widget, event.SetEventObject( win ); event.SetId( win->GetId() ); - if (win->GetEventHandler()->ProcessEvent( event )) - { - g_signal_stop_emission_by_name (widget, "button_release_event"); - return TRUE; - } - - return FALSE; -} + return win->GetEventHandler()->ProcessEvent(event); } //----------------------------------------------------------------------------- // "motion_notify_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; - if (g_blockEventsOnScroll) return FALSE; - - if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); if (gdk_event->is_hint) { @@ -1720,19 +1691,12 @@ gtk_window_motion_notify_callback( GtkWidget *widget, gdk_event->y = y; } -/* - printf( "OnMotion from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ - wxMouseEvent event( wxEVT_MOTION ); InitMouseEvent(win, event, gdk_event); if ( g_captureWindow ) { - // synthetize a mouse enter or leave event if needed + // synthesise a mouse enter or leave event if needed GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL); // This seems to be necessary and actually been added to // GDK itself in version 2.0.X @@ -1769,40 +1733,27 @@ gtk_window_motion_notify_callback( GtkWidget *widget, } } - if (win->GetEventHandler()->ProcessEvent( event )) - { - g_signal_stop_emission_by_name (widget, "motion_notify_event"); - return TRUE; - } - - return FALSE; -} + return win->GetEventHandler()->ProcessEvent(event); } //----------------------------------------------------------------------------- -// "mouse_wheel_event" +// "scroll_event", (mouse wheel event) //----------------------------------------------------------------------------- -extern "C" { static gboolean -gtk_window_wheel_callback (GtkWidget * widget, - GdkEventScroll * gdk_event, - wxWindowGTK * win) +window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // don't need to install idle handler, its done from "event" signal - wxEventType event_type = wxEVT_NULL; - if (gdk_event->direction == GDK_SCROLL_UP) - event_type = wxEVT_MOUSEWHEEL; - else if (gdk_event->direction == GDK_SCROLL_DOWN) - event_type = wxEVT_MOUSEWHEEL; - else - return FALSE; + if (gdk_event->direction != GDK_SCROLL_UP && + gdk_event->direction != GDK_SCROLL_DOWN) + { + return false; + } - wxMouseEvent event( event_type ); + 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); @@ -1827,51 +1778,24 @@ gtk_window_wheel_callback (GtkWidget * widget, event.SetId( win->GetId() ); event.SetTimestamp( gdk_event->time ); - if (win->GetEventHandler()->ProcessEvent( event )) - { - g_signal_stop_emission_by_name (widget, "scroll_event"); - return TRUE; - } - - return FALSE; -} + return win->GetEventHandler()->ProcessEvent(event); } //----------------------------------------------------------------------------- // "popup-menu" //----------------------------------------------------------------------------- -extern "C" { + static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win) { - wxContextMenuEvent event( - wxEVT_CONTEXT_MENU, - win->GetId(), - wxPoint(-1, -1)); + wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1)); event.SetEventObject(win); return win->GetEventHandler()->ProcessEvent(event); } -} //----------------------------------------------------------------------------- // "focus_in_event" //----------------------------------------------------------------------------- -// send the wxChildFocusEvent and wxFocusEvent, common code of -// gtk_window_focus_in_callback() and SetFocus() -static bool DoSendFocusEvents(wxWindow *win) -{ - // Notify the parent keeping track of focus for the kbd navigation - // purposes that we got it. - wxChildFocusEvent eventChildFocus(win); - (void)win->GetEventHandler()->ProcessEvent(eventChildFocus); - - wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId()); - eventFocus.SetEventObject(win); - - return win->GetEventHandler()->ProcessEvent(eventFocus); -} - -extern "C" { static gboolean gtk_window_focus_in_callback( GtkWidget *widget, GdkEventFocus *WXUNUSED(event), @@ -1879,8 +1803,7 @@ gtk_window_focus_in_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // 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); @@ -1925,13 +1848,11 @@ gtk_window_focus_in_callback( GtkWidget *widget, return FALSE; } -} //----------------------------------------------------------------------------- // "focus_out_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, @@ -1939,8 +1860,7 @@ gtk_window_focus_out_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // 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); @@ -1992,31 +1912,21 @@ gtk_window_focus_out_callback( GtkWidget *widget, return FALSE; } -} //----------------------------------------------------------------------------- // "enter_notify_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); // Event was emitted after a grab if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE; - if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; - int x = 0; int y = 0; GdkModifierType state = (GdkModifierType)0; @@ -2038,39 +1948,23 @@ gtk_window_enter_callback( GtkWidget *widget, } } - if (win->GetEventHandler()->ProcessEvent( event )) - { - g_signal_stop_emission_by_name (widget, "enter_notify_event"); - return TRUE; - } - - return FALSE; -} + return win->GetEventHandler()->ProcessEvent(event); } //----------------------------------------------------------------------------- // "leave_notify_event" //----------------------------------------------------------------------------- -extern "C" { static gboolean gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); // Event was emitted after an ungrab if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE; - if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; - wxMouseEvent event( wxEVT_LEAVE_WINDOW ); event.SetTimestamp( gdk_event->time ); event.SetEventObject( win ); @@ -2093,163 +1987,94 @@ gtk_window_leave_callback( GtkWidget *widget, event.m_x = x + pt.x; event.m_y = y + pt.y; - if (win->GetEventHandler()->ProcessEvent( event )) - { - g_signal_stop_emission_by_name (widget, "leave_notify_event"); - return TRUE; - } - - return FALSE; -} + return win->GetEventHandler()->ProcessEvent(event); } //----------------------------------------------------------------------------- -// "value_changed" from m_vAdjust +// "value_changed" from scrollbar //----------------------------------------------------------------------------- -extern "C" { -static void gtk_window_vscroll_callback( GtkAdjustment *adjust, - wxWindowGTK *win ) +static void +gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - if (g_blockEventsOnDrag) return; - - if (!win->m_hasVMT) return; - - float diff = adjust->value - win->m_oldVerticalPos; - if (fabs(diff) < 0.2) return; - - win->m_oldVerticalPos = adjust->value; + wxEventType eventType = win->GetScrollEventType(range); + if (eventType != wxEVT_NULL) + { + // Convert scroll event type to scrollwin event type + eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP; - wxEventType command = GtkScrollWinTypeToWx(GTK_SCROLL_JUMP); + // find the scrollbar which generated the event + wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range); - int value = (int)(adjust->value+0.5); + // generate the corresponding wx event + const int orient = win->OrientFromScrollDir(dir); + wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient); + event.SetEventObject(win); - wxScrollWinEvent event( command, value, wxVERTICAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); -} + win->m_blockValueChanged[dir] = true; + win->GetEventHandler()->ProcessEvent(event); + win->m_blockValueChanged[dir] = false; + } } //----------------------------------------------------------------------------- -// "value_changed" from m_hAdjust +// "button_press_event" from scrollbar //----------------------------------------------------------------------------- -extern "C" { -static void gtk_window_hscroll_callback( GtkAdjustment *adjust, - wxWindowGTK *win ) +static gboolean +gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win) { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); + // don't need to install idle handler, its done from "event" signal - if (g_blockEventsOnDrag) return; - if (!win->m_hasVMT) return; - - float diff = adjust->value - win->m_oldHorizontalPos; - if (fabs(diff) < 0.2) return; - - wxEventType command = GtkScrollWinTypeToWx(GTK_SCROLL_JUMP); - - win->m_oldHorizontalPos = adjust->value; - - int value = (int)(adjust->value+0.5); + g_blockEventsOnScroll = true; + win->m_mouseButtonDown = true; - wxScrollWinEvent event( command, value, wxHORIZONTAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); -} + return false; } //----------------------------------------------------------------------------- -// "button_press_event" from scrollbar +// "event_after" from scrollbar //----------------------------------------------------------------------------- -extern "C" { -static gboolean -gtk_scrollbar_button_press_callback( GtkWidget *widget, - GdkEventButton *gdk_event, - wxWindowGTK *win) +static void +gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win) { - DEBUG_MAIN_THREAD - - if (g_isIdle) - wxapp_install_idle_handler(); - - - g_blockEventsOnScroll = true; - -// FIXME: there is no 'slider' field in GTK+ 2.0 any more -#if 0 - win->m_isScrolling = (gdk_event->window == widget->slider); -#endif + if (event->type == GDK_BUTTON_RELEASE) + { + g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win); - return FALSE; -} + const int orient = win->OrientFromScrollDir( + win->ScrollDirFromRange(range)); + wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient); + event.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(event); + } } //----------------------------------------------------------------------------- // "button_release_event" from scrollbar //----------------------------------------------------------------------------- -extern "C" { static gboolean -gtk_scrollbar_button_release_callback( GtkRange *widget, - GdkEventButton *WXUNUSED(gdk_event), - wxWindowGTK *win) +gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win) { DEBUG_MAIN_THREAD -// don't test here as we can release the mouse while being over -// a different window than the slider -// -// if (gdk_event->window != widget->slider) return FALSE; - g_blockEventsOnScroll = false; - + win->m_mouseButtonDown = false; + // If thumb tracking if (win->m_isScrolling) { - wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE; - int value = -1; - int dir = -1; - - GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget); - if (widget == GTK_RANGE(scrolledWindow->hscrollbar)) - { - value = (int)(win->m_hAdjust->value+0.5); - dir = wxHORIZONTAL; - } - if (widget == GTK_RANGE(scrolledWindow->vscrollbar)) - { - value = (int)(win->m_vAdjust->value+0.5); - dir = wxVERTICAL; - } - - wxScrollWinEvent event( command, value, dir ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); + win->m_isScrolling = false; + // Hook up handler to send thumb release event after this emission is finished. + // To allow setting scroll position from event handler, sending event must + // be deferred until after the GtkRange handler for this signal has run + g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win); } - win->m_isScrolling = false; - - return FALSE; -} -} - -// ---------------------------------------------------------------------------- -// this wxWindowBase function is implemented here (in platform-specific file) -// because it is static and so couldn't be made virtual -// ---------------------------------------------------------------------------- - -wxWindow *wxWindowBase::DoFindFocus() -{ - // the cast is necessary when we compile in wxUniversal mode - return (wxWindow *)g_focusWindow; + return false; } //----------------------------------------------------------------------------- @@ -2259,7 +2084,6 @@ wxWindow *wxWindowBase::DoFindFocus() /* We cannot set colours and fonts before the widget has been realized, so we do this directly after realization. */ -extern "C" { static void gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) { @@ -2279,13 +2103,11 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) event.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( event ); } -} //----------------------------------------------------------------------------- // "size_allocate" //----------------------------------------------------------------------------- -extern "C" { static void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation *WXUNUSED(alloc), @@ -2294,8 +2116,6 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), if (g_isIdle) wxapp_install_idle_handler(); - if (!win->m_hasScrolling) return; - int client_width = 0; int client_height = 0; win->GetClientSize( &client_width, &client_height ); @@ -2312,7 +2132,6 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), win->GetEventHandler()->ProcessEvent( event ); } } -} #ifdef HAVE_XIM @@ -2322,8 +2141,6 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), #endif /* Resize XIM window */ - -extern "C" { static void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), @@ -2347,7 +2164,6 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), } #endif // HAVE_XIM } -} //----------------------------------------------------------------------------- // "realize" from m_wxwindow @@ -2355,7 +2171,6 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), /* Initialize XIM support */ -extern "C" { static void gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), wxWindowGTK * WXUNUSED_UNLESS_XIM(win) ) @@ -2440,6 +2255,18 @@ gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), } #endif // HAVE_XIM } + +} // extern "C" + +// ---------------------------------------------------------------------------- +// this wxWindowBase function is implemented here (in platform-specific file) +// because it is static and so couldn't be made virtual +// ---------------------------------------------------------------------------- + +wxWindow *wxWindowBase::DoFindFocus() +{ + // the cast is necessary when we compile in wxUniversal mode + return (wxWindow *)g_focusWindow; } //----------------------------------------------------------------------------- @@ -2532,17 +2359,25 @@ void wxWindowGTK::Init() m_hasVMT = false; m_needParent = true; m_isBeingDeleted = false; + + m_showOnIdle= false; m_noExpose = false; m_nativeSizeEvent = false; 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_hAdjust = (GtkAdjustment*) NULL; - m_vAdjust = (GtkAdjustment*) NULL; - m_oldHorizontalPos = - m_oldVerticalPos = 0.0; m_oldClientWidth = m_oldClientHeight = 0; @@ -2606,8 +2441,8 @@ bool wxWindowGTK::Create( wxWindow *parent, gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); - m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) ); - m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) ); + m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar); + m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar); m_wxwindow = gtk_pizza_new(); @@ -2637,42 +2472,25 @@ bool wxWindowGTK::Create( wxWindow *parent, GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); m_acceptsFocus = true; - // I _really_ don't want scrollbars in the beginning - m_vAdjust->lower = 0.0; - m_vAdjust->upper = 1.0; - m_vAdjust->value = 0.0; - m_vAdjust->step_increment = 1.0; - m_vAdjust->page_increment = 1.0; - m_vAdjust->page_size = 5.0; - g_signal_emit_by_name (m_vAdjust, "changed"); - m_hAdjust->lower = 0.0; - m_hAdjust->upper = 1.0; - m_hAdjust->value = 0.0; - m_hAdjust->step_increment = 1.0; - m_hAdjust->page_increment = 1.0; - m_hAdjust->page_size = 5.0; - g_signal_emit_by_name (m_hAdjust, "changed"); - - // 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 (scrolledWindow->vscrollbar, "button_press_event", - G_CALLBACK (gtk_scrollbar_button_press_callback), this); - g_signal_connect (scrolledWindow->hscrollbar, "button_press_event", - G_CALLBACK (gtk_scrollbar_button_press_callback), this); - g_signal_connect (scrolledWindow->vscrollbar, "button_release_event", - G_CALLBACK (gtk_scrollbar_button_release_callback), this); - g_signal_connect (scrolledWindow->hscrollbar, "button_release_event", - G_CALLBACK (gtk_scrollbar_button_release_callback), this); - - // these handlers get notified when screen updates are required either when - // scrolling or when the window size (and therefore scrollbar configuration) - // has changed - - g_signal_connect (m_hAdjust, "value_changed", - G_CALLBACK (gtk_window_hscroll_callback), this); - g_signal_connect (m_vAdjust, "value_changed", - G_CALLBACK (gtk_window_vscroll_callback), this); + // 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_CALLBACK(gtk_scrollbar_button_release_event), this); + + 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); + + // these handlers get notified when scrollbar slider moves + g_signal_connect(m_scrollBar[dir], "value_changed", + G_CALLBACK(gtk_scrollbar_value_changed), this); + } gtk_widget_show( m_wxwindow ); @@ -2844,6 +2662,15 @@ void wxWindowGTK::PostCreation() G_CALLBACK (wxgtk_combo_size_request_callback), this); } +#ifdef GTK_IS_FILE_CHOOSER_BUTTON + else if (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 ? + } +#endif else { // This is needed if we want to add our windows into native @@ -2878,7 +2705,7 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) g_signal_connect (widget, "motion_notify_event", G_CALLBACK (gtk_window_motion_notify_callback), this); g_signal_connect (widget, "scroll_event", - G_CALLBACK (gtk_window_wheel_callback), this); + G_CALLBACK (window_scroll_event), this); g_signal_connect (widget, "popup_menu", G_CALLBACK (wxgtk_window_popup_menu_callback), this); g_signal_connect (widget, "enter_notify_event", @@ -3034,8 +2861,32 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags m_resizing = false; } +bool wxWindowGTK::GtkShowFromOnIdle() +{ + if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget)) + { + GtkAllocation alloc; + alloc.x = m_x; + alloc.y = m_y; + alloc.width = m_width; + alloc.height = m_height; + gtk_widget_size_allocate( m_widget, &alloc ); + gtk_widget_show( m_widget ); + wxShowEvent eventShow(GetId(), true); + eventShow.SetEventObject(this); + GetEventHandler()->ProcessEvent(eventShow); + m_showOnIdle = false; + return true; + } + + return false; +} + void wxWindowGTK::OnInternalIdle() { + // Check if we have to show window now + if (GtkShowFromOnIdle()) return; + if ( m_dirtyTabOrder ) { m_dirtyTabOrder = false; @@ -3049,10 +2900,7 @@ void wxWindowGTK::OnInternalIdle() SetBackgroundStyle(GetBackgroundStyle()); m_needsStyleChange = false; } - - // Update invalidated regions. - GtkUpdate(); - + wxCursor cursor = m_cursor; if (g_globalCursor.Ok()) cursor = g_globalCursor; @@ -3077,13 +2925,11 @@ void wxWindowGTK::OnInternalIdle() gdk_window_set_cursor( window, cursor.GetCursor() ); } - else + else if ( m_widget ) { - GdkWindow *window = m_widget->window; - if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget))) + if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) ) gdk_window_set_cursor( window, cursor.GetCursor() ); - } } @@ -3261,14 +3107,22 @@ bool wxWindowGTK::Show( bool show ) } if (show) - gtk_widget_show( m_widget ); + { + if (!m_showOnIdle) + { + gtk_widget_show( m_widget ); + wxShowEvent eventShow(GetId(), show); + eventShow.SetEventObject(this); + GetEventHandler()->ProcessEvent(eventShow); + } + } else + { gtk_widget_hide( m_widget ); - - wxShowEvent eventShow(GetId(), show); - eventShow.SetEventObject(this); - - GetEventHandler()->ProcessEvent(eventShow); + wxShowEvent eventShow(GetId(), show); + eventShow.SetEventObject(this); + GetEventHandler()->ProcessEvent(eventShow); + } return true; } @@ -3332,7 +3186,7 @@ int wxWindowGTK::GetCharHeight() const PangoRectangle rect; pango_layout_line_get_extents(line, NULL, &rect); - g_object_unref( G_OBJECT( layout ) ); + g_object_unref (layout); return (int) PANGO_PIXELS(rect.height); } @@ -3360,7 +3214,7 @@ int wxWindowGTK::GetCharWidth() const PangoRectangle rect; pango_layout_line_get_extents(line, NULL, &rect); - g_object_unref( G_OBJECT( layout ) ); + g_object_unref (layout); return (int) PANGO_PIXELS(rect.width); } @@ -3417,7 +3271,23 @@ void wxWindowGTK::GetTextExtent( const wxString& string, } if (externalLeading) (*externalLeading) = 0; // ?? - g_object_unref( G_OBJECT( layout ) ); + g_object_unref (layout); +} + +bool wxWindowGTK::GTKSetDelayedFocusIfNeeded() +{ + if ( g_delayedFocus == this ) + { + if ( GTK_WIDGET_REALIZED(m_widget) ) + { + gtk_widget_grab_focus(m_widget); + g_delayedFocus = NULL; + + return true; + } + } + + return false; } void wxWindowGTK::SetFocus() @@ -3506,6 +3376,12 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) if (newParent) { + if (GTK_WIDGET_VISIBLE (newParent->m_widget)) + { + m_showOnIdle = true; + gtk_widget_hide( m_widget ); + } + /* insert GTK representation */ (*(newParent->m_insertCallback))(newParent, this); } @@ -3665,10 +3541,36 @@ bool wxWindowGTK::SetCursor( const wxCursor &cursor ) if (g_isIdle) wxapp_install_idle_handler(); - if (cursor == wxNullCursor) - return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ); - else - return wxWindowBase::SetCursor( cursor ); + return wxWindowBase::SetCursor( cursor.Ok() ? cursor : *wxSTANDARD_CURSOR ); +} + +void wxWindowGTK::GTKUpdateCursor() +{ + wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor()); + if ( cursor.Ok() ) + { + wxArrayGdkWindows windowsThis; + GdkWindow * const winThis = GTKGetWindow(windowsThis); + if ( winThis ) + { + gdk_window_set_cursor(winThis, cursor.GetCursor()); + } + else + { + const size_t count = windowsThis.size(); + for ( size_t n = 0; n < count; n++ ) + { + GdkWindow *win = windowsThis[n]; + if ( !win ) + { + wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?")); + continue; + } + + gdk_window_set_cursor(win, cursor.GetCursor()); + } + } + } } void wxWindowGTK::WarpPointer( int x, int y ) @@ -3688,38 +3590,47 @@ void wxWindowGTK::WarpPointer( int x, int y ) gdk_window_warp_pointer( window, x, y ); } -static bool wxScrollAdjust(GtkAdjustment* adj, double change) +wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const { - double value_start = adj->value; - double value = value_start + change; - double upper = adj->upper - adj->page_size; - if (value > upper) + // find the scrollbar which generated the event + for ( int dir = 0; dir < ScrollDir_Max; dir++ ) { - value = upper; + if ( range == m_scrollBar[dir] ) + return (ScrollDir)dir; } - // Lower bound will be checked by gtk_adjustment_set_value - gtk_adjustment_set_value(adj, value); - return adj->value != value_start; + + wxFAIL_MSG( _T("event from unknown scrollbar received") ); + + return ScrollDir_Max; } -bool wxWindowGTK::ScrollLines(int lines) +bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units) { - return - m_vAdjust != NULL && - wxScrollAdjust(m_vAdjust, lines * m_vAdjust->step_increment); + bool changed = false; + GtkRange* range = m_scrollBar[dir]; + if ( range && units ) + { + GtkAdjustment* adj = range->adjustment; + gdouble inc = unit == ScrollUnit_Line ? adj->step_increment + : adj->page_increment; + + const int posOld = int(adj->value + 0.5); + gtk_range_set_value(range, posOld + units*inc); + + changed = int(adj->value + 0.5) != posOld; + } + + return changed; } -bool wxWindowGTK::ScrollPages(int pages) +bool wxWindowGTK::ScrollLines(int lines) { - return - m_vAdjust != NULL && - wxScrollAdjust(m_vAdjust, pages * m_vAdjust->page_increment); + return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines); } -void wxWindowGTK::SetVScrollAdjustment(GtkAdjustment* adj) +bool wxWindowGTK::ScrollPages(int pages) { - wxASSERT(m_vAdjust == NULL); - m_vAdjust = adj; + return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages); } void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) @@ -3731,6 +3642,8 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) if (m_wxwindow) { + if (!GTK_PIZZA(m_wxwindow)->bin_window) return; + GdkRectangle gdk_rect, *p; if (rect) @@ -3765,6 +3678,8 @@ 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) + gdk_window_process_updates( m_widget->window, FALSE ); // for consistency with other platforms (and also because it's convenient // to be able to update an entire TLW by calling Update() only once), we @@ -3847,6 +3762,14 @@ void wxWindowGTK::GtkSendPaintEvents() m_updateRegion.Clear(); } +void wxWindowGTK::SetDoubleBuffered( bool on ) +{ + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); + + if ( m_wxwindow ) + gtk_widget_set_double_buffered( m_wxwindow, on ); +} + void wxWindowGTK::ClearBackground() { wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); @@ -3936,7 +3859,7 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) if ( m_foregroundColour.Ok() ) { - GdkColor *fg = m_foregroundColour.GetColor(); + const GdkColor *fg = m_foregroundColour.GetColor(); style->fg[GTK_STATE_NORMAL] = *fg; style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG; @@ -3950,7 +3873,7 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) if ( m_backgroundColour.Ok() ) { - GdkColor *bg = m_backgroundColour.GetColor(); + const GdkColor *bg = m_backgroundColour.GetColor(); style->bg[GTK_STATE_NORMAL] = *bg; style->base[GTK_STATE_NORMAL] = *bg; @@ -4061,12 +3984,18 @@ GtkWidget* wxWindowGTK::GetConnectWidget() return connect_widget; } -bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window ) +bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const { - if (m_wxwindow) - return (window == GTK_PIZZA(m_wxwindow)->bin_window); + wxArrayGdkWindows windowsThis; + GdkWindow * const winThis = GTKGetWindow(windowsThis); - return (window == m_widget->window); + return winThis ? window == winThis + : windowsThis.Index(window) != wxNOT_FOUND; +} + +GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const +{ + return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window; } bool wxWindowGTK::SetFont( const wxFont &font ) @@ -4143,139 +4072,154 @@ bool wxWindowGTK::IsRetained() const return false; } -void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible, - int range, bool refresh ) +void wxWindowGTK::BlockScrollEvent() { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); + wxASSERT(!m_blockScrollEvent); + m_blockScrollEvent = true; +} - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); +void wxWindowGTK::UnblockScrollEvent() +{ + wxASSERT(m_blockScrollEvent); + m_blockScrollEvent = false; +} - m_hasScrolling = true; +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") ); - if (orient == wxHORIZONTAL) + if (range > 0) { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; - if (fpos > frange-fthumb) fpos = frange-fthumb; - if (fpos < 0.0) fpos = 0.0; - - if ((fabs(frange-m_hAdjust->upper) < 0.2) && - (fabs(fthumb-m_hAdjust->page_size) < 0.2)) - { - SetScrollPos( orient, pos, refresh ); - return; - } - - m_oldHorizontalPos = fpos; - - m_hAdjust->lower = 0.0; - m_hAdjust->upper = frange; - m_hAdjust->value = fpos; - m_hAdjust->step_increment = 1.0; - m_hAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_hAdjust->page_size = fthumb; + m_hasScrolling = true; } else { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; - if (fpos > frange-fthumb) fpos = frange-fthumb; - if (fpos < 0.0) fpos = 0.0; - - if ((fabs(frange-m_vAdjust->upper) < 0.2) && - (fabs(fthumb-m_vAdjust->page_size) < 0.2)) - { - SetScrollPos( orient, pos, refresh ); - return; - } - - m_oldVerticalPos = fpos; - - m_vAdjust->lower = 0.0; - m_vAdjust->upper = frange; - m_vAdjust->value = fpos; - m_vAdjust->step_increment = 1.0; - m_vAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_vAdjust->page_size = fthumb; + // GtkRange requires upper > lower + range = + thumbVisible = 1; } - if (orient == wxHORIZONTAL) - g_signal_emit_by_name (m_hAdjust, "changed"); - else - g_signal_emit_by_name (m_vAdjust, "changed"); -} - -void wxWindowGTK::GtkUpdateScrollbar(int orient) -{ - GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust; - gpointer fn = orient == wxHORIZONTAL - ? (gpointer) gtk_window_hscroll_callback - : (gpointer) gtk_window_vscroll_callback; - - g_signal_handlers_disconnect_by_func (adj, fn, this); - g_signal_emit_by_name (adj, "value_changed"); - g_signal_connect (adj, "value_changed", G_CALLBACK (fn), this); + if (pos > range - thumbVisible) + pos = range - thumbVisible; + if (pos < 0) + pos = 0; + GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment; + adj->step_increment = 1; + adj->page_increment = + adj->page_size = thumbVisible; + adj->upper = range; + SetScrollPos(orient, pos); + gtk_adjustment_changed(adj); } -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") ); - GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust; - - float fpos = (float)pos; - if (fpos > adj->upper - adj->page_size) - fpos = adj->upper - adj->page_size; - if (fpos < 0.0) - fpos = 0.0; - *(orient == wxHORIZONTAL ? &m_oldHorizontalPos : &m_oldVerticalPos) = fpos; - - if (fabs(fpos-adj->value) < 0.2) - return; - adj->value = fpos; - - if ( m_wxwindow->window ) + // 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); + } } } -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") ); - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->page_size+0.5); - else - return (int)(m_vAdjust->page_size+0.5); + return int(m_scrollBar[ScrollDirFromOrient(orient)]->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") ); - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->value+0.5); - else - return (int)(m_vAdjust->value+0.5); + return int(m_scrollBar[ScrollDirFromOrient(orient)]->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") ); - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->upper+0.5); - else - return (int)(m_vAdjust->upper+0.5); + return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper); +} + +// Determine if increment is the same as +/-x, allowing for some small +// difference due to possible inexactness in floating point arithmetic +static inline bool IsScrollIncrement(double increment, double x) +{ + wxASSERT(increment > 0); + const double tolerance = 1.0 / 1024; + return fabs(increment - fabs(x)) < tolerance; +} + +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]; + GtkAdjustment* adj = range->adjustment; + const int value = int(adj->value + 0.5); + // save previous position + const double oldPos = m_scrollPos[barIndex]; + // update current position + m_scrollPos[barIndex] = adj->value; + // If event should be ignored, or integral position has not changed + if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5)) + { + return wxEVT_NULL; + } + + wxEventType eventType = wxEVT_SCROLL_THUMBTRACK; + if (!m_isScrolling) + { + // Difference from last change event + const double diff = adj->value - oldPos; + const bool isDown = diff > 0; + + if (IsScrollIncrement(adj->step_increment, diff)) + { + eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP; + } + else if (IsScrollIncrement(adj->page_increment, diff)) + { + eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP; + } + else if (m_mouseButtonDown) + { + // Assume track event + m_isScrolling = true; + } + } + return eventType; } void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) @@ -4373,32 +4317,3 @@ void wxRemoveGrab(wxWindow* window) gtk_grab_remove( (GtkWidget*) window->GetHandle() ); } -// ---------------------------------------------------------------------------- -// wxWinModule -// ---------------------------------------------------------------------------- - -class wxWinModule : public wxModule -{ -public: - bool OnInit(); - void OnExit(); - -private: - DECLARE_DYNAMIC_CLASS(wxWinModule) -}; - -IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule) - -bool wxWinModule::OnInit() -{ - // g_eraseGC = gdk_gc_new( gdk_get_default_root_window() ); - // gdk_gc_set_fill( g_eraseGC, GDK_SOLID ); - - return true; -} - -void wxWinModule::OnExit() -{ - if (g_eraseGC) - g_object_unref (G_OBJECT (g_eraseGC)); -}