X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/82213cb04e56cb1aa3c8659f3c36c9b3017ad345..63e1921d0be4956ab729735189ccf637773a7e27:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 613f33abf5..3805f1ba5a 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -43,6 +43,7 @@ #include "wx/gtk/private/gtk2-compat.h" #include "wx/gtk/private/event.h" #include "wx/gtk/private/win_gtk.h" +#include "wx/private/textmeasure.h" using namespace wxGTKImpl; #ifdef GDK_WINDOWING_X11 @@ -226,6 +227,17 @@ int g_lastButtonNumber = 0; // the trace mask used for the focus debugging messages #define TRACE_FOCUS wxT("focus") +// A handy function to run from under gdb to show information about the given +// GtkWidget. Right now it only shows its type, we could enhance it to show +// more information later but this is already pretty useful. +const char* wxDumpGtkWidget(GtkWidget* w) +{ + static wxString s; + s.Printf("GtkWidget %p, type \"%s\"", w, G_OBJECT_TYPE_NAME(w)); + + return s.c_str(); +} + //----------------------------------------------------------------------------- // "expose_event"/"draw" from m_wxwindow //----------------------------------------------------------------------------- @@ -830,7 +842,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, event.m_keyCode = key_code; #if wxUSE_UNICODE - event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym); + event.m_uniChar = gdk_keyval_to_unicode(key_code); if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE ) { // Set Unicode key code to the ASCII equivalent for compatibility. E.g. @@ -939,8 +951,6 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gdk_event, wxWindow *win ) { - if (!win->m_hasVMT) - return FALSE; if (g_blockEventsOnDrag) return FALSE; @@ -1113,9 +1123,6 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), GdkEventKey *gdk_event, wxWindowGTK *win ) { - if (!win->m_hasVMT) - return FALSE; - if (g_blockEventsOnDrag) return FALSE; @@ -1265,13 +1272,11 @@ bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const bool wxWindowGTK::GTKShouldIgnoreEvent() const { - return !m_hasVMT || g_blockEventsOnDrag; + return g_blockEventsOnDrag; } int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const { - if (!m_hasVMT) - return FALSE; if (g_blockEventsOnDrag) return TRUE; if (g_blockEventsOnScroll) @@ -1527,8 +1532,11 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget), { int x = 0; int y = 0; - GdkModifierType state; - gdk_window_get_pointer(gdk_event->window, &x, &y, &state); +#ifdef __WXGTK3__ + gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL); +#else + gdk_window_get_pointer(gdk_event->window, &x, &y, NULL); +#endif gdk_event->x = x; gdk_event->y = y; } @@ -1541,7 +1549,12 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget), if ( g_captureWindow ) { // synthesise a mouse enter or leave event if needed - GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL); + GdkWindow* winUnderMouse = +#ifdef __WXGTK3__ + gdk_device_get_window_at_position(gdk_event->device, NULL, NULL); +#else + gdk_window_at_pointer(NULL, NULL); +#endif // This seems to be necessary and actually been added to // GDK itself in version 2.0.X gdk_flush(); @@ -1636,7 +1649,10 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) case GDK_SCROLL_LEFT: event.m_wheelRotation = -120; break; - +#if GTK_CHECK_VERSION(3,4,0) + case GDK_SCROLL_SMOOTH: + // TODO +#endif default: return false; // Unknown/unhandled direction } @@ -1653,6 +1669,11 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) case GDK_SCROLL_RIGHT: event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL; break; +#if GTK_CHECK_VERSION(3,4,0) + case GDK_SCROLL_SMOOTH: + // TODO + break; +#endif } if (win->GTKProcessEvent(event)) @@ -1737,7 +1758,7 @@ wx_window_focus_callback(GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_enter_callback( GtkWidget *widget, +gtk_window_enter_callback( GtkWidget*, GdkEventCrossing *gdk_event, wxWindowGTK *win ) { @@ -1746,17 +1767,8 @@ gtk_window_enter_callback( GtkWidget *widget, // Event was emitted after a grab if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE; - int x = 0; - int y = 0; - GdkModifierType state = (GdkModifierType)0; - - gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state); - wxMouseEvent event( wxEVT_ENTER_WINDOW ); InitMouseEvent(win, event, gdk_event); - wxPoint pt = win->GetClientAreaOrigin(); - event.m_x = x + pt.x; - event.m_y = y + pt.y; if ( !g_captureWindow ) { @@ -1775,7 +1787,7 @@ gtk_window_enter_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_leave_callback( GtkWidget *widget, +gtk_window_leave_callback( GtkWidget*, GdkEventCrossing *gdk_event, wxWindowGTK *win ) { @@ -1785,13 +1797,6 @@ gtk_window_leave_callback( GtkWidget *widget, if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE; wxMouseEvent event( wxEVT_LEAVE_WINDOW ); - - int x = 0; - int y = 0; - GdkModifierType state = (GdkModifierType)0; - - gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state); - InitMouseEvent(win, event, gdk_event); return win->GTKProcessEvent(event); @@ -1905,10 +1910,11 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win) if (w < 0) w = 0; if (h < 0) h = 0; } - if (win->m_oldClientWidth != w || win->m_oldClientHeight != h) + win->m_useCachedClientSize = true; + if (win->m_clientWidth != w || win->m_clientHeight != h) { - win->m_oldClientWidth = w; - win->m_oldClientHeight = h; + win->m_clientWidth = w; + win->m_clientHeight = h; // this callback can be connected to m_wxwindow, // so always get size from m_widget->allocation GtkAllocation a; @@ -1955,43 +1961,35 @@ static void style_updated(GtkWidget*, wxWindow* win) static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win) #endif { - if (win->IsTopLevel()) - { - wxSysColourChangedEvent event; - event.SetEventObject(win); - win->GTKProcessEvent(event); - } - else - { - // Border width could change, which will change client size. - // Make sure size event occurs for this - win->m_oldClientWidth = 0; - } + wxSysColourChangedEvent event; + event.SetEventObject(win); + win->GTKProcessEvent(event); } //----------------------------------------------------------------------------- -// "unrealize" from m_wxwindow +// "unrealize" //----------------------------------------------------------------------------- static void unrealize(GtkWidget*, wxWindow* win) { - if (win->m_imData) - gtk_im_context_set_client_window(win->m_imData->context, NULL); - - g_signal_handlers_disconnect_by_func( - win->m_wxwindow, (void*)style_updated, win); + win->GTKHandleUnrealize(); } } // extern "C" void wxWindowGTK::GTKHandleRealized() { + if (IsFrozen()) + DoFreeze(); + + GdkWindow* const window = GTKGetDrawingWindow(); + if (m_imData) { gtk_im_context_set_client_window ( m_imData->context, - m_wxwindow ? GTKGetDrawingWindow() + window ? window : gtk_widget_get_window(m_widget) ); } @@ -2002,7 +2000,6 @@ void wxWindowGTK::GTKHandleRealized() #if wxGTK_HAS_COMPOSITING_SUPPORT if (IsTransparentBackgroundSupported()) { - GdkWindow* const window = GTKGetDrawingWindow(); if (window) gdk_window_set_composited(window, true); } @@ -2014,16 +2011,14 @@ void wxWindowGTK::GTKHandleRealized() } } - - // We cannot set colours and fonts before the widget - // been realized, so we do this directly after realization - // or otherwise in idle time - - if (m_needsStyleChange) +#ifndef __WXGTK3__ + if (window && ( + m_backgroundStyle == wxBG_STYLE_PAINT || + m_backgroundStyle == wxBG_STYLE_TRANSPARENT)) { - SetBackgroundStyle(GetBackgroundStyle()); - m_needsStyleChange = false; + gdk_window_set_back_pixmap(window, NULL, false); } +#endif wxWindowCreateEvent event(static_cast(this)); event.SetEventObject( this ); @@ -2031,8 +2026,7 @@ void wxWindowGTK::GTKHandleRealized() GTKUpdateCursor(true, false); - if (m_wxwindow && - (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))) + if (m_wxwindow && IsTopLevel()) { // attaching to style changed signal after realization avoids initial // changes we don't care about @@ -2048,6 +2042,26 @@ void wxWindowGTK::GTKHandleRealized() } } +void wxWindowGTK::GTKHandleUnrealize() +{ + // unrealizing a frozen window seems to have some lingering effect + // preventing updates to the affected area + if (IsFrozen()) + DoThaw(); + + if (m_wxwindow) + { + if (m_imData) + gtk_im_context_set_client_window(m_imData->context, NULL); + + if (IsTopLevel()) + { + g_signal_handlers_disconnect_by_func( + m_wxwindow, (void*)style_updated, this); + } + } +} + // ---------------------------------------------------------------------------- // this wxWindowBase function is implemented here (in platform-specific file) // because it is static and so couldn't be made virtual @@ -2101,7 +2115,7 @@ bool wxGetKeyState(wxKeyCode WXUNUSED(key)) } #endif // __WINDOWS__ -static void GetMouseState(int& x, int& y, GdkModifierType& mask) +static GdkDisplay* GetDisplay() { wxWindow* tlw = NULL; if (!wxTopLevelWindows.empty()) @@ -2111,7 +2125,7 @@ static void GetMouseState(int& x, int& y, GdkModifierType& mask) display = gtk_widget_get_display(tlw->m_widget); else display = gdk_display_get_default(); - gdk_display_get_pointer(display, NULL, &x, &y, &mask); + return display; } wxMouseState wxGetMouseState() @@ -2122,7 +2136,17 @@ wxMouseState wxGetMouseState() gint y; GdkModifierType mask; - GetMouseState(x, y, mask); + GdkDisplay* display = GetDisplay(); +#ifdef __WXGTK3__ + GdkDeviceManager* manager = gdk_display_get_device_manager(display); + GdkDevice* device = gdk_device_manager_get_client_pointer(manager); + GdkScreen* screen; + gdk_device_get_position(device, &screen, &x, &y); + GdkWindow* window = gdk_screen_get_root_window(screen); + gdk_device_get_state(device, window, NULL, &mask); +#else + gdk_display_get_pointer(display, NULL, &x, &y, &mask); +#endif ms.SetX(x); ms.SetY(y); @@ -2164,14 +2188,13 @@ void wxWindowGTK::Init() m_width = 0; m_height = 0; - m_hasVMT = false; - m_showOnIdle = false; m_noExpose = false; m_nativeSizeEvent = false; #ifdef __WXGTK3__ m_paintContext = NULL; + m_styleProvider = NULL; #endif m_isScrolling = false; @@ -2184,13 +2207,12 @@ void wxWindowGTK::Init() m_scrollPos[dir] = 0; } - m_oldClientWidth = - m_oldClientHeight = 0; + m_clientWidth = + m_clientHeight = 0; + m_useCachedClientSize = false; m_clipPaintRegion = false; - m_needsStyleChange = false; - m_cursor = *wxSTANDARD_CURSOR; m_imData = NULL; @@ -2240,14 +2262,20 @@ void wxWindowGTK::GTKCreateScrolledWindowWith(GtkWidget* view) } } - if (HasFlag(wxALWAYS_SHOW_SB)) - { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); - } - else - { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); - } + // If wx[HV]SCROLL is not given, the corresponding scrollbar is not shown + // at all. Otherwise it may be shown only on demand (default) or always, if + // the wxALWAYS_SHOW_SB is specified. + GtkPolicyType horzPolicy = HasFlag(wxHSCROLL) + ? HasFlag(wxALWAYS_SHOW_SB) + ? GTK_POLICY_ALWAYS + : GTK_POLICY_AUTOMATIC + : GTK_POLICY_NEVER; + GtkPolicyType vertPolicy = HasFlag(wxVSCROLL) + ? HasFlag(wxALWAYS_SHOW_SB) + ? GTK_POLICY_ALWAYS + : GTK_POLICY_AUTOMATIC + : GTK_POLICY_NEVER; + gtk_scrolled_window_set_policy( scrolledWindow, horzPolicy, vertPolicy ); m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow)); m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow)); @@ -2332,6 +2360,12 @@ bool wxWindowGTK::Create( wxWindow *parent, return true; } +void wxWindowGTK::GTKDisconnect(void* instance) +{ + g_signal_handlers_disconnect_matched(instance, + GSignalMatchType(G_SIGNAL_MATCH_DATA), 0, 0, NULL, NULL, this); +} + wxWindowGTK::~wxWindowGTK() { SendDestroyEvent(); @@ -2344,22 +2378,28 @@ wxWindowGTK::~wxWindowGTK() if ( gs_deferredFocusOut == this ) gs_deferredFocusOut = NULL; - m_hasVMT = false; - - // destroy children before destroying this window itself - DestroyChildren(); + // Unlike the above cases, which can happen in normal circumstances, a + // window shouldn't be destroyed while it still has capture, so even though + // we still reset the global pointer to avoid leaving it dangling and + // crashing afterwards, also complain about it. + if ( g_captureWindow == this ) + { + wxFAIL_MSG( wxS("Destroying window with mouse capture") ); + g_captureWindow = NULL; + } - // unhook focus handlers to prevent stray events being - // propagated to this (soon to be) dead object - if (m_focusWidget != NULL) + if (m_wxwindow) { - g_signal_handlers_disconnect_by_func (m_focusWidget, - (gpointer) gtk_window_focus_in_callback, - this); - g_signal_handlers_disconnect_by_func (m_focusWidget, - (gpointer) gtk_window_focus_out_callback, - this); + GTKDisconnect(m_wxwindow); + GtkWidget* parent = gtk_widget_get_parent(m_wxwindow); + if (parent) + GTKDisconnect(parent); } + if (m_widget && m_widget != m_wxwindow) + GTKDisconnect(m_widget); + + // destroy children before destroying this window itself + DestroyChildren(); if (m_widget) Show( false ); @@ -2371,8 +2411,13 @@ wxWindowGTK::~wxWindowGTK() // avoid problem with GTK+ 2.18 where a frozen window causes the whole // TLW to be frozen, and if the window is then destroyed, nothing ever // gets painted again - if (IsFrozen()) - DoThaw(); + while (IsFrozen()) + Thaw(); + +#ifdef __WXGTK3__ + if (m_styleProvider) + g_object_unref(m_styleProvider); +#endif if (m_widget) { @@ -2453,7 +2498,6 @@ void wxWindowGTK::PostCreation() g_signal_connect (m_imData->context, "commit", G_CALLBACK (gtk_wxwindow_commit_cb), this); - g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this); } // focus handling @@ -2498,13 +2542,14 @@ void wxWindowGTK::PostCreation() // was in fact realized already. if ( gtk_widget_get_realized(connect_widget) ) { - gtk_window_realized_callback(connect_widget, this); + GTKHandleRealized(); } else { g_signal_connect (connect_widget, "realize", G_CALLBACK (gtk_window_realized_callback), this); } + g_signal_connect(connect_widget, "unrealize", G_CALLBACK(unrealize), this); if (!IsTopLevel()) { @@ -2535,9 +2580,10 @@ void wxWindowGTK::PostCreation() if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget)) gtk_widget_set_size_request(m_widget, m_width, m_height); - InheritAttributes(); + // apply any font or color changes made before creation + GTKApplyWidgetStyle(); - m_hasVMT = true; + InheritAttributes(); SetLayoutDirection(wxLayout_Default); @@ -2583,13 +2629,6 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) G_CALLBACK (gtk_window_leave_callback), this); } -bool wxWindowGTK::Destroy() -{ - m_hasVMT = false; - - return wxWindowBase::Destroy(); -} - static GSList* gs_queueResizeList; extern "C" { @@ -2687,6 +2726,10 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags height = m_height; const bool sizeChange = m_width != width || m_height != height; + + if (sizeChange) + m_useCachedClientSize = false; + if (sizeChange || m_x != x || m_y != y) { m_x = x; @@ -2716,7 +2759,7 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags { // update these variables to keep size_allocate handler // from sending another size event for this change - GetClientSize( &m_oldClientWidth, &m_oldClientHeight ); + DoGetClientSize(&m_clientWidth, &m_clientHeight); wxSizeEvent event( wxSize(m_width,m_height), GetId() ); event.SetEventObject( this ); @@ -2781,6 +2824,13 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); + if (m_useCachedClientSize) + { + if (width) *width = m_clientWidth; + if (height) *height = m_clientHeight; + return; + } + int w = m_width; int h = m_height; @@ -2793,8 +2843,16 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget), &policy[ScrollDir_Horz], &policy[ScrollDir_Vert]); - const int scrollbar_spacing = + + // get scrollbar spacing the same way the GTK-private function + // _gtk_scrolled_window_get_scrollbar_spacing() does it + int scrollbar_spacing = GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing; + if (scrollbar_spacing < 0) + { + gtk_widget_style_get( + m_widget, "scrollbar-spacing", &scrollbar_spacing, NULL); + } for ( int i = 0; i < ScrollDir_Max; i++ ) { @@ -3074,52 +3132,18 @@ void wxWindowGTK::DoGetTextExtent( const wxString& string, int *externalLeading, const wxFont *theFont ) const { - wxFont fontToUse = theFont ? *theFont : GetFont(); + // ensure we work with a valid font + wxFont fontToUse; + if ( !theFont || !theFont->IsOk() ) + fontToUse = GetFont(); + else + fontToUse = *theFont; wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") ); - if (string.empty()) - { - if (x) (*x) = 0; - if (y) (*y) = 0; - return; - } - - PangoContext *context = NULL; - if (m_widget) - context = gtk_widget_get_pango_context( m_widget ); - - if (!context) - { - if (x) (*x) = 0; - if (y) (*y) = 0; - return; - } - - PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description; - PangoLayout *layout = pango_layout_new(context); - pango_layout_set_font_description(layout, desc); - { - const wxCharBuffer data = wxGTK_CONV( string ); - if ( data ) - pango_layout_set_text(layout, data, strlen(data)); - } - - PangoRectangle rect; - pango_layout_get_extents(layout, NULL, &rect); - - if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width); - if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height); - if (descent) - { - PangoLayoutIter *iter = pango_layout_get_iter(layout); - int baseline = pango_layout_iter_get_baseline(iter); - pango_layout_iter_free(iter); - *descent = *y - PANGO_PIXELS(baseline); - } - if (externalLeading) (*externalLeading) = 0; // ?? - - g_object_unref (layout); + const wxWindow* win = static_cast(this); + wxTextMeasure txm(win, &fontToUse); + txm.GetTextExtent(string, x, y, descent, externalLeading); } void wxWindowGTK::GTKDisableFocusOutEvent() @@ -3988,46 +4012,46 @@ void wxWindowGTK::GTKApplyToolTip(const char* tip) bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) { - wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); - if (!wxWindowBase::SetBackgroundColour(colour)) return false; -#ifndef __WXGTK3__ - if (colour.IsOk()) + if (m_widget) { - // We need the pixel value e.g. for background clearing. - m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); - } +#ifndef __WXGTK3__ + if (colour.IsOk()) + { + // We need the pixel value e.g. for background clearing. + m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); + } #endif - // apply style change (forceStyle=true so that new style is applied - // even if the bg colour changed from valid to wxNullColour) - GTKApplyWidgetStyle(true); + // apply style change (forceStyle=true so that new style is applied + // even if the bg colour changed from valid to wxNullColour) + GTKApplyWidgetStyle(true); + } return true; } bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) { - wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); - if (!wxWindowBase::SetForegroundColour(colour)) - { return false; - } -#ifndef __WXGTK3__ - if (colour.IsOk()) + if (m_widget) { - // We need the pixel value e.g. for background clearing. - m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); - } +#ifndef __WXGTK3__ + if (colour.IsOk()) + { + // We need the pixel value e.g. for background clearing. + m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); + } #endif - // apply style change (forceStyle=true so that new style is applied - // even if the bg colour changed from valid to wxNullColour): - GTKApplyWidgetStyle(true); + // apply style change (forceStyle=true so that new style is applied + // even if the bg colour changed from valid to wxNullColour): + GTKApplyWidgetStyle(true); + } return true; } @@ -4038,16 +4062,8 @@ PangoContext *wxWindowGTK::GTKGetPangoDefaultContext() } #ifndef __WXGTK3__ -GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle) +GtkRcStyle* wxWindowGTK::GTKCreateWidgetStyle() { - // do we need to apply any changes at all? - if ( !forceStyle && - !m_font.IsOk() && - !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() ) - { - return NULL; - } - GtkRcStyle *style = gtk_rc_style_new(); if ( m_font.IsOk() ) @@ -4108,18 +4124,35 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle) } #endif // !__WXGTK3__ -void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle)) +void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle) { + if (forceStyle || m_font.IsOk() || + m_foregroundColour.IsOk() || m_backgroundColour.IsOk()) + { #ifdef __WXGTK3__ - DoApplyWidgetStyle(NULL); + if (m_backgroundColour.IsOk()) + { + // create a GtkStyleProvider to override "background-image" + if (m_styleProvider == NULL) + m_styleProvider = GTK_STYLE_PROVIDER(gtk_css_provider_new()); + const char css[] = + "*{background-image:-gtk-gradient(linear,0 0,0 1," + "from(rgba(%u,%u,%u,%g)),to(rgba(%u,%u,%u,%g)))}"; + char buf[sizeof(css) + 20]; + const unsigned r = m_backgroundColour.Red(); + const unsigned g = m_backgroundColour.Green(); + const unsigned b = m_backgroundColour.Blue(); + const double a = m_backgroundColour.Alpha() / 255.0; + g_snprintf(buf, sizeof(buf), css, r, g, b, a, r, g, b, a); + gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(m_styleProvider), buf, -1, NULL); + } + DoApplyWidgetStyle(NULL); #else - GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle); - if ( style ) - { + GtkRcStyle* style = GTKCreateWidgetStyle(); DoApplyWidgetStyle(style); g_object_unref(style); - } #endif + } // Style change may affect GTK+'s size calculation: InvalidateBestSize(); @@ -4157,6 +4190,25 @@ void wxWindowGTK::GTKApplyStyle(GtkWidget* widget, GtkRcStyle* WXUNUSED_IN_GTK3( gtk_widget_override_font(widget, pfd); gtk_widget_override_color(widget, GTK_STATE_FLAG_NORMAL, m_foregroundColour); gtk_widget_override_background_color(widget, GTK_STATE_FLAG_NORMAL, m_backgroundColour); + + // setting background color has no effect with some themes when the widget style + // has a "background-image" property, so we need to override that as well + + GtkStyleContext* context = gtk_widget_get_style_context(widget); + if (m_styleProvider) + gtk_style_context_remove_provider(context, m_styleProvider); + cairo_pattern_t* pattern = NULL; + if (m_backgroundColour.IsOk()) + { + gtk_style_context_get(context, + GTK_STATE_FLAG_NORMAL, "background-image", &pattern, NULL); + } + if (pattern) + { + cairo_pattern_destroy(pattern); + gtk_style_context_add_provider(context, + m_styleProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + } #else gtk_widget_modify_style(widget, style); #endif @@ -4169,40 +4221,10 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) #ifndef __WXGTK3__ GdkWindow *window; - if ( m_wxwindow ) + if ((style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT) && + (window = GTKGetDrawingWindow())) { - window = GTKGetDrawingWindow(); - } - else - { - GtkWidget * const w = GetConnectWidget(); - window = w ? gtk_widget_get_window(w) : NULL; - } - - bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT; - - if ( wantNoBackPixmap ) - { - if (window) - { - // Make sure GDK/X11 doesn't refresh the window - // automatically. - gdk_window_set_back_pixmap( window, NULL, FALSE ); - m_needsStyleChange = false; - } - else // window not realized yet - { - // Do when window is realized - m_needsStyleChange = true; - } - - // Don't apply widget style, or we get a grey background - } - else - { - // apply style change (forceStyle=true so that new style is applied - // even if the bg colour changed from valid to wxNullColour): - GTKApplyWidgetStyle(true); + gdk_window_set_back_pixmap(window, NULL, false); } #endif // !__WXGTK3__ @@ -4269,7 +4291,11 @@ void wxPopupMenuPositionCallback( GtkMenu *menu, { // ensure that the menu appears entirely on screen GtkRequisition req; +#ifdef __WXGTK3__ + gtk_widget_get_preferred_size(GTK_WIDGET(menu), &req, NULL); +#else gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req); +#endif wxSize sizeScreen = wxGetDisplaySize(); wxPoint *pos = (wxPoint*)user_data; @@ -4367,14 +4393,15 @@ GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const bool wxWindowGTK::SetFont( const wxFont &font ) { - wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); - if (!wxWindowBase::SetFont(font)) return false; - // apply style change (forceStyle=true so that new style is applied - // even if the font changed from valid to wxNullFont): - GTKApplyWidgetStyle(true); + if (m_widget) + { + // apply style change (forceStyle=true so that new style is applied + // even if the font changed from valid to wxNullFont): + GTKApplyWidgetStyle(true); + } return true; } @@ -4395,15 +4422,25 @@ void wxWindowGTK::DoCaptureMouse() if (!cursor->IsOk()) cursor = wxSTANDARD_CURSOR; + const GdkEventMask mask = GdkEventMask( + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_HINT_MASK | + GDK_POINTER_MOTION_MASK); +#ifdef __WXGTK3__ + GdkDisplay* display = gdk_window_get_display(window); + GdkDeviceManager* manager = gdk_display_get_device_manager(display); + GdkDevice* device = gdk_device_manager_get_client_pointer(manager); + gdk_device_grab( + device, window, GDK_OWNERSHIP_NONE, false, mask, + cursor->GetCursor(), unsigned(GDK_CURRENT_TIME)); +#else gdk_pointer_grab( window, FALSE, - (GdkEventMask) - (GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_POINTER_MOTION_HINT_MASK | - GDK_POINTER_MOTION_MASK), + mask, NULL, cursor->GetCursor(), (guint32)GDK_CURRENT_TIME ); +#endif g_captureWindow = this; g_captureWindowHasMouse = true; } @@ -4425,7 +4462,14 @@ void wxWindowGTK::DoReleaseMouse() if (!window) return; +#ifdef __WXGTK3__ + GdkDisplay* display = gdk_window_get_display(window); + GdkDeviceManager* manager = gdk_display_get_device_manager(display); + GdkDevice* device = gdk_device_manager_get_client_pointer(manager); + gdk_device_ungrab(device, unsigned(GDK_CURRENT_TIME)); +#else gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); +#endif } void wxWindowGTK::GTKReleaseMouseAndNotify() @@ -4544,7 +4588,7 @@ wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range) // update current position m_scrollPos[barIndex] = value; // If event should be ignored, or integral position has not changed - if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos)) + if (g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos)) { return wxEVT_NULL; } @@ -4648,12 +4692,23 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt) } // Get the current mouse position. +void wxGetMousePosition(int* x, int* y) +{ + GdkDisplay* display = GetDisplay(); +#ifdef __WXGTK3__ + GdkDeviceManager* manager = gdk_display_get_device_manager(display); + GdkDevice* device = gdk_device_manager_get_client_pointer(manager); + gdk_device_get_position(device, NULL, x, y); +#else + gdk_display_get_pointer(display, NULL, x, y, NULL); +#endif +} + wxPoint wxGetMousePosition() { - int x, y; - GdkModifierType unused; - GetMouseState(x, y, unused); - return wxPoint(x, y); + wxPoint pt; + wxGetMousePosition(&pt.x, &pt.y); + return pt; } GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const @@ -4668,91 +4723,38 @@ GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const // freeze/thaw // ---------------------------------------------------------------------------- -extern "C" -{ - -// this is called if we attempted to freeze unrealized widget when it finally -// is realized (and so can be frozen): -static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win) -{ - wxASSERT( w && gtk_widget_get_has_window(w) ); - wxASSERT( gtk_widget_get_realized(w) ); - - g_signal_handlers_disconnect_by_func - ( - w, - (void*)wx_frozen_widget_realize, - win - ); - - GdkWindow* window; - if (w == win->m_wxwindow) - window = win->GTKGetDrawingWindow(); - else - window = gtk_widget_get_window(w); - gdk_window_freeze_updates(window); -} - -} // extern "C" - -void wxWindowGTK::GTKFreezeWidget(GtkWidget *w) +void wxWindowGTK::GTKFreezeWidget(GtkWidget* widget) { - if ( !w || !gtk_widget_get_has_window(w) ) - return; // window-less widget, cannot be frozen - - GdkWindow* window = gtk_widget_get_window(w); - if (window == NULL) + if (widget && gtk_widget_get_has_window(widget)) { - // we can't thaw unrealized widgets because they don't have GdkWindow, - // so set it up to be done immediately after realization: - g_signal_connect_after - ( - w, - "realize", - G_CALLBACK(wx_frozen_widget_realize), - this - ); - return; + GdkWindow* window = gtk_widget_get_window(widget); + if (window) + gdk_window_freeze_updates(window); } - - if (w == m_wxwindow) - window = GTKGetDrawingWindow(); - gdk_window_freeze_updates(window); } -void wxWindowGTK::GTKThawWidget(GtkWidget *w) +void wxWindowGTK::GTKThawWidget(GtkWidget* widget) { - if ( !w || !gtk_widget_get_has_window(w) ) - return; // window-less widget, cannot be frozen - - GdkWindow* window = gtk_widget_get_window(w); - if (window == NULL) + if (widget && gtk_widget_get_has_window(widget)) { - // the widget wasn't realized yet, no need to thaw - g_signal_handlers_disconnect_by_func - ( - w, - (void*)wx_frozen_widget_realize, - this - ); - return; + GdkWindow* window = gtk_widget_get_window(widget); + if (window) + gdk_window_thaw_updates(window); } - - if (w == m_wxwindow) - window = GTKGetDrawingWindow(); - gdk_window_thaw_updates(window); } void wxWindowGTK::DoFreeze() { - GTKFreezeWidget(m_widget); - if ( m_wxwindow && m_widget != m_wxwindow ) - GTKFreezeWidget(m_wxwindow); + GtkWidget* widget = m_wxwindow; + if (widget == NULL) + widget = m_widget; + GTKFreezeWidget(widget); } void wxWindowGTK::DoThaw() { - GTKThawWidget(m_widget); - if ( m_wxwindow && m_widget != m_wxwindow ) - GTKThawWidget(m_wxwindow); + GtkWidget* widget = m_wxwindow; + if (widget == NULL) + widget = m_widget; + GTKThawWidget(widget); }