X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/079b6a775a0498cf3e100180f28878bb4700d80d..eccace042d8adfe2d45dae21ad924bfc4e0d9ed9:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 1f83b25b85..ac10b6fc7d 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -41,13 +41,21 @@ #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 +// 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 //----------------------------------------------------------------------------- @@ -338,18 +346,6 @@ parent_set(GtkWidget* widget, GtkWidget* 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") @@ -736,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 @@ -754,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 @@ -842,15 +842,62 @@ bool SendCharHookEvent(const wxKeyEvent& event, wxWindow *win) if ( !g_captureWindow ) { wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event); - if ( win->HandleWindowEvent(eventCharHook) ) + if ( win->HandleWindowEvent(eventCharHook) + && !event.IsNextEventAllowed() ) return true; } 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 +// 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 this code avoids handling them in any parent wxWindow, +// while still allowing the event to propagate so things like native keyboard +// navigation will work. +#define wxPROCESS_EVENT_ONCE(EventType, event) \ + static EventType eventPrev; \ + if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \ + return false; \ + eventPrev = *event + extern "C" { static gboolean gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), @@ -862,6 +909,8 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), if (g_blockEventsOnDrag) return FALSE; + wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event); + wxKeyEvent event( wxEVT_KEY_DOWN ); bool ret = false; bool return_after_IM = false; @@ -964,19 +1013,7 @@ gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), 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 ( eventChar.ControlDown() && - ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) )) - { - if ( wxIsLowerChar(key_code) ) - eventChar.m_keyCode = key_code - 'a' + 1; - if ( wxIsUpperChar(key_code) ) - eventChar.m_keyCode = key_code - 'A' + 1; -#if wxUSE_UNICODE - eventChar.m_uniChar = eventChar.m_keyCode; -#endif - } + AdjustCharEventKeyCodes(eventChar); ret = win->HandleWindowEvent(eventChar); } @@ -1021,21 +1058,7 @@ 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); window->HandleWindowEvent(event); } @@ -1059,6 +1082,8 @@ gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), if (g_blockEventsOnDrag) return FALSE; + wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event); + wxKeyEvent event( wxEVT_KEY_UP ); if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) { @@ -1124,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) { @@ -1174,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) && @@ -1253,6 +1279,8 @@ gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) { + wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event); + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); g_lastButtonNumber = gdk_event->button; @@ -1450,6 +1478,8 @@ gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget), GdkEventButton *gdk_event, wxWindowGTK *win ) { + wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event); + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); g_lastButtonNumber = 0; @@ -1513,6 +1543,8 @@ gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget), GdkEventMotion *gdk_event, wxWindowGTK *win ) { + wxPROCESS_EVENT_ONCE(GdkEventMotion, gdk_event); + wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); if (gdk_event->is_hint) @@ -1609,22 +1641,43 @@ window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* static gboolean window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) { - if (gdk_event->direction != GDK_SCROLL_UP && - gdk_event->direction != GDK_SCROLL_DOWN) - { - return false; - } - wxMouseEvent event(wxEVT_MOUSEWHEEL); InitMouseEvent(win, event, gdk_event); // FIXME: Get these values from GTK or GDK event.m_linesPerAction = 3; event.m_wheelDelta = 120; - if (gdk_event->direction == GDK_SCROLL_UP) - event.m_wheelRotation = 120; - else - event.m_wheelRotation = -120; + + // Determine the scroll direction. + switch (gdk_event->direction) + { + case GDK_SCROLL_UP: + case GDK_SCROLL_RIGHT: + event.m_wheelRotation = 120; + break; + + case GDK_SCROLL_DOWN: + case GDK_SCROLL_LEFT: + event.m_wheelRotation = -120; + break; + + default: + return false; // Unknown/unhandled direction + } + + // And the scroll axis. + switch (gdk_event->direction) + { + case GDK_SCROLL_UP: + case GDK_SCROLL_DOWN: + event.m_wheelAxis = wxMOUSE_WHEEL_VERTICAL; + break; + + case GDK_SCROLL_LEFT: + case GDK_SCROLL_RIGHT: + event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL; + break; + } if (win->GTKProcessEvent(event)) return TRUE; @@ -1937,10 +1990,18 @@ 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; + } } } @@ -1958,6 +2019,25 @@ void wxWindowGTK::GTKHandleRealized() ); } + // 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 @@ -2288,8 +2368,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; } @@ -2298,6 +2381,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) @@ -2454,7 +2552,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); } @@ -2615,21 +2713,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; } @@ -2724,39 +2812,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; } @@ -3515,11 +3581,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 @@ -3635,7 +3703,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; @@ -3667,6 +3737,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 ); @@ -3743,6 +3834,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(); @@ -3946,35 +4070,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; } @@ -3990,6 +4113,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 // ---------------------------------------------------------------------------- @@ -4382,12 +4548,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) @@ -4400,31 +4560,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