X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e56307d3196b614ae7a09e53dda87b339cbbc913..55410bb4f67febe1ca20654f078ea4fb9a6223ae:/src/gtk/win_gtk.cpp diff --git a/src/gtk/win_gtk.cpp b/src/gtk/win_gtk.cpp index 0e21432e6a..13f596d26c 100644 --- a/src/gtk/win_gtk.cpp +++ b/src/gtk/win_gtk.cpp @@ -8,7 +8,8 @@ /////////////////////////////////////////////////////////////////////////////// #include "wx/defs.h" -#include "wx/gtk/win_gtk.h" +#include "wx/gtk/private.h" +#include "wx/gtk/private/win_gtk.h" /* wxPizza is a custom GTK+ widget derived from GtkFixed. A custom widget @@ -21,11 +22,8 @@ GtkScrolledWindow. Child widget positions are adjusted for the scrolling position in size_allocate. A second same-size GdkWindow is placed behind widget->window, to allow GDK to use a more efficient scrolling technique. -For borders, space is reserved in realize and size_allocate. -For non-scrolling wxWindows, a second GdkWindow is used for the -border; scrolling wxWindows draw their border on wxPizza's parent -(a GtkScrolledWindow) GdkWindow. Border widths for sunken and raised -styles are taken from widget->style, so they will match the current theme. +For borders, space is reserved in realize and size_allocate. The border is +drawn on wxPizza's parent GdkWindow. For RTL, child widget positions are mirrored in size_allocate. */ @@ -49,8 +47,6 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc) widget->allocation.x != alloc->x || widget->allocation.y != alloc->y; - widget->allocation = *alloc; - wxPizza* pizza = WX_PIZZA(widget); int border_x, border_y; pizza->get_border_widths(border_x, border_y); @@ -64,46 +60,42 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc) if (pizza->m_is_scrollable) { - // backing window is inside border + // two windows, both same size gdk_window_move_resize(pizza->m_backing_window, alloc->x + border_x, alloc->y + border_y, w, h); + if (is_resize) + gdk_window_resize(widget->window, w, h); } else { - // border window (or only window if - // no-scroll no-border) is full size - GdkWindow* window = pizza->m_backing_window; - if (window == NULL) - window = widget->window; - gdk_window_move_resize( - window, alloc->x, alloc->y, alloc->width, alloc->height); - } - if (is_resize && pizza->m_backing_window) - { - // main window is inside border - if (pizza->m_is_scrollable) - gdk_window_resize(widget->window, w, h); - else - // need move as well as resize because border can change - gdk_window_move_resize(widget->window, border_x, border_y, w, h); + // one window + gdk_window_move_resize(widget->window, + alloc->x + border_x, alloc->y + border_y, w, h); - // wxWidgets turns off redraw-on-allocate by default, - // so border area needs to be invalidated - if (border_x > 1 || border_y > 1) + if (is_resize && (border_x || border_y)) { - if (pizza->m_is_scrollable) - ; // invalidate does not seem to be needed in this case - else - gdk_window_invalidate_rect(pizza->m_backing_window, NULL, false); + // old and new border areas need to be invalidated, + // otherwise they will not be erased/redrawn properly + const GtkAllocation& a1 = widget->allocation; + const GtkAllocation& a2 = *alloc; + GdkRectangle r1 = { a1.x, a1.y, a1.width, a1.height }; + GdkRectangle r2 = { a2.x, a2.y, a2.width, a2.height }; + gdk_window_invalidate_rect(widget->parent->window, &r1, false); + gdk_window_invalidate_rect(widget->parent->window, &r2, false); } } } + + widget->allocation = *alloc; + // adjust child positions for (const GList* list = pizza->m_fixed.children; list; list = list->next) { const GtkFixedChild* child = static_cast<GtkFixedChild*>(list->data); if (GTK_WIDGET_VISIBLE(child->widget)) { + GtkAllocation child_old_alloc = child->widget->allocation; + GtkAllocation child_alloc; // note that child positions do not take border into // account, they need to be relative to widget->window, @@ -115,9 +107,7 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc) child_alloc.width = req.width; child_alloc.height = req.height; if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) - { child_alloc.x = w - child_alloc.x - child_alloc.width; - } gtk_widget_size_allocate(child->widget, &child_alloc); } } @@ -128,44 +118,46 @@ static void realize(GtkWidget* widget) parent_class->realize(widget); wxPizza* pizza = WX_PIZZA(widget); - // second window is created if there is a border, or wxWindow is scrollable if (pizza->m_border_style || pizza->m_is_scrollable) { - GdkWindowAttr attr; - attr.event_mask = pizza->m_is_scrollable ? 0 : GDK_EXPOSURE_MASK; - attr.x = widget->allocation.x; - attr.y = widget->allocation.y; - attr.width = widget->allocation.width; - attr.height = widget->allocation.height; int border_x, border_y; pizza->get_border_widths(border_x, border_y); + int x = widget->allocation.x + border_x; + int y = widget->allocation.y + border_y; int w = widget->allocation.width - 2 * border_x; int h = widget->allocation.height - 2 * border_y; if (w < 0) w = 0; if (h < 0) h = 0; if (pizza->m_is_scrollable) { - attr.x += border_x; - attr.y += border_y; + // second window is created if wxWindow is scrollable + GdkWindowAttr attr; + attr.event_mask = 0; + attr.x = x; + attr.y = y; attr.width = w; attr.height = h; - } - attr.wclass = GDK_INPUT_OUTPUT; - attr.visual = gtk_widget_get_visual(widget); - attr.colormap = gtk_widget_get_colormap(widget); - attr.window_type = GDK_WINDOW_CHILD; + attr.wclass = GDK_INPUT_OUTPUT; + attr.visual = gtk_widget_get_visual(widget); + attr.colormap = gtk_widget_get_colormap(widget); + attr.window_type = GDK_WINDOW_CHILD; - pizza->m_backing_window = gdk_window_new( - gdk_window_get_parent(widget->window), - &attr, - GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP); + pizza->m_backing_window = gdk_window_new( + gdk_window_get_parent(widget->window), + &attr, + GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP); - gdk_window_set_user_data(pizza->m_backing_window, widget); - if (pizza->m_is_scrollable) + gdk_window_set_user_data(pizza->m_backing_window, widget); gdk_window_reparent(widget->window, pizza->m_backing_window, 0, 0); + gdk_window_resize(widget->window, w, h); + + // Parts of m_backing_window may be exposed temporarily while + // resizing. Setting the backing pixmap to None prevents those + // areas from being briefly painted black. + gdk_window_set_back_pixmap(pizza->m_backing_window, NULL, false); + } else - gdk_window_reparent(widget->window, pizza->m_backing_window, border_x, border_y); - gdk_window_resize(widget->window, w, h); + gdk_window_move_resize(widget->window, x, y, w, h); } } @@ -290,16 +282,17 @@ GType wxPizza::type() return type; } -GtkWidget* wxPizza::New(long windowStyle) +GtkWidget* wxPizza::New(long windowStyle,void* owner) { GtkWidget* widget = GTK_WIDGET(g_object_new(type(), NULL)); wxPizza* pizza = WX_PIZZA(widget); + pizza->m_owner = owner; pizza->m_backing_window = NULL; pizza->m_scroll_x = 0; pizza->m_scroll_y = 0; pizza->m_is_scrollable = (windowStyle & (wxHSCROLL | wxVSCROLL)) != 0; - pizza->m_border_style = - int(windowStyle & (wxBORDER_SIMPLE | wxBORDER_RAISED | wxBORDER_SUNKEN)); + // mask off border styles not useable with wxPizza + pizza->m_border_style = int(windowStyle & BORDER_STYLES); gtk_fixed_set_has_window(GTK_FIXED(widget), true); gtk_widget_add_events(widget, GDK_EXPOSURE_MASK | @@ -317,7 +310,6 @@ GtkWidget* wxPizza::New(long windowStyle) GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK); - gtk_container_set_resize_mode(GTK_CONTAINER(widget), GTK_RESIZE_QUEUE); return widget; } @@ -338,6 +330,31 @@ void wxPizza::move(GtkWidget* widget, int x, int y) } } +struct AdjustData { + GdkWindow* window; + int dx, dy; +}; + +// Adjust allocations for all widgets using the GdkWindow which was just scrolled +extern "C" { +static void scroll_adjust(GtkWidget* widget, void* data) +{ + const AdjustData* p = static_cast<AdjustData*>(data); + widget->allocation.x += p->dx; + widget->allocation.y += p->dy; + + if (widget->window == p->window) + { + // GtkFrame requires a queue_resize, otherwise parts of + // the frame newly exposed by the scroll are not drawn. + // To be safe, do it for all widgets. + gtk_widget_queue_resize_no_redraw(widget); + if (GTK_IS_CONTAINER(widget)) + gtk_container_forall(GTK_CONTAINER(widget), scroll_adjust, data); + } +} +} + void wxPizza::scroll(int dx, int dy) { GtkWidget* widget = GTK_WIDGET(this); @@ -346,28 +363,43 @@ void wxPizza::scroll(int dx, int dy) m_scroll_x -= dx; m_scroll_y -= dy; if (widget->window) - gdk_window_scroll(widget->window, dx, dy); - const GList* list = m_fixed.children; - if (list) { - const GtkFixedChild* child = static_cast<GtkFixedChild*>(list->data); - // queueing a resize on any child will update them all - gtk_widget_queue_resize(child->widget); + gdk_window_scroll(widget->window, dx, dy); + // Adjust child allocations. Doing a queue_resize on the children is not + // enough, sometimes they redraw in the wrong place during fast scrolling. + AdjustData data = { widget->window, dx, dy }; + gtk_container_forall(GTK_CONTAINER(widget), scroll_adjust, &data); } } void wxPizza::get_border_widths(int& x, int& y) { x = y = 0; + if (m_border_style == 0) + return; + +#ifndef __WXUNIVERSAL__ if (m_border_style & wxBORDER_SIMPLE) x = y = 1; - else if (m_border_style) + else if (m_is_scrollable || (m_border_style & wxBORDER_THEME)) + { + GtkWidget *style_widget = wxGTKPrivate::GetTreeWidget(); + + if (style_widget->style) + { + x = style_widget->style->xthickness; + y = style_widget->style->ythickness; + } + } + else { - GtkWidget* widget = GTK_WIDGET(this); - if (widget->style) + GtkWidget *style_widget = wxGTKPrivate::GetEntryWidget(); + + if (style_widget->style) { - x = widget->style->xthickness; - y = widget->style->ythickness; + x = style_widget->style->xthickness; + y = style_widget->style->ythickness; } } +#endif }