X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4d711190c7d59c8f6cfa566d131a9f0ef86d26e6..14722c43c30918cd8fbba956b50ac3426d2fe339:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 87477cec2d..613f33abf5 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -31,24 +31,29 @@ #include "wx/tooltip.h" #include "wx/caret.h" #include "wx/fontutil.h" -#include "wx/scopeguard.h" #include "wx/sysopt.h" +#ifdef __WXGTK3__ + #include "wx/gtk/dc.h" +#endif #include +#include #include "wx/gtk/private.h" -#include "wx/gtk/private/win_gtk.h" +#include "wx/gtk/private/gtk2-compat.h" #include "wx/gtk/private/event.h" +#include "wx/gtk/private/win_gtk.h" using namespace wxGTKImpl; #ifdef GDK_WINDOWING_X11 #include +#include "wx/x11/private/wrapxkb.h" #else typedef guint KeySym; #endif #include -#if GTK_CHECK_VERSION(3,0,0) +#ifdef __WXGTK3__ #include #endif @@ -222,57 +227,47 @@ int g_lastButtonNumber = 0; #define TRACE_FOCUS wxT("focus") //----------------------------------------------------------------------------- -// "size_request" of m_widget +// "expose_event"/"draw" from m_wxwindow //----------------------------------------------------------------------------- extern "C" { -static void -wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget), - GtkRequisition *requisition, - wxWindow * win) +#ifdef __WXGTK3__ +static gboolean draw(GtkWidget*, cairo_t* cr, wxWindow* win) { - int w, h; - win->GetSize( &w, &h ); - if (w < 2) - w = 2; - if (h < 2) - h = 2; + if (gtk_cairo_should_draw_window(cr, win->GTKGetDrawingWindow())) + win->GTKSendPaintEvents(cr); - requisition->height = h; - requisition->width = w; -} + return false; } - -//----------------------------------------------------------------------------- -// "expose_event" of m_wxwindow -//----------------------------------------------------------------------------- - -extern "C" { -static gboolean -gtk_window_expose_callback( GtkWidget*, - GdkEventExpose *gdk_event, - wxWindow *win ) +#else // !__WXGTK3__ +static gboolean expose_event(GtkWidget*, GdkEventExpose* gdk_event, wxWindow* win) { if (gdk_event->window == win->GTKGetDrawingWindow()) - { - win->GetUpdateRegion() = wxRegion( gdk_event->region ); - win->GtkSendPaintEvents(); - } - // Let parent window draw window-less widgets - return FALSE; + win->GTKSendPaintEvents(gdk_event->region); + + return false; } +#endif // !__WXGTK3__ } #ifndef __WXUNIVERSAL__ //----------------------------------------------------------------------------- -// "expose_event" from m_wxwindow->parent, for drawing border +// "expose_event"/"draw" from m_wxwindow->parent, for drawing border //----------------------------------------------------------------------------- extern "C" { static gboolean -expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win) +#ifdef __WXGTK3__ +draw_border(GtkWidget*, cairo_t* cr, wxWindow* win) +#else +draw_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win) +#endif { +#ifdef __WXGTK3__ + if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_parent_window(win->m_wxwindow))) +#else if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow)) +#endif return false; if (!win->IsShown()) @@ -290,30 +285,55 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win) if (win->HasFlag(wxBORDER_SIMPLE)) { +#ifdef __WXGTK3__ + GtkStyleContext* sc = gtk_widget_get_style_context(win->m_wxwindow); + GdkRGBA c; + gtk_style_context_get_border_color(sc, GTK_STATE_FLAG_NORMAL, &c); + gdk_cairo_set_source_rgba(cr, &c); + cairo_set_line_width(cr, 1); + cairo_rectangle(cr, x + 0.5, y + 0.5, w - 1, h - 1); + cairo_stroke(cr); +#else gdk_draw_rectangle(gdk_event->window, gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1); +#endif } - else + else if (win->HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)) { +#ifdef __WXGTK3__ + //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN + GtkStyleContext* sc; + if (win->HasFlag(wxHSCROLL | wxVSCROLL)) + sc = gtk_widget_get_style_context(wxGTKPrivate::GetTreeWidget()); + else + sc = gtk_widget_get_style_context(wxGTKPrivate::GetEntryWidget()); + + gtk_render_frame(sc, cr, x, y, w, h); +#else // !__WXGTK3__ GtkShadowType shadow = GTK_SHADOW_IN; if (win->HasFlag(wxBORDER_RAISED)) shadow = GTK_SHADOW_OUT; - // Style detail to use + GtkStyle* style; const char* detail; - if (win->m_widget == win->m_wxwindow) - // for non-scrollable wxWindows - detail = "entry"; - else - // for scrollable ones + if (win->HasFlag(wxHSCROLL | wxVSCROLL)) + { + style = gtk_widget_get_style(wxGTKPrivate::GetTreeWidget()); detail = "viewport"; + } + else + { + style = gtk_widget_get_style(wxGTKPrivate::GetEntryWidget()); + detail = "entry"; + } // clip rect is required to avoid painting background // over upper left (w,h) of parent window GdkRectangle clipRect = { x, y, w, h }; gtk_paint_shadow( - gtk_widget_get_style(win->m_wxwindow), gdk_event->window, GTK_STATE_NORMAL, - shadow, &clipRect, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h); + style, gdk_event->window, GTK_STATE_NORMAL, + shadow, &clipRect, widget, detail, x, y, w, h); +#endif // !__WXGTK3__ } return false; } @@ -330,13 +350,16 @@ parent_set(GtkWidget* widget, GtkWidget* old_parent, wxWindow* win) if (old_parent) { g_signal_handlers_disconnect_by_func( - old_parent, (void*)expose_event_border, win); + old_parent, (void*)draw_border, win); } GtkWidget* parent = gtk_widget_get_parent(widget); if (parent) { - g_signal_connect_after(parent, "expose_event", - G_CALLBACK(expose_event_border), win); +#ifdef __WXGTK3__ + g_signal_connect_after(parent, "draw", G_CALLBACK(draw_border), win); +#else + g_signal_connect_after(parent, "expose_event", G_CALLBACK(draw_border), win); +#endif } } } @@ -643,6 +666,16 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0; + // At least with current Linux systems, MOD5 corresponds to AltGr key and + // we represent it, for consistency with Windows, which really allows to + // use Ctrl+Alt as a replacement for AltGr if this key is not present, as a + // combination of these two modifiers. + if ( gdk_event->state & GDK_MOD5_MASK ) + { + event.m_controlDown = + event.m_altDown = true; + } + // Normally we take the state of modifiers directly from the low level GDK // event but unfortunately GDK uses a different convention from MSW for the // key events corresponding to the modifier keys themselves: in it, when @@ -688,8 +721,6 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, event.m_rawCode = (wxUint32) gdk_event->keyval; event.m_rawFlags = gdk_event->hardware_keycode; - wxGetMousePosition(&event.m_x, &event.m_y); - win->ScreenToClient(&event.m_x, &event.m_y); event.SetEventObject( win ); } @@ -746,7 +777,11 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode); +#ifdef HAVE_X11_XKBLIB_H + KeySym keysymNormalized = XkbKeycodeToKeysym(dpy, keycode, 0, 0); +#else KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0); +#endif // use the normalized, i.e. lower register, keysym if we've // got one @@ -924,38 +959,8 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), return TRUE; } - // Emit KEY_DOWN event - ret = win->HandleWindowEvent( event ); - } - else - { - // Return after IM processing as we cannot do - // anything with it anyhow. - return_after_IM = true; - } - - if (!ret && win->m_imData) - { - win->m_imData->lastKeyEvent = gdk_event; - - // 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. - // we should send the key_down event anyway. - bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event); - win->m_imData->lastKeyEvent = NULL; - if (intercepted_by_IM) - { - wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM")); - return TRUE; - } - } - - if (return_after_IM) - return FALSE; - + // Next check for accelerators. #if wxUSE_ACCEL - if (!ret) - { wxWindowGTK *ancestor = win; while (ancestor) { @@ -980,17 +985,46 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), break; ancestor = ancestor->GetParent(); } - } #endif // wxUSE_ACCEL + // If not an accelerator, then emit KEY_DOWN event + if ( !ret ) + ret = win->HandleWindowEvent( event ); + } + else + { + // Return after IM processing as we cannot do + // anything with it anyhow. + return_after_IM = true; + } + + if (!ret && win->m_imData) + { + win->m_imData->lastKeyEvent = gdk_event; + + // 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. + // we should send the key_down event anyway. + bool intercepted_by_IM = + gtk_im_context_filter_keypress(win->m_imData->context, gdk_event) != 0; + win->m_imData->lastKeyEvent = NULL; + if (intercepted_by_IM) + { + wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM")); + return TRUE; + } + } + + if (return_after_IM) + return FALSE; + // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x // will only be sent if it is not in an accelerator table. if (!ret) { - long key_code; KeySym keysym = gdk_event->keyval; // Find key code for EVT_CHAR and EVT_CHAR_HOOK events - key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */); + long key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */); if ( !key_code ) { if ( wxIsAsciiKeysym(keysym) ) @@ -1012,6 +1046,9 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code); eventChar.m_keyCode = key_code; +#if wxUSE_UNICODE + eventChar.m_uniChar = gdk_keyval_to_unicode(key_code); +#endif // wxUSE_UNICODE AdjustCharEventKeyCodes(eventChar); @@ -1275,7 +1312,7 @@ extern "C" //----------------------------------------------------------------------------- static gboolean -gtk_window_button_press_callback( GtkWidget *widget, +gtk_window_button_press_callback( GtkWidget* WXUNUSED_IN_GTK3(widget), GdkEventButton *gdk_event, wxWindowGTK *win ) { @@ -1285,140 +1322,79 @@ gtk_window_button_press_callback( GtkWidget *widget, g_lastButtonNumber = gdk_event->button; - // GDK sends surplus button down events - // before a double click event. We - // need to filter these out. - if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow)) + wxEventType event_type; + wxEventType down; + wxEventType dclick; + switch (gdk_event->button) { - GdkEvent *peek_event = gdk_event_peek(); - if (peek_event) - { - if ((peek_event->type == GDK_2BUTTON_PRESS) || - (peek_event->type == GDK_3BUTTON_PRESS)) + case 1: + down = wxEVT_LEFT_DOWN; + dclick = wxEVT_LEFT_DCLICK; + break; + case 2: + down = wxEVT_MIDDLE_DOWN; + dclick = wxEVT_MIDDLE_DCLICK; + break; + case 3: + down = wxEVT_RIGHT_DOWN; + dclick = wxEVT_RIGHT_DCLICK; + break; + case 8: + down = wxEVT_AUX1_DOWN; + dclick = wxEVT_AUX1_DCLICK; + break; + case 9: + down = wxEVT_AUX2_DOWN; + dclick = wxEVT_AUX2_DCLICK; + break; + default: + return false; + } + switch (gdk_event->type) + { + case GDK_BUTTON_PRESS: + event_type = down; + // GDK sends surplus button down events + // before a double click event. We + // need to filter these out. + if (win->m_wxwindow) { - gdk_event_free( peek_event ); - return TRUE; + GdkEvent* peek_event = gdk_event_peek(); + if (peek_event) + { + const GdkEventType peek_event_type = peek_event->type; + gdk_event_free(peek_event); + if (peek_event_type == GDK_2BUTTON_PRESS || + peek_event_type == GDK_3BUTTON_PRESS) + { + return true; + } + } } - else + break; + case GDK_2BUTTON_PRESS: + event_type = dclick; +#ifndef __WXGTK3__ + if (gdk_event->button >= 1 && gdk_event->button <= 3) { - gdk_event_free( peek_event ); + // Reset GDK internal timestamp variables in order to disable GDK + // triple click events. GDK will then next time believe no button has + // been clicked just before, and send a normal button click event. + GdkDisplay* display = gtk_widget_get_display(widget); + display->button_click_time[1] = 0; + display->button_click_time[0] = 0; } - } - } - - wxEventType event_type = wxEVT_NULL; - - if ( gdk_event->type == GDK_2BUTTON_PRESS && - gdk_event->button >= 1 && gdk_event->button <= 3 ) - { - // Reset GDK internal timestamp variables in order to disable GDK - // triple click events. GDK will then next time believe no button has - // been clicked just before, and send a normal button click event. - GdkDisplay* display = gtk_widget_get_display (widget); - display->button_click_time[1] = 0; - display->button_click_time[0] = 0; - } - - if (gdk_event->button == 1) - { - // note that GDK generates triple click events which are not supported - // by wxWidgets but still have to be passed to the app as otherwise - // clicks would simply go missing - switch (gdk_event->type) - { - // we shouldn't get triple clicks at all for GTK2 because we - // suppress them artificially using the code above but we still - // should map them to something for GTK1 and not just ignore them - // as this would lose clicks - case GDK_3BUTTON_PRESS: // we could also map this to DCLICK... - case GDK_BUTTON_PRESS: - event_type = wxEVT_LEFT_DOWN; - break; - - case GDK_2BUTTON_PRESS: - event_type = wxEVT_LEFT_DCLICK; - break; - - default: - // just to silence gcc warnings - ; - } - } - else if (gdk_event->button == 2) - { - switch (gdk_event->type) - { - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_PRESS: - event_type = wxEVT_MIDDLE_DOWN; - break; - - case GDK_2BUTTON_PRESS: - event_type = wxEVT_MIDDLE_DCLICK; - break; - - default: - ; - } - } - else if (gdk_event->button == 3) - { - switch (gdk_event->type) - { - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_PRESS: - event_type = wxEVT_RIGHT_DOWN; - break; - - case GDK_2BUTTON_PRESS: - event_type = wxEVT_RIGHT_DCLICK; - break; - - default: - ; - } - } - - else if (gdk_event->button == 8) - { - switch (gdk_event->type) - { - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_PRESS: - event_type = wxEVT_AUX1_DOWN; - break; - - case GDK_2BUTTON_PRESS: - event_type = wxEVT_AUX1_DCLICK; - break; - - default: - ; - } - } - - else if (gdk_event->button == 9) - { - switch (gdk_event->type) - { - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_PRESS: - event_type = wxEVT_AUX2_DOWN; - break; - - case GDK_2BUTTON_PRESS: - event_type = wxEVT_AUX2_DCLICK; - break; - - default: - ; - } - } - - if ( event_type == wxEVT_NULL ) - { - // unknown mouse button or click type - return FALSE; +#endif // !__WXGTK3__ + break; + // we shouldn't get triple clicks at all for GTK2 because we + // suppress them artificially using the code above but we still + // should map them to something for GTK3 and not just ignore them + // as this would lose clicks + case GDK_3BUTTON_PRESS: + event_type = down; + break; + default: + return false; } g_lastMouseEvent = (GdkEvent*) gdk_event; @@ -1911,16 +1887,6 @@ gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win) win->GTKHandleRealized(); } -//----------------------------------------------------------------------------- -// "unrealize" from m_wxwindow -//----------------------------------------------------------------------------- - -static void unrealize(GtkWidget*, wxWindowGTK* win) -{ - if (win->m_imData) - gtk_im_context_set_client_window(win->m_imData->context, NULL); -} - //----------------------------------------------------------------------------- // "size_allocate" from m_wxwindow or m_widget //----------------------------------------------------------------------------- @@ -1932,10 +1898,10 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win) 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; + GtkBorder border; + WX_PIZZA(win->m_wxwindow)->get_border(border); + w -= border.left + border.right; + h -= border.top + border.bottom; if (w < 0) w = 0; if (h < 0) h = 0; } @@ -1980,29 +1946,40 @@ gtk_window_grab_broken( GtkWidget*, #endif //----------------------------------------------------------------------------- -// "style_set" +// "style_set"/"style_updated" //----------------------------------------------------------------------------- -static -void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget), - GtkStyle *previous_style, - wxWindow* win ) +#ifdef __WXGTK3__ +static void style_updated(GtkWidget*, wxWindow* win) +#else +static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win) +#endif { - if (win && previous_style) + if (win->IsTopLevel()) { - 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); } + else + { + // Border width could change, which will change client size. + // Make sure size event occurs for this + win->m_oldClientWidth = 0; + } +} + +//----------------------------------------------------------------------------- +// "unrealize" from m_wxwindow +//----------------------------------------------------------------------------- + +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); } } // extern "C" @@ -2053,6 +2030,22 @@ void wxWindowGTK::GTKHandleRealized() GTKProcessEvent( event ); GTKUpdateCursor(true, false); + + if (m_wxwindow && + (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))) + { + // attaching to style changed signal after realization avoids initial + // changes we don't care about + const gchar *detailed_signal = +#ifdef __WXGTK3__ + "style_updated"; +#else + "style_set"; +#endif + g_signal_connect(m_wxwindow, + detailed_signal, + G_CALLBACK(style_updated), this); + } } // ---------------------------------------------------------------------------- @@ -2062,6 +2055,13 @@ void wxWindowGTK::GTKHandleRealized() wxWindow *wxWindowBase::DoFindFocus() { + // For compatibility with wxMSW, pretend that showing a popup menu doesn't + // change the focus and that it remains on the window showing it, even + // though the real focus does change in GTK. + extern wxMenu *wxCurrentPopupMenu; + if ( wxCurrentPopupMenu ) + return wxCurrentPopupMenu->GetInvokingWindow(); + wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus; // the cast is necessary when we compile in wxUniversal mode return static_cast(focus); @@ -2077,9 +2077,8 @@ void wxWindowGTK::AddChildGTK(wxWindowGTK* child) child->m_x += pizza->m_scroll_x; child->m_y += pizza->m_scroll_y; - gtk_widget_set_size_request( - child->m_widget, child->m_width, child->m_height); - pizza->put(child->m_widget, child->m_x, child->m_y); + pizza->put(child->m_widget, + child->m_x, child->m_y, child->m_width, child->m_height); } //----------------------------------------------------------------------------- @@ -2092,6 +2091,29 @@ wxWindow *wxGetActiveWindow() } +// Under Unix this is implemented using X11 functions in utilsx11.cpp but we +// need to have this function under Windows too, so provide at least a stub. +#ifndef GDK_WINDOWING_X11 +bool wxGetKeyState(wxKeyCode WXUNUSED(key)) +{ + wxFAIL_MSG(wxS("Not implemented under Windows")); + return false; +} +#endif // __WINDOWS__ + +static void GetMouseState(int& x, int& y, GdkModifierType& mask) +{ + wxWindow* tlw = NULL; + if (!wxTopLevelWindows.empty()) + tlw = wxTopLevelWindows.front(); + GdkDisplay* display; + if (tlw && tlw->m_widget) + display = gtk_widget_get_display(tlw->m_widget); + else + display = gdk_display_get_default(); + gdk_display_get_pointer(display, NULL, &x, &y, &mask); +} + wxMouseState wxGetMouseState() { wxMouseState ms; @@ -2100,7 +2122,7 @@ wxMouseState wxGetMouseState() gint y; GdkModifierType mask; - gdk_window_get_pointer(NULL, &x, &y, &mask); + GetMouseState(x, y, mask); ms.SetX(x); ms.SetY(y); @@ -2148,6 +2170,9 @@ void wxWindowGTK::Init() m_noExpose = false; m_nativeSizeEvent = false; +#ifdef __WXGTK3__ + m_paintContext = NULL; +#endif m_isScrolling = false; m_mouseButtonDown = false; @@ -2189,6 +2214,71 @@ wxWindowGTK::wxWindowGTK( wxWindow *parent, Create( parent, id, pos, size, style, name ); } +void wxWindowGTK::GTKCreateScrolledWindowWith(GtkWidget* view) +{ + wxASSERT_MSG( HasFlag(wxHSCROLL) || HasFlag(wxVSCROLL), + wxS("Must not be called if scrolling is not needed.") ); + + m_widget = gtk_scrolled_window_new( NULL, NULL ); + + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); + + // There is a conflict with default bindings at GTK+ + // level between scrolled windows and notebooks both of which want to use + // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal + // direction and notebooks for changing pages -- we decide that if we don't + // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it + // means we can get working keyboard navigation in notebooks + if ( !HasFlag(wxHSCROLL) ) + { + GtkBindingSet * + bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget)); + if ( bindings ) + { + gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK); + gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK); + } + } + + if (HasFlag(wxALWAYS_SHOW_SB)) + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); + } + else + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); + } + + m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow)); + m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow)); + if (GetLayoutDirection() == wxLayout_RightToLeft) + gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE ); + + gtk_container_add( GTK_CONTAINER(m_widget), view ); + + // 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_after(m_scrollBar[dir], "value_changed", + G_CALLBACK(gtk_scrollbar_value_changed), this); + } + + gtk_widget_show( view ); +} + bool wxWindowGTK::Create( wxWindow *parent, wxWindowID id, const wxPoint &pos, @@ -2227,66 +2317,7 @@ bool wxWindowGTK::Create( wxWindow *parent, if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL)) m_widget = m_wxwindow; else - { - m_widget = gtk_scrolled_window_new( NULL, NULL ); - - GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); - - // There is a conflict with default bindings at GTK+ - // level between scrolled windows and notebooks both of which want to use - // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal - // direction and notebooks for changing pages -- we decide that if we don't - // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it - // means we can get working keyboard navigation in notebooks - if ( !HasFlag(wxHSCROLL) ) - { - GtkBindingSet * - bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget)); - if ( bindings ) - { - gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK); - gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK); - } - } - - if (HasFlag(wxALWAYS_SHOW_SB)) - { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); - } - else - { - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); - } - - m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow)); - m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow)); - 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_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_after(m_scrollBar[dir], "value_changed", - G_CALLBACK(gtk_scrollbar_value_changed), this); - } - - gtk_widget_show( m_wxwindow ); - } + GTKCreateScrolledWindowWith(m_wxwindow); g_object_ref(m_widget); if (m_parent) @@ -2388,11 +2419,14 @@ void wxWindowGTK::PostCreation() IsTransparentBackgroundSupported() ) { GdkScreen *screen = gtk_widget_get_screen (m_widget); - +#ifdef __WXGTK3__ + gtk_widget_set_visual(m_widget, gdk_screen_get_rgba_visual(screen)); +#else GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen); if (rgba_colormap) gtk_widget_set_colormap(m_widget, rgba_colormap); +#endif } #endif // wxGTK_HAS_COMPOSITING_SUPPORT @@ -2401,9 +2435,11 @@ void wxWindowGTK::PostCreation() if (!m_noExpose) { // these get reported to wxWidgets -> wxPaintEvent - - g_signal_connect (m_wxwindow, "expose_event", - G_CALLBACK (gtk_window_expose_callback), this); +#ifdef __WXGTK3__ + g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this); +#else + g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(expose_event), this); +#endif if (GetLayoutDirection() == wxLayout_LeftToRight) gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE)); @@ -2477,7 +2513,9 @@ void wxWindowGTK::PostCreation() } #if GTK_CHECK_VERSION(2, 8, 0) +#ifndef __WXGTK3__ if ( gtk_check_version(2,8,0) == NULL ) +#endif { // Make sure we can notify the app when mouse capture is lost if ( m_wxwindow ) @@ -2494,16 +2532,8 @@ void wxWindowGTK::PostCreation() } #endif // GTK+ >= 2.8 - if ( GTKShouldConnectSizeRequest() ) - { - // This is needed if we want to add our windows into native - // GTK controls, such as the toolbar. With this callback, the - // toolbar gets to know the correct size (the one set by the - // programmer). Sadly, it misbehaves for wxComboBox. - g_signal_connect (m_widget, "size_request", - G_CALLBACK (wxgtk_window_size_request_callback), - this); - } + 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(); @@ -2551,10 +2581,6 @@ 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 (m_wxwindow && (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))) - g_signal_connect (m_wxwindow, "style_set", - G_CALLBACK (gtk_window_style_set_callback), this); } bool wxWindowGTK::Destroy() @@ -2564,14 +2590,46 @@ bool wxWindowGTK::Destroy() return wxWindowBase::Destroy(); } +static GSList* gs_queueResizeList; + +extern "C" { +static gboolean queue_resize(void*) +{ + gdk_threads_enter(); + for (GSList* p = gs_queueResizeList; p; p = p->next) + { + if (p->data) + { + gtk_widget_queue_resize(GTK_WIDGET(p->data)); + g_object_remove_weak_pointer(G_OBJECT(p->data), &p->data); + } + } + g_slist_free(gs_queueResizeList); + gs_queueResizeList = NULL; + gdk_threads_leave(); + return false; +} +} + void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { gtk_widget_set_size_request(m_widget, width, height); + GtkWidget* parent = gtk_widget_get_parent(m_widget); + if (WX_IS_PIZZA(parent)) + WX_PIZZA(parent)->move(m_widget, x, y, width, height); - // inform the parent to perform the move - wxASSERT_MSG(m_parent && m_parent->m_wxwindow, - "the parent window has no client area?"); - WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y); + // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate + // is in progress. This situation is common in wxWidgets, since + // size-allocate can generate wxSizeEvent and size event handlers often + // call SetSize(), directly or indirectly. Work around this by deferring + // the queue-resize until after size-allocate processing is finished. + if (g_slist_find(gs_queueResizeList, m_widget) == NULL) + { + if (gs_queueResizeList == NULL) + g_idle_add_full(GTK_PRIORITY_RESIZE, queue_resize, NULL, NULL); + gs_queueResizeList = g_slist_prepend(gs_queueResizeList, m_widget); + g_object_add_weak_pointer(G_OBJECT(m_widget), &gs_queueResizeList->data); + } } void wxWindowGTK::ConstrainSize() @@ -2593,8 +2651,7 @@ void wxWindowGTK::ConstrainSize() 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") ); + wxCHECK_RET(m_widget, "invalid window"); int scrollX = 0, scrollY = 0; GtkWidget* parent = gtk_widget_get_parent(m_widget); @@ -2636,14 +2693,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags m_y = y; m_width = width; m_height = height; - } - - if (m_parent->m_wxwindow) - { - int left_border = 0; - int right_border = 0; - int top_border = 0; - int bottom_border = 0; /* the default button has a border around it */ if (gtk_widget_get_can_default(m_widget)) @@ -2652,30 +2701,23 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags gtk_widget_style_get( m_widget, "default_border", &default_border, NULL ); if (default_border) { - left_border += default_border->left; - right_border += default_border->right; - top_border += default_border->top; - bottom_border += default_border->bottom; + x -= default_border->left; + y -= default_border->top; + width += default_border->left + default_border->right; + height += default_border->top + default_border->bottom; gtk_border_free( default_border ); } } - DoMoveWindow( m_x - left_border, - m_y - top_border, - m_width+left_border+right_border, - m_height+top_border+bottom_border ); + DoMoveWindow(x, y, width, height); } - if (sizeChange) + if ((sizeChange && !m_nativeSizeEvent) || (sizeFlags & wxSIZE_FORCE_EVENT)) { // update these variables to keep size_allocate handler // from sending another size event for this change GetClientSize( &m_oldClientWidth, &m_oldClientHeight ); - gtk_widget_queue_resize(m_widget); - } - if ((sizeChange && !m_nativeSizeEvent) || (sizeFlags & wxSIZE_FORCE_EVENT)) - { wxSizeEvent event( wxSize(m_width,m_height), GetId() ); event.SetEventObject( this ); HandleWindowEvent( event ); @@ -2751,6 +2793,8 @@ 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 = + GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing; for ( int i = 0; i < ScrollDir_Max; i++ ) { @@ -2777,15 +2821,32 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const continue; } - GtkScrolledWindowClass *scroll_class = - GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); - GtkRequisition req; +#ifdef __WXGTK3__ + GtkWidget* widget = GTK_WIDGET(range); + if (i == ScrollDir_Horz) + { + if (height) + { + gtk_widget_get_preferred_height(widget, NULL, &req.height); + h -= req.height + scrollbar_spacing; + } + } + else + { + if (width) + { + gtk_widget_get_preferred_width(widget, NULL, &req.width); + w -= req.width + scrollbar_spacing; + } + } +#else // !__WXGTK3__ gtk_widget_size_request(GTK_WIDGET(range), &req); if (i == ScrollDir_Horz) - h -= req.height + scroll_class->scrollbar_spacing; + h -= req.height + scrollbar_spacing; else - w -= req.width + scroll_class->scrollbar_spacing; + w -= req.width + scrollbar_spacing; +#endif // !__WXGTK3__ } } @@ -2808,10 +2869,9 @@ wxSize wxWindowGTK::DoGetBorderSize() const if ( !m_wxwindow ) return wxWindowBase::DoGetBorderSize(); - int x, y; - WX_PIZZA(m_wxwindow)->get_border_widths(x, y); - - return 2*wxSize(x, y); + GtkBorder border; + WX_PIZZA(m_wxwindow)->get_border(border); + return wxSize(border.left + border.right, border.top + border.bottom); } void wxWindowGTK::DoGetPosition( int *x, int *y ) const @@ -3421,7 +3481,7 @@ bool wxWindowGTK::DoNavigateIn(int flags) gboolean rc; g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc); - return rc == TRUE; + return rc != 0; } } @@ -3581,7 +3641,7 @@ void wxWindowGTK::WarpPointer( int x, int y ) ClientToScreen(&x, &y); GdkDisplay* display = gtk_widget_get_display(m_widget); GdkScreen* screen = gtk_widget_get_screen(m_widget); -#ifdef __WXGTK30__ +#ifdef __WXGTK3__ GdkDeviceManager* manager = gdk_display_get_device_manager(display); gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y); #else @@ -3700,16 +3760,23 @@ bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const return m_updateRegion.Contains(x, y, w, h) != wxOutRegion; } -void wxWindowGTK::GtkSendPaintEvents() +#ifdef __WXGTK3__ +void wxWindowGTK::GTKSendPaintEvents(cairo_t* cr) +#else +void wxWindowGTK::GTKSendPaintEvents(const GdkRegion* region) +#endif { - if (!m_wxwindow) - { - m_updateRegion.Clear(); - return; - } +#ifdef __WXGTK3__ + m_paintContext = cr; + double x1, y1, x2, y2; + cairo_clip_extents(cr, &x1, &y1, &x2, &y2); + m_updateRegion = wxRegion(int(x1), int(y1), int(x2 - x1), int(y2 - y1)); +#else // !__WXGTK3__ + m_updateRegion = wxRegion(region); #if wxGTK_HAS_COMPOSITING_SUPPORT cairo_t* cr = NULL; #endif +#endif // !__WXGTK3__ // Clip to paint region in wxClientDC m_clipPaintRegion = true; @@ -3720,8 +3787,7 @@ void wxWindowGTK::GtkSendPaintEvents() // Transform m_updateRegion under RTL m_updateRegion.Clear(); - gint width; - gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL); + const int width = gdk_window_get_width(GTKGetDrawingWindow()); wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) @@ -3750,20 +3816,26 @@ void wxWindowGTK::GtkSendPaintEvents() // explicitly paint. // NB: it works also for top level windows (but this is the // windows manager which then does the compositing job) +#ifndef __WXGTK3__ cr = gdk_cairo_create(m_wxwindow->window); gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion()); cairo_clip(cr); - +#endif cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); +#ifndef __WXGTK3__ cairo_surface_flush(cairo_get_target(cr)); +#endif } #endif // wxGTK_HAS_COMPOSITING_SUPPORT break; case wxBG_STYLE_ERASE: { +#ifdef __WXGTK3__ + wxGTKCairoDC dc(cr); +#else wxWindowDC dc( (wxWindow*)this ); dc.SetDeviceClippingRegion( m_updateRegion ); @@ -3776,7 +3848,7 @@ void wxWindowGTK::GtkSendPaintEvents() dc.SetBackground(GetBackgroundColour()); dc.Clear(); } - +#endif // !__WXGTK3__ wxEraseEvent erase_event( GetId(), &dc ); erase_event.SetEventObject( this ); @@ -3791,34 +3863,28 @@ void wxWindowGTK::GtkSendPaintEvents() case wxBG_STYLE_SYSTEM: if ( GetThemeEnabled() ) { + GdkWindow* gdkWindow = GTKGetDrawingWindow(); + const int w = gdk_window_get_width(gdkWindow); + const int h = gdk_window_get_height(gdkWindow); +#ifdef __WXGTK3__ + GtkStyleContext* sc = gtk_widget_get_style_context(m_wxwindow); + gtk_render_background(sc, cr, 0, 0, w, h); +#else // find ancestor from which to steal background wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); if (!parent) parent = (wxWindow*)this; - - if (gtk_widget_get_mapped(parent->m_widget)) - { - wxRegionIterator upd( m_nativeUpdateRegion ); - while (upd) - { - GdkRectangle rect; - rect.x = upd.GetX(); - rect.y = upd.GetY(); - rect.width = upd.GetWidth(); - rect.height = upd.GetHeight(); - - gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget), - GTKGetDrawingWindow(), + GdkRectangle rect; + m_nativeUpdateRegion.GetBox(rect.x, rect.y, rect.width, rect.height); + gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget), + gdkWindow, gtk_widget_get_state(m_wxwindow), GTK_SHADOW_NONE, &rect, parent->m_widget, (char *)"base", - 0, 0, -1, -1 ); - - ++upd; - } - } + 0, 0, w, h); +#endif // !__WXGTK3__ } break; @@ -3848,13 +3914,14 @@ void wxWindowGTK::GtkSendPaintEvents() wxWindow *compositeChild = node->GetData(); if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT) { +#ifndef __WXGTK3__ if (cr == NULL) { cr = gdk_cairo_create(m_wxwindow->window); gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion()); cairo_clip(cr); } - +#endif // !__WXGTK3__ GtkWidget *child = compositeChild->m_wxwindow; GtkAllocation alloc; gtk_widget_get_allocation(child, &alloc); @@ -3866,13 +3933,17 @@ void wxWindowGTK::GtkSendPaintEvents() cairo_paint(cr); } } +#ifndef __WXGTK3__ if (cr) cairo_destroy(cr); +#endif } #endif // wxGTK_HAS_COMPOSITING_SUPPORT m_clipPaintRegion = false; - +#ifdef __WXGTK3__ + m_paintContext = NULL; +#endif m_updateRegion.Clear(); m_nativeUpdateRegion.Clear(); } @@ -3887,7 +3958,7 @@ void wxWindowGTK::SetDoubleBuffered( bool on ) bool wxWindowGTK::IsDoubleBuffered() const { - return gtk_widget_get_double_buffered( m_wxwindow ); + return gtk_widget_get_double_buffered( m_wxwindow ) != 0; } void wxWindowGTK::ClearBackground() @@ -3922,11 +3993,13 @@ bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) if (!wxWindowBase::SetBackgroundColour(colour)) return false; +#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) @@ -3944,11 +4017,13 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) return false; } +#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): @@ -3962,6 +4037,7 @@ PangoContext *wxWindowGTK::GTKGetPangoDefaultContext() return gtk_widget_get_pango_context( m_widget ); } +#ifndef __WXGTK3__ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle) { // do we need to apply any changes at all? @@ -4030,15 +4106,20 @@ GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle) return style; } +#endif // !__WXGTK3__ -void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle) +void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle)) { +#ifdef __WXGTK3__ + DoApplyWidgetStyle(NULL); +#else GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle); if ( style ) { DoApplyWidgetStyle(style); g_object_unref(style); } +#endif // Style change may affect GTK+'s size calculation: InvalidateBestSize(); @@ -4046,37 +4127,47 @@ void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle) void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) { - if ( m_wxwindow ) + GtkWidget* widget = m_wxwindow ? m_wxwindow : m_widget; + + // block the signal temporarily to avoid sending + // wxSysColourChangedEvents when we change the colours ourselves + bool unblock = false; + if (m_wxwindow && IsTopLevel()) { - // block the signal temporarily to avoid sending - // wxSysColourChangedEvents when we change the colours ourselves - bool unblock = false; - if ( IsTopLevel() ) - { - unblock = true; - g_signal_handlers_block_by_func( - m_wxwindow, (void *)gtk_window_style_set_callback, this); - } + unblock = true; + g_signal_handlers_block_by_func( + m_wxwindow, (void*)style_updated, this); + } - gtk_widget_modify_style(m_wxwindow, style); + GTKApplyStyle(widget, style); - if ( unblock ) - { - g_signal_handlers_unblock_by_func( - m_wxwindow, (void *)gtk_window_style_set_callback, this); - } - } - else + if (unblock) { - gtk_widget_modify_style(m_widget, style); + g_signal_handlers_unblock_by_func( + m_wxwindow, (void*)style_updated, this); } } +void wxWindowGTK::GTKApplyStyle(GtkWidget* widget, GtkRcStyle* WXUNUSED_IN_GTK3(style)) +{ +#ifdef __WXGTK3__ + const PangoFontDescription* pfd = NULL; + if (m_font.IsOk()) + pfd = pango_font_description_copy(m_font.GetNativeFontInfo()->description); + 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); +#else + gtk_widget_modify_style(widget, style); +#endif +} + bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) { if (!wxWindowBase::SetBackgroundStyle(style)) return false; +#ifndef __WXGTK3__ GdkWindow *window; if ( m_wxwindow ) { @@ -4113,6 +4204,7 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) // even if the bg colour changed from valid to wxNullColour): GTKApplyWidgetStyle(true); } +#endif // !__WXGTK3__ return true; } @@ -4120,6 +4212,7 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const { #if wxGTK_HAS_COMPOSITING_SUPPORT +#ifndef __WXGTK3__ if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL) { if (reason) @@ -4131,6 +4224,7 @@ bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const return false; } +#endif // !__WXGTK3__ // NB: We don't check here if the particular kind of widget supports // transparency, we check only if it would be possible for a generic window @@ -4155,9 +4249,9 @@ bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const *reason = _("This program was compiled with a too old version of GTK+, " "please rebuild with GTK+ 2.12 or newer."); } -#endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT return false; +#endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT } // ---------------------------------------------------------------------------- @@ -4192,14 +4286,6 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) { wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); - // For compatibility with other ports, pretend that the window showing the - // menu has focus while the menu is shown. This is needed because the popup - // menu actually steals the focus from the window it's associated it in - // wxGTK unlike, say, wxMSW. - wxWindowGTK* const oldPendingFocus = gs_pendingFocus; - gs_pendingFocus = this; - wxON_BLOCK_EXIT_SET( gs_pendingFocus, oldPendingFocus ); - menu->UpdateUI(); wxPoint pos; @@ -4564,17 +4650,9 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt) // Get the current mouse position. wxPoint wxGetMousePosition() { - wxWindow* tlw = NULL; - if (!wxTopLevelWindows.empty()) - tlw = wxTopLevelWindows.front(); - GdkDisplay* display; - if (tlw && tlw->m_widget) - display = gtk_widget_get_display(tlw->m_widget); - else - display = gdk_display_get_default(); - int x, y; - gdk_display_get_pointer(display, NULL, &x, &y, NULL); + GdkModifierType unused; + GetMouseState(x, y, unused); return wxPoint(x, y); }