X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/843101f7660e5e4411769c179398fbf172a441ff..d361ea0db52530cffcce3ef2dd92f9b1516288c6:/src/gtk/window.cpp?ds=sidebyside diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 2c416d0e80..f5d1fbb070 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -31,42 +31,30 @@ #include "wx/tooltip.h" #include "wx/caret.h" #include "wx/fontutil.h" +#include "wx/scopeguard.h" #include "wx/sysopt.h" #include #include "wx/gtk/private.h" #include "wx/gtk/private/win_gtk.h" +#include "wx/gtk/private/event.h" +using namespace wxGTKImpl; +#ifdef GDK_WINDOWING_X11 #include +#else +typedef guint KeySym; +#endif #include #if GTK_CHECK_VERSION(3,0,0) #include #endif -#if !GTK_CHECK_VERSION(2,10,0) - // GTK+ can reliably detect Meta key state only since 2.10 when - // GDK_META_MASK was introduced -- there wasn't any way to detect it - // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but - // GDK_MOD2_MASK is documented as: - // - // the fifth modifier key (it depends on the modifier mapping of the X - // server which key is interpreted as this modifier) - // - // In other words, it isn't guaranteed to map to Meta. This is a real - // problem: it is common to map NumLock to it (in fact, it's an exception - // if the X server _doesn't_ use it for NumLock). So the old code caused - // wxKeyEvent::MetaDown() to always return true as long as NumLock was on - // on many systems, which broke all applications using - // wxKeyEvent::GetModifiers() to check modifiers state (see e.g. here: - // http://tinyurl.com/56lsk2). - // - // Because of this, it's better to not detect Meta key state at all than - // to detect it incorrectly. Hence the following #define, which causes - // m_metaDown to be always set to false. - #define GDK_META_MASK 0 -#endif +// gdk_window_set_composited() is only supported since 2.12 +#define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0 +#define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0) //----------------------------------------------------------------------------- // documentation on internals @@ -337,7 +325,7 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win) extern "C" { static void -parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win) +parent_set(GtkWidget* widget, GtkWidget* old_parent, wxWindow* win) { if (old_parent) { @@ -358,18 +346,6 @@ parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win) // "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 wxT("keyevent") @@ -756,6 +732,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, keysym = (KeySym)gdk_event->string[0]; } +#ifdef GDK_WINDOWING_X11 // we want to always get the same key code when the same key is // pressed regardless of the state of the modifiers, i.e. on a // standard US keyboard pressing '5' or '%' ('5' key with @@ -774,6 +751,9 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, // use the normalized, i.e. lower register, keysym if we've // got one key_code = keysymNormalized ? keysymNormalized : keysym; +#else + key_code = keysym; +#endif // as explained above, we want to have lower register key codes // normally but for the letter keys we want to have the upper ones @@ -851,34 +831,58 @@ struct wxGtkIMData namespace { -// Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't -// processed, send wxEVT_CHAR to the window itself. Return true if either of -// them was handled. -bool -SendCharHookAndCharEvents(const wxKeyEvent& event, wxWindow *win) +// Send wxEVT_CHAR_HOOK event to the parent of the window and return true only +// if it was processed (and not skipped). +bool SendCharHookEvent(const wxKeyEvent& event, wxWindow *win) { - // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it + // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog + // which typically closes when Esc key is pressed in any of its controls) // to handle key events in all of its children unless the mouse is captured // in which case we consider that the keyboard should be "captured" too. if ( !g_captureWindow ) { - wxWindow * const parent = wxGetTopLevelParent(win); - if ( parent ) - { - // We need to make a copy of the event object because it is - // modified while it's handled, notably its WasProcessed() flag - // is set after it had been processed once. - wxKeyEvent eventCharHook(event); - eventCharHook.SetEventType(wxEVT_CHAR_HOOK); - if ( parent->HandleWindowEvent(eventCharHook) ) - return true; - } + wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event); + if ( win->HandleWindowEvent(eventCharHook) + && !event.IsNextEventAllowed() ) + return true; } - // As above, make a copy of the event first. - wxKeyEvent eventChar(event); - eventChar.SetEventType(wxEVT_CHAR); - return win->HandleWindowEvent(eventChar); + return false; +} + +// Adjust wxEVT_CHAR event key code fields. This function takes care of two +// conventions: +// (a) Ctrl-letter key presses generate key codes in range 1..26 +// (b) Unicode key codes are same as key codes for the codes in 1..255 range +void AdjustCharEventKeyCodes(wxKeyEvent& event) +{ + const int code = event.m_keyCode; + + // Check for (a) above. + if ( event.ControlDown() ) + { + // We intentionally don't use isupper/lower() here, we really need + // ASCII letters only as it doesn't make sense to translate any other + // ones into this range which has only 26 slots. + if ( code >= 'a' && code <= 'z' ) + event.m_keyCode = code - 'a' + 1; + else if ( code >= 'A' && code <= 'Z' ) + event.m_keyCode = code - 'A' + 1; + +#if wxUSE_UNICODE + // Adjust the Unicode equivalent in the same way too. + if ( event.m_keyCode != code ) + event.m_uniChar = event.m_keyCode; +#endif // wxUSE_UNICODE + } + +#if wxUSE_UNICODE + // Check for (b) from above. + // + // FIXME: Should we do it for key codes up to 255? + if ( !event.m_uniChar && code < WXK_DELETE ) + event.m_uniChar = code; +#endif // wxUSE_UNICODE } } // anonymous namespace @@ -900,6 +904,13 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) { + // Send the CHAR_HOOK event first + if ( SendCharHookEvent(event, win) ) + { + // Don't do anything at all with this event any more. + return TRUE; + } + // Emit KEY_DOWN event ret = win->HandleWindowEvent( event ); } @@ -983,25 +994,15 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), if ( key_code ) { + wxKeyEvent eventChar(wxEVT_CHAR, event); + wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code); - event.m_keyCode = key_code; + eventChar.m_keyCode = key_code; - // To conform to the docs we need to translate Ctrl-alpha - // characters to values in the range 1-26. - if ( event.ControlDown() && - ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) )) - { - 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 - } + AdjustCharEventKeyCodes(eventChar); - ret = SendCharHookAndCharEvents(event, win); + ret = win->HandleWindowEvent(eventChar); } } @@ -1015,7 +1016,7 @@ gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context), const gchar *str, wxWindow *window) { - wxKeyEvent event( wxEVT_KEY_DOWN ); + wxKeyEvent event( wxEVT_CHAR ); // take modifiers, cursor position, timestamp etc. from the last // key_press_event that was fed into Input Method: @@ -1044,23 +1045,9 @@ gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context), event.m_keyCode = (char)*pstr; #endif // wxUSE_UNICODE - // To conform to the docs we need to translate Ctrl-alpha - // characters to values in the range 1-26. - 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; -#endif - } + AdjustCharEventKeyCodes(event); - SendCharHookAndCharEvents(event, window); + window->HandleWindowEvent(event); } } } @@ -1093,6 +1080,21 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), } } +//----------------------------------------------------------------------------- +// key and mouse events, after, from m_widget +//----------------------------------------------------------------------------- + +extern "C" { +static gboolean key_and_mouse_event_after(GtkWidget* widget, GdkEventKey*, wxWindow*) +{ + // If a widget does not handle a key or mouse event, GTK+ sends it up the + // parent chain until it is handled. These events are not supposed to + // propagate in wxWidgets, so prevent it unless widget is in a native + // container. + return WX_IS_PIZZA(gtk_widget_get_parent(widget)); +} +} + // ============================================================================ // the mouse events // ============================================================================ @@ -1101,43 +1103,6 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), // mouse event processing helpers // ---------------------------------------------------------------------------- -// init wxMouseEvent with the info from GdkEventXXX struct -template void InitMouseEvent(wxWindowGTK *win, - wxMouseEvent& event, - T *gdk_event) -{ - event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; - event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; - event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; - event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0; - event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0; - event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0; - event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0; - - // In gdk/win32 VK_XBUTTON1 is translated to GDK_BUTTON4_MASK - // and VK_XBUTTON2 to GDK_BUTTON5_MASK. In x11/gdk buttons 4/5 - // are wheel rotation and buttons 8/9 don't change the state. - event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0; - event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0; - - wxPoint pt = win->GetClientAreaOrigin(); - event.m_x = (wxCoord)gdk_event->x - pt.x; - event.m_y = (wxCoord)gdk_event->y - pt.y; - - if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft)) - { - // origin in the upper right corner - GtkAllocation a; - gtk_widget_get_allocation(win->m_wxwindow, &a); - int window_width = a.width; - event.m_x = window_width - event.m_x; - } - - event.SetEventObject( win ); - event.SetId( win->GetId() ); - event.SetTimestamp( gdk_event->time ); -} - static void AdjustEventButtonState(wxMouseEvent& event) { // GDK reports the old state of the button for a button press event, but @@ -1184,7 +1149,7 @@ static void AdjustEventButtonState(wxMouseEvent& event) } } -// find the window to send the mouse event too +// find the window to send the mouse event to static wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) { @@ -1234,6 +1199,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) else { if ((child->m_wxwindow == NULL) && + win->IsClientAreaChild(child) && (child->m_x <= xx) && (child->m_y <= yy) && (child->m_x+child->m_width >= xx) && @@ -1913,38 +1879,19 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w //----------------------------------------------------------------------------- static void -gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindow* win) +gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win) { win->GTKHandleRealized(); } -void wxWindowGTK::GTKHandleRealized() -{ - if (m_imData) - { - gtk_im_context_set_client_window - ( - m_imData->context, - m_wxwindow ? GTKGetDrawingWindow() - : gtk_widget_get_window(m_widget) - ); - } - - // 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) - { - SetBackgroundStyle(GetBackgroundStyle()); - m_needsStyleChange = false; - } - - wxWindowCreateEvent event( this ); - event.SetEventObject( this ); - GTKProcessEvent( event ); +//----------------------------------------------------------------------------- +// "unrealize" from m_wxwindow +//----------------------------------------------------------------------------- - GTKUpdateCursor(true, false); +static void unrealize(GtkWidget*, wxWindowGTK* win) +{ + if (win->m_imData) + gtk_im_context_set_client_window(win->m_imData->context, NULL); } //----------------------------------------------------------------------------- @@ -2016,15 +1963,71 @@ void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget), { if (win && previous_style) { - wxSysColourChangedEvent event; - event.SetEventObject(win); - - win->GTKProcessEvent( event ); + 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; + } } } } // extern "C" +void wxWindowGTK::GTKHandleRealized() +{ + if (m_imData) + { + gtk_im_context_set_client_window + ( + m_imData->context, + m_wxwindow ? GTKGetDrawingWindow() + : gtk_widget_get_window(m_widget) + ); + } + + // Use composited window if background is transparent, if supported. + if (m_backgroundStyle == wxBG_STYLE_TRANSPARENT) + { +#if wxGTK_HAS_COMPOSITING_SUPPORT + if (IsTransparentBackgroundSupported()) + { + GdkWindow* const window = GTKGetDrawingWindow(); + if (window) + gdk_window_set_composited(window, true); + } + else +#endif // wxGTK_HAS_COMPOSITING_SUPPORT + { + // We revert to erase mode if transparency is not supported + m_backgroundStyle = wxBG_STYLE_ERASE; + } + } + + + // 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) + { + SetBackgroundStyle(GetBackgroundStyle()); + m_needsStyleChange = false; + } + + wxWindowCreateEvent event(static_cast(this)); + event.SetEventObject( this ); + GTKProcessEvent( event ); + + GTKUpdateCursor(true, false); +} + // ---------------------------------------------------------------------------- // this wxWindowBase function is implemented here (in platform-specific file) // because it is static and so couldn't be made virtual @@ -2305,6 +2308,7 @@ wxWindowGTK::~wxWindowGTK() // delete before the widgets to avoid a crash on solaris delete m_imData; + m_imData = NULL; // 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 @@ -2337,8 +2341,11 @@ bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const w m_width = WidthDefault(size.x) ; m_height = HeightDefault(size.y); - m_x = (int)pos.x; - m_y = (int)pos.y; + if (pos != wxDefaultPosition) + { + m_x = pos.x; + m_y = pos.y; + } return true; } @@ -2347,6 +2354,21 @@ void wxWindowGTK::PostCreation() { wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); +#if wxGTK_HAS_COMPOSITING_SUPPORT + // Set RGBA visual as soon as possible to minimize the possibility that + // somebody uses the wrong one. + if ( m_backgroundStyle == wxBG_STYLE_TRANSPARENT && + IsTransparentBackgroundSupported() ) + { + GdkScreen *screen = gtk_widget_get_screen (m_widget); + + GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen); + + if (rgba_colormap) + gtk_widget_set_colormap(m_widget, rgba_colormap); + } +#endif // wxGTK_HAS_COMPOSITING_SUPPORT + if (m_wxwindow) { if (!m_noExpose) @@ -2368,6 +2390,7 @@ 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 @@ -2407,6 +2430,18 @@ void wxWindowGTK::PostCreation() ConnectWidget( connect_widget ); + // connect handler to prevent events from propagating up parent chain + g_signal_connect_after(m_widget, + "key_press_event", G_CALLBACK(key_and_mouse_event_after), this); + g_signal_connect_after(m_widget, + "key_release_event", G_CALLBACK(key_and_mouse_event_after), this); + g_signal_connect_after(m_widget, + "button_press_event", G_CALLBACK(key_and_mouse_event_after), this); + g_signal_connect_after(m_widget, + "button_release_event", G_CALLBACK(key_and_mouse_event_after), this); + g_signal_connect_after(m_widget, + "motion_notify_event", G_CALLBACK(key_and_mouse_event_after), this); + // We cannot set colours, fonts and cursors before the widget has been // realized, so we do this directly after realization -- unless the widget // was in fact realized already. @@ -2467,7 +2502,8 @@ void wxWindowGTK::PostCreation() gtk_widget_show( m_widget ); } -unsigned long wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)()) +unsigned long +wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback) { return g_signal_connect(m_widget, signal, callback, this); } @@ -2501,7 +2537,7 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) g_signal_connect (widget, "leave_notify_event", G_CALLBACK (gtk_window_leave_callback), this); - if (IsTopLevel() && m_wxwindow) + 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); } @@ -2545,12 +2581,15 @@ 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") ); - int currentX, currentY; - GetPosition(¤tX, ¤tY); - if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) - x = currentX; - if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) - y = currentY; + if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0 && (x == -1 || y == -1)) + { + int currentX, currentY; + GetPosition(¤tX, ¤tY); + if (x == -1) + x = currentX; + if (y == -1) + y = currentY; + } AdjustForParentClientOrigin(x, y, sizeFlags); // calculate the best size if we should auto size the window @@ -2659,21 +2698,11 @@ void wxWindowGTK::OnInternalIdle() RealizeTabOrder(); } - // Update style if the window was not yet realized when - // SetBackgroundStyle() was called - if (m_needsStyleChange) - { - SetBackgroundStyle(GetBackgroundStyle()); - m_needsStyleChange = false; - } - wxWindowBase::OnInternalIdle(); } void wxWindowGTK::DoGetSize( int *width, int *height ) const { - wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (width) (*width) = m_width; if (height) (*height) = m_height; } @@ -2768,39 +2797,17 @@ wxSize wxWindowGTK::DoGetBorderSize() const void wxWindowGTK::DoGetPosition( int *x, int *y ) const { - wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - int dx = 0; int dy = 0; - if (!IsTopLevel() && m_parent && m_parent->m_wxwindow) + GtkWidget* parent = NULL; + if (m_widget) + parent = gtk_widget_get_parent(m_widget); + if (WX_IS_PIZZA(parent)) { - wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow); + wxPizza* pizza = WX_PIZZA(parent); dx = pizza->m_scroll_x; dy = pizza->m_scroll_y; } - - if (m_x == -1 && m_y == -1) - { - GdkWindow *source = NULL; - if (m_wxwindow) - source = gtk_widget_get_window(m_wxwindow); - else - source = gtk_widget_get_window(m_widget); - - if (source) - { - int org_x = 0; - int org_y = 0; - gdk_window_get_origin( source, &org_x, &org_y ); - - if (m_parent) - m_parent->ScreenToClient(&org_x, &org_y); - - const_cast(this)->m_x = org_x; - const_cast(this)->m_y = org_y; - } - } - if (x) (*x) = m_x - dx; if (y) (*y) = m_y - dy; } @@ -3559,11 +3566,13 @@ void wxWindowGTK::WarpPointer( int x, int y ) GdkDeviceManager* manager = gdk_display_get_device_manager(display); gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y); #else +#ifdef GDK_WINDOWING_X11 XWarpPointer(GDK_DISPLAY_XDISPLAY(display), None, GDK_WINDOW_XID(gdk_screen_get_root_window(screen)), 0, 0, 0, 0, x, y); #endif +#endif } wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const @@ -3612,43 +3621,31 @@ bool wxWindowGTK::ScrollPages(int pages) void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground), const wxRect *rect) { - if ( !m_widget ) - { - // it is valid to call Refresh() for a window which hasn't been created - // yet, it simply doesn't do anything in this case - return; - } - - if (!m_wxwindow) + if (m_wxwindow) { - if (rect) - gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height ); - else - gtk_widget_queue_draw( m_widget ); + if (gtk_widget_get_mapped(m_wxwindow)) + { + GdkWindow* window = gtk_widget_get_window(m_wxwindow); + if (rect) + { + GdkRectangle r = { rect->x, rect->y, rect->width, rect->height }; + if (GetLayoutDirection() == wxLayout_RightToLeft) + r.x = gdk_window_get_width(window) - r.x - rect->width; + gdk_window_invalidate_rect(window, &r, true); + } + else + gdk_window_invalidate_rect(window, NULL, true); + } } - else + else if (m_widget) { - // Just return if the widget or one of its ancestors isn't mapped - GtkWidget *w; - for (w = m_wxwindow; w != NULL; w = gtk_widget_get_parent(w)) - if (!gtk_widget_get_mapped (w)) - return; - - GdkWindow* window = GTKGetDrawingWindow(); - if (rect) + if (gtk_widget_get_mapped(m_widget)) { - int x = rect->x; - if (GetLayoutDirection() == wxLayout_RightToLeft) - x = GetClientSize().x - x - rect->width; - GdkRectangle r; - r.x = rect->x; - r.y = rect->y; - r.width = rect->width; - r.height = rect->height; - gdk_window_invalidate_rect(window, &r, true); + if (rect) + gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height); + else + gtk_widget_queue_draw(m_widget); } - else - gdk_window_invalidate_rect(window, NULL, true); } } @@ -3691,7 +3688,9 @@ void wxWindowGTK::GtkSendPaintEvents() m_updateRegion.Clear(); return; } - +#if wxGTK_HAS_COMPOSITING_SUPPORT + cairo_t* cr = NULL; +#endif // Clip to paint region in wxClientDC m_clipPaintRegion = true; @@ -3723,6 +3722,27 @@ void wxWindowGTK::GtkSendPaintEvents() switch ( GetBackgroundStyle() ) { + case wxBG_STYLE_TRANSPARENT: +#if wxGTK_HAS_COMPOSITING_SUPPORT + if (IsTransparentBackgroundSupported()) + { + // Set a transparent background, so that overlaying in parent + // might indeed let see through where this child did not + // explicitly paint. + // NB: it works also for top level windows (but this is the + // windows manager which then does the compositing job) + cr = gdk_cairo_create(m_wxwindow->window); + gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion()); + cairo_clip(cr); + + cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); + cairo_paint(cr); + cairo_set_operator(cr, CAIRO_OPERATOR_OVER); + cairo_surface_flush(cairo_get_target(cr)); + } +#endif // wxGTK_HAS_COMPOSITING_SUPPORT + break; + case wxBG_STYLE_ERASE: { wxWindowDC dc( (wxWindow*)this ); @@ -3799,6 +3819,39 @@ void wxWindowGTK::GtkSendPaintEvents() paint_event.SetEventObject( this ); HandleWindowEvent( paint_event ); +#if wxGTK_HAS_COMPOSITING_SUPPORT + if (IsTransparentBackgroundSupported()) + { // now composite children which need it + // Overlay all our composite children on top of the painted area + wxWindowList::compatibility_iterator node; + for ( node = m_children.GetFirst(); node ; node = node->GetNext() ) + { + wxWindow *compositeChild = node->GetData(); + if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT) + { + if (cr == NULL) + { + cr = gdk_cairo_create(m_wxwindow->window); + gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion()); + cairo_clip(cr); + } + + GtkWidget *child = compositeChild->m_wxwindow; + GtkAllocation alloc; + gtk_widget_get_allocation(child, &alloc); + + // The source data is the (composited) child + gdk_cairo_set_source_window( + cr, gtk_widget_get_window(child), alloc.x, alloc.y); + + cairo_paint(cr); + } + } + if (cr) + cairo_destroy(cr); + } +#endif // wxGTK_HAS_COMPOSITING_SUPPORT + m_clipPaintRegion = false; m_updateRegion.Clear(); @@ -4002,35 +4055,34 @@ void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) { - wxWindowBase::SetBackgroundStyle(style); + if (!wxWindowBase::SetBackgroundStyle(style)) + return false; - if ( style == wxBG_STYLE_PAINT ) + GdkWindow *window; + if ( m_wxwindow ) { - GdkWindow *window; - if ( m_wxwindow ) - { - window = GTKGetDrawingWindow(); - } - else - { - GtkWidget * const w = GetConnectWidget(); - window = w ? gtk_widget_get_window(w) : NULL; - } + 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, None, False ); -#ifdef __X__ - Display* display = GDK_WINDOW_DISPLAY(window); - XFlush(display); -#endif + gdk_window_set_back_pixmap( window, NULL, FALSE ); m_needsStyleChange = false; } else // window not realized yet { - // Do in OnIdle, because the window is not yet available + // Do when window is realized m_needsStyleChange = true; } @@ -4046,6 +4098,49 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) return true; } +bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const +{ +#if wxGTK_HAS_COMPOSITING_SUPPORT + if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL) + { + if (reason) + { + *reason = _("GTK+ installed on this machine is too old to " + "support screen compositing, please install " + "GTK+ 2.12 or later."); + } + + return false; + } + + // 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 + + wxCHECK_MSG ( m_widget, false, "Window must be created first" ); + + if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget))) + { + if (reason) + { + *reason = _("Compositing not supported by this system, " + "please enable it in your Window Manager."); + } + + return false; + } + + return true; +#else + if (reason) + { + *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; +} + // ---------------------------------------------------------------------------- // Pop-up menu stuff // ---------------------------------------------------------------------------- @@ -4078,6 +4173,14 @@ 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; @@ -4430,12 +4533,6 @@ void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle) } } -void wxWindowGTK::SetWindowStyleFlag( long style ) -{ - // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already - wxWindowBase::SetWindowStyleFlag(style); -} - // Find the wxWindow at the current mouse position, also returning the mouse // position. wxWindow* wxFindWindowAtPointer(wxPoint& pt) @@ -4448,31 +4545,18 @@ wxWindow* wxFindWindowAtPointer(wxPoint& pt) // Get the current mouse position. wxPoint wxGetMousePosition() { - /* This crashes when used within wxHelpContext, - so we have to use the X-specific implementation below. - gint x, y; - GdkModifierType *mask; - (void) gdk_window_get_pointer(NULL, &x, &y, mask); - - return wxPoint(x, y); - */ + 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; - GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y); - - Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY(); - Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display)); - Window rootReturn, childReturn; - int rootX, rootY, winX, winY; - unsigned int maskReturn; - - XQueryPointer (display, - rootWindow, - &rootReturn, - &childReturn, - &rootX, &rootY, &winX, &winY, &maskReturn); - return wxPoint(rootX, rootY); - + gdk_display_get_pointer(display, NULL, &x, &y, NULL); + return wxPoint(x, y); } GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const