simplify wxPizza a bit by always drawing the border on parent

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@56797 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/gtk/win_gtk.cpp

@@ -22,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 borders, space is reserved in realize and size_allocate.  The border is
-For non-scrolling wxWindows, a second GdkWindow is used for the
+drawn on wxPizza's parent GdkWindow.
-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 RTL, child widget positions are mirrored in size_allocate.
 */
@@ -71,31 +68,11 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc)
             if (is_resize)
                 gdk_window_resize(widget->window, w, h);
         }
-        else if (pizza->m_backing_window)
-        {
-            // two windows, widget->window is smaller by border widths (need to
-            // move widget->window as well as resize because border can change)
-            gdk_window_move_resize(pizza->m_backing_window,
-                alloc->x, alloc->y, alloc->width, alloc->height);
-            gdk_window_move_resize(widget->window, border_x, border_y, w, h);
-        }
         else
         {
             // one window
             gdk_window_move_resize(widget->window,
-                alloc->x, alloc->y, alloc->width, alloc->height);
+                alloc->x + border_x, alloc->y + border_y, w, h);
-        }
-        if (is_resize && pizza->m_backing_window)
-        {
-            // wxWidgets turns off redraw-on-allocate by default,
-            // so border area needs to be invalidated
-            if (border_x > 1 || border_y > 1)
-            {
-                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);
-            }
         }
     }
     // adjust child positions
@@ -128,49 +105,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;
+            // second window is created if wxWindow is scrollable
-            attr.y += border_y;
+            GdkWindowAttr attr;
+            attr.event_mask = 0;
+            attr.x = x;
+            attr.y = y;
             attr.width  = w;
             attr.height = h;
-        }
+            attr.wclass = GDK_INPUT_OUTPUT;
-        attr.wclass = GDK_INPUT_OUTPUT;
+            attr.visual = gtk_widget_get_visual(widget);
-        attr.visual = gtk_widget_get_visual(widget);
+            attr.colormap = gtk_widget_get_colormap(widget);
-        attr.colormap = gtk_widget_get_colormap(widget);
+            attr.window_type = GDK_WINDOW_CHILD;
-        attr.window_type = GDK_WINDOW_CHILD;
 
-        pizza->m_backing_window = gdk_window_new(
+            pizza->m_backing_window = gdk_window_new(
-            gdk_window_get_parent(widget->window),
+                gdk_window_get_parent(widget->window),
-            &attr,
+                &attr,
-            GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
+                GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
 
-        gdk_window_set_user_data(pizza->m_backing_window, widget);
+            gdk_window_set_user_data(pizza->m_backing_window, widget);
-        if (pizza->m_is_scrollable)
             gdk_window_reparent(widget->window, pizza->m_backing_window, 0, 0);
-        else
+            gdk_window_resize(widget->window, w, h);
-            gdk_window_reparent(widget->window, pizza->m_backing_window, border_x, border_y);
-        gdk_window_resize(widget->window, w, h);
 
-        // Parts of m_backing_window which are supposed to be obscured may be
+            // Parts of m_backing_window may be exposed temporarily while
-        // exposed temporarily while resizing. Setting the backing pixmap to
+            // resizing. Setting the backing pixmap to None prevents those
-        // None prevents those areas from being briefly painted black.
+            // areas from being briefly painted black.
-        gdk_window_set_back_pixmap(pizza->m_backing_window, NULL, false);
+            gdk_window_set_back_pixmap(pizza->m_backing_window, NULL, false);
+        }
+        else
+            gdk_window_move_resize(widget->window, x, y, w, h);
     }
 }
 
@@ -386,6 +360,7 @@ void wxPizza::scroll(int dx, int dy)
 void wxPizza::get_border_widths(int& x, int& y)
 {
     x = y = 0;
+#ifndef __WXUNIVERSAL__
     if (m_border_style & wxBORDER_SIMPLE)
         x = y = 1;
     else if (m_border_style)
@@ -397,4 +372,5 @@ void wxPizza::get_border_widths(int& x, int& y)
             y = entry_widget->style->ythickness;
         }
     }
+#endif
 }

src/gtk/window.cpp

@@ -295,30 +295,27 @@ gtk_window_expose_callback( GtkWidget* widget,
 }
 }
 
-//-----------------------------------------------------------------------------
-// "expose_event" from m_widget, for drawing border
-//-----------------------------------------------------------------------------
-
 #ifndef __WXUNIVERSAL__
+//-----------------------------------------------------------------------------
+// "expose_event" from m_wxwindow->parent, for drawing border
+//-----------------------------------------------------------------------------
 
 extern "C" {
 static gboolean
 expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
 {
-    // if this event is not for the GdkWindow the border is drawn on
+    if (gdk_event->window != widget->window)
-    if (win->m_wxwindow == win->m_widget && gdk_event->window == widget->window)
+        return false;
+
+    const GtkAllocation& alloc = win->m_wxwindow->allocation;
+    const int x = alloc.x;
+    const int y = alloc.y;
+    const int w = alloc.width;
+    const int h = alloc.height;
+
+    if (w <= 0 || h <= 0)
         return false;
 
-    int x = 0;
-    int y = 0;
-    // GtkScrolledWindow is GTK_NO_WINDOW
-    if (GTK_WIDGET_NO_WINDOW(widget))
-    {
-        x = widget->allocation.x;
-        y = widget->allocation.y;
-    }
-    int w = win->m_wxwindow->allocation.width;
-    int h = win->m_wxwindow->allocation.height;
     if (win->HasFlag(wxBORDER_SIMPLE))
     {
         gdk_draw_rectangle(gdk_event->window,
@@ -332,7 +329,7 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
 
         // Style detail to use
         const char* detail;
-        if (widget == win->m_wxwindow)
+        if (win->m_widget == win->m_wxwindow)
             // for non-scrollable wxWindows
             detail = "entry";
         else
@@ -343,9 +340,28 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
            win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
            shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
     }
+    return false;
+}
+}
 
-    // no further painting is needed for border-only GdkWindow
+//-----------------------------------------------------------------------------
-    return win->m_wxwindow == win->m_widget;
+// "parent_set" from m_wxwindow
+//-----------------------------------------------------------------------------
+
+extern "C" {
+static void
+parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
+{
+    if (old_parent)
+    {
+        g_signal_handlers_disconnect_by_func(
+            old_parent, (void*)expose_event_border, win);
+    }
+    if (widget->parent)
+    {
+        g_signal_connect_after(widget->parent, "expose_event",
+            G_CALLBACK(expose_event_border), win);
+    }
 }
 }
 #endif // !__WXUNIVERSAL__
@@ -2040,6 +2056,13 @@ bool wxWindowGTK::Create( wxWindow *parent,
 
 
     m_wxwindow = wxPizza::New(m_windowStyle);
+#ifndef __WXUNIVERSAL__
+    if (HasFlag(wxPizza::BORDER_STYLES))
+    {
+        g_signal_connect(m_wxwindow, "parent_set",
+            G_CALLBACK(parent_set), this);
+    }
+#endif
     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
         m_widget = m_wxwindow;
     else
@@ -2215,15 +2238,6 @@ void wxWindowGTK::PostCreation()
 
         g_signal_connect (m_imData->context, "commit",
                           G_CALLBACK (gtk_wxwindow_commit_cb), this);
-
-        // border drawing
-#ifndef __WXUNIVERSAL__
-        if (HasFlag(wxPizza::BORDER_STYLES))
-        {
-            g_signal_connect(m_widget, "expose_event",
-                G_CALLBACK(expose_event_border), this);
-        }
-#endif
     }
 
     // focus handling