API: Remove gtk_cairo_should_draw_window()

The answer is: Yes.

15 files changed, 99 insertions, 250 deletions

diff --git a/gtk/gtkcalendar.c b/gtk/gtkcalendar.c
index 24f34a34ca..e8cdc6d6f4 100644
--- a/gtk/gtkcalendar.c
+++ b/gtk/gtkcalendar.c
@@ -2742,26 +2742,22 @@ gtk_calendar_draw (GtkWidget *widget,
 {
   GtkCalendar *calendar = GTK_CALENDAR (widget);
   GtkCalendarPrivate *priv = calendar->priv;
+  GtkStyleContext *context;
   int i;
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
-    {
-      GtkStyleContext *context;
-
-      context = gtk_widget_get_style_context (widget);
+  context = gtk_widget_get_style_context (widget);
 
-      gtk_style_context_save (context);
-      gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
+  gtk_style_context_save (context);
+  gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
 
-      gtk_render_background (context, cr, 0, 0,
-                             gtk_widget_get_allocated_width (widget),
-                             gtk_widget_get_allocated_height (widget));
-      gtk_render_frame (context, cr, 0, 0,
-                        gtk_widget_get_allocated_width (widget),
-                        gtk_widget_get_allocated_height (widget));
+  gtk_render_background (context, cr, 0, 0,
+                         gtk_widget_get_allocated_width (widget),
+                         gtk_widget_get_allocated_height (widget));
+  gtk_render_frame (context, cr, 0, 0,
+                    gtk_widget_get_allocated_width (widget),
+                    gtk_widget_get_allocated_height (widget));
 
-      gtk_style_context_restore (context);
-    }
+  gtk_style_context_restore (context);
 
   calendar_paint_main (calendar, cr);
 
diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index 767cc5ae31..928d95ecf6 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -3147,21 +3147,9 @@ gtk_container_should_propagate_draw (GtkContainer   *container,
                                      GtkWidget      *child,
                                      cairo_t        *cr)
 {
-  GdkWindow *child_in_window;
-
   if (!_gtk_widget_is_drawable (child))
     return FALSE;
 
-  /* Never propagate to a child window when exposing a window
-   * that is not the one the child widget is in.
-   */
-  if (_gtk_widget_get_has_window (child))
-    child_in_window = gdk_window_get_parent (_gtk_widget_get_window (child));
-  else
-    child_in_window = _gtk_widget_get_window (child);
-  if (!gtk_cairo_should_draw_window (cr, child_in_window))
-    return FALSE;
-
   return TRUE;
 }
 
diff --git a/gtk/gtkiconview.c b/gtk/gtkiconview.c
index 82ca12716c..84b77e032a 100644
--- a/gtk/gtkiconview.c
+++ b/gtk/gtkiconview.c
@@ -1757,9 +1757,6 @@ gtk_icon_view_draw (GtkWidget *widget,
                          gtk_widget_get_allocated_width (widget),
                          gtk_widget_get_allocated_height (widget));
 
-  if (!gtk_cairo_should_draw_window (cr, icon_view->priv->bin_window))
-    return FALSE;
-
   cairo_save (cr);
 
   gtk_cairo_transform_to_window (cr, widget, icon_view->priv->bin_window);
diff --git a/gtk/gtklayout.c b/gtk/gtklayout.c
index 28b72d00ad..f505278ecf 100644
--- a/gtk/gtklayout.c
+++ b/gtk/gtklayout.c
@@ -132,8 +132,6 @@ static void gtk_layout_measure (GtkWidget *widget,
                                 int            *natural_baseline);
 static void gtk_layout_size_allocate      (GtkWidget      *widget,
                                            GtkAllocation  *allocation);
-static gint gtk_layout_draw               (GtkWidget      *widget,
-                                           cairo_t        *cr);
 static void gtk_layout_add                (GtkContainer   *container,
 					   GtkWidget      *widget);
 static void gtk_layout_remove             (GtkContainer   *container,
@@ -603,7 +601,6 @@ gtk_layout_class_init (GtkLayoutClass *class)
   widget_class->map = gtk_layout_map;
   widget_class->measure = gtk_layout_measure;
   widget_class->size_allocate = gtk_layout_size_allocate;
-  widget_class->draw = gtk_layout_draw;
 
   container_class->add = gtk_layout_add;
   container_class->remove = gtk_layout_remove;
@@ -899,19 +896,6 @@ gtk_layout_size_allocate (GtkWidget     *widget,
   gtk_layout_set_vadjustment_values (layout);
 }
 
-static gboolean
-gtk_layout_draw (GtkWidget *widget,
-                 cairo_t   *cr)
-{
-  GtkLayout *layout = GTK_LAYOUT (widget);
-  GtkLayoutPrivate *priv = layout->priv;
-
-  if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-    GTK_WIDGET_CLASS (gtk_layout_parent_class)->draw (widget, cr);
-
-  return FALSE;
-}
-
 /* Container methods
  */
 static void
diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index 3a569f2cdf..7839098371 100644
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -2927,6 +2927,7 @@ gtk_menu_draw (GtkWidget *widget,
   GtkMenuPrivate *priv;
   GtkStyleContext *context;
   GtkAllocation allocation;
+  int x, y;
 
   menu = GTK_MENU (widget);
   priv = menu->priv;
@@ -2934,34 +2935,26 @@ gtk_menu_draw (GtkWidget *widget,
 
   gtk_widget_get_allocation (widget, &allocation);
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
-    {
-      gtk_render_background (context, cr, 0, 0,
-                             allocation.width, allocation.height);
-      gtk_render_frame (context, cr, 0, 0,
-                        allocation.width, allocation.height);
-
-      if (priv->upper_arrow_visible)
-        gtk_css_gadget_draw (priv->top_arrow_gadget, cr);
+  gtk_render_background (context, cr, 0, 0,
+                         allocation.width, allocation.height);
+  gtk_render_frame (context, cr, 0, 0,
+                    allocation.width, allocation.height);
 
-      if (priv->lower_arrow_visible)
-        gtk_css_gadget_draw (priv->bottom_arrow_gadget, cr);
-    }
+  if (priv->upper_arrow_visible)
+    gtk_css_gadget_draw (priv->top_arrow_gadget, cr);
 
-  if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-    {
-      int x, y;
+  if (priv->lower_arrow_visible)
+    gtk_css_gadget_draw (priv->bottom_arrow_gadget, cr);
 
-      gdk_window_get_position (priv->view_window, &x, &y);
+  gdk_window_get_position (priv->view_window, &x, &y);
 
-      cairo_rectangle (cr,
-                       x - allocation.x, y - allocation.y,
-                       gdk_window_get_width (priv->view_window),
-                       gdk_window_get_height (priv->view_window));
-      cairo_clip (cr);
+  cairo_rectangle (cr,
+                   x - allocation.x, y - allocation.y,
+                   gdk_window_get_width (priv->view_window),
+                   gdk_window_get_height (priv->view_window));
+  cairo_clip (cr);
 
-      GTK_WIDGET_CLASS (gtk_menu_parent_class)->draw (widget, cr);
-    }
+  GTK_WIDGET_CLASS (gtk_menu_parent_class)->draw (widget, cr);
 
   return FALSE;
 }
diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c
index 5f0144fdbc..02939bb802 100644
--- a/gtk/gtknotebook.c
+++ b/gtk/gtknotebook.c
@@ -2381,11 +2381,9 @@ gtk_notebook_draw (GtkWidget *widget,
   GtkNotebook *notebook = GTK_NOTEBOOK (widget);
   GtkNotebookPrivate *priv = notebook->priv;
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
-    gtk_css_gadget_draw (priv->gadget, cr);
+  gtk_css_gadget_draw (priv->gadget, cr);
 
-  if (priv->operation == DRAG_OPERATION_REORDER &&
-      gtk_cairo_should_draw_window (cr, priv->drag_window))
+  if (priv->operation == DRAG_OPERATION_REORDER)
     gtk_css_gadget_draw (priv->cur_page->gadget, cr);
 
   return FALSE;
diff --git a/gtk/gtkpaned.c b/gtk/gtkpaned.c
index a8c5db8c20..1fadaf578f 100644
--- a/gtk/gtkpaned.c
+++ b/gtk/gtkpaned.c
@@ -1665,8 +1665,7 @@ gtk_paned_render (GtkCssGadget *gadget,
   int window_x, window_y;
 
   gtk_widget_get_allocation (widget, &widget_allocation);
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)) &&
-      priv->child1 && gtk_widget_get_visible (priv->child1) &&
+  if (priv->child1 && gtk_widget_get_visible (priv->child1) &&
       priv->child2 && gtk_widget_get_visible (priv->child2))
     gtk_css_gadget_draw (priv->handle_gadget, cr);
 
diff --git a/gtk/gtkrevealer.c b/gtk/gtkrevealer.c
index ae4f14164b..c9e7693824 100644
--- a/gtk/gtkrevealer.c
+++ b/gtk/gtkrevealer.c
@@ -100,8 +100,6 @@ static void     gtk_revealer_real_size_allocate                  (GtkWidget
                                                                   GtkAllocation *allocation);
 static void     gtk_revealer_real_map                            (GtkWidget     *widget);
 static void     gtk_revealer_real_unmap                          (GtkWidget     *widget);
-static gboolean gtk_revealer_real_draw                           (GtkWidget     *widget,
-                                                                  cairo_t       *cr);
 static void gtk_revealer_measure (GtkWidget      *widget,
                                   GtkOrientation  orientation,
                                   int             for_size,
@@ -220,7 +218,6 @@ gtk_revealer_class_init (GtkRevealerClass *klass)
   widget_class->size_allocate = gtk_revealer_real_size_allocate;
   widget_class->map = gtk_revealer_real_map;
   widget_class->unmap = gtk_revealer_real_unmap;
-  widget_class->draw = gtk_revealer_real_draw;
   widget_class->measure = gtk_revealer_measure;
 
   container_class->add = gtk_revealer_real_add;
@@ -652,19 +649,6 @@ gtk_revealer_real_unmap (GtkWidget *widget)
   gtk_revealer_stop_animation (revealer);
 }
 
-static gboolean
-gtk_revealer_real_draw (GtkWidget *widget,
-                        cairo_t   *cr)
-{
-  GtkRevealer *revealer = GTK_REVEALER (widget);
-  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
-
-  if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-    GTK_WIDGET_CLASS (gtk_revealer_parent_class)->draw (widget, cr);
-
-  return GDK_EVENT_PROPAGATE;
-}
-
 /**
  * gtk_revealer_set_reveal_child:
  * @revealer: a #GtkRevealer
diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c
index bc5f459cc9..9744a98880 100644
--- a/gtk/gtkscrolledwindow.c
+++ b/gtk/gtkscrolledwindow.c
@@ -1973,20 +1973,14 @@ gtk_scrolled_window_render (GtkCssGadget *gadget,
   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
-    {
-      if (priv->hscrollbar_visible &&
-          priv->vscrollbar_visible)
-        gtk_scrolled_window_draw_scrollbars_junction (scrolled_window, cr);
-    }
+  if (priv->hscrollbar_visible &&
+      priv->vscrollbar_visible)
+    gtk_scrolled_window_draw_scrollbars_junction (scrolled_window, cr);
 
   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->draw (widget, cr);
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
-    {
-      gtk_scrolled_window_draw_undershoot (scrolled_window, cr);
-      gtk_scrolled_window_draw_overshoot (scrolled_window, cr);
-    }
+  gtk_scrolled_window_draw_undershoot (scrolled_window, cr);
+  gtk_scrolled_window_draw_overshoot (scrolled_window, cr);
 
   return FALSE;
 }
diff --git a/gtk/gtkstack.c b/gtk/gtkstack.c
index e79056d2bd..610b2f6239 100644
--- a/gtk/gtkstack.c
+++ b/gtk/gtkstack.c
@@ -2024,8 +2024,7 @@ gtk_stack_draw_slide (GtkWidget *widget,
   GtkStack *stack = GTK_STACK (widget);
   GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
 
-  if (priv->last_visible_surface &&
-      gtk_cairo_should_draw_window (cr, priv->view_window))
+  if (priv->last_visible_surface)
     {
       GtkAllocation allocation;
       int x, y;
@@ -2078,10 +2077,9 @@ gtk_stack_draw_slide (GtkWidget *widget,
       cairo_restore (cr);
      }
 
-  if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-    gtk_container_propagate_draw (GTK_CONTAINER (stack),
-                                  priv->visible_child->widget,
-                                  cr);
+  gtk_container_propagate_draw (GTK_CONTAINER (stack),
+                                priv->visible_child->widget,
+                                cr);
 }
 
 static gboolean
@@ -2108,19 +2106,15 @@ gtk_stack_render (GtkCssGadget *gadget,
   GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
   GtkStack *stack = GTK_STACK (widget);
   GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
+  GtkStyleContext *context;
   cairo_t *pattern_cr;
 
-  if (gtk_cairo_should_draw_window (cr, priv->view_window))
-    {
-      GtkStyleContext *context;
-
-      context = gtk_widget_get_style_context (widget);
-      gtk_render_background (context,
-                             cr,
-                             0, 0,
-                             gtk_widget_get_allocated_width (widget),
-                             gtk_widget_get_allocated_height (widget));
-    }
+  context = gtk_widget_get_style_context (widget);
+  gtk_render_background (context,
+                         cr,
+                         0, 0,
+                         gtk_widget_get_allocated_width (widget),
+                         gtk_widget_get_allocated_height (widget));
 
   if (priv->visible_child)
     {
@@ -2153,8 +2147,7 @@ gtk_stack_render (GtkCssGadget *gadget,
           switch (priv->active_transition_type)
             {
             case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
-	      if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-		gtk_stack_draw_crossfade (widget, cr);
+	      gtk_stack_draw_crossfade (widget, cr);
               break;
             case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
             case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
@@ -2170,15 +2163,14 @@ gtk_stack_render (GtkCssGadget *gadget,
             case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
             case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
             case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
-	      if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-		gtk_stack_draw_under (widget, cr);
+	      gtk_stack_draw_under (widget, cr);
               break;
             default:
               g_assert_not_reached ();
             }
 
         }
-      else if (gtk_cairo_should_draw_window (cr, priv->bin_window))
+      else
         gtk_container_propagate_draw (GTK_CONTAINER (stack),
                                       priv->visible_child->widget,
                                       cr);
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index f21ed3138c..7f4f79a19c 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -5881,27 +5881,24 @@ paint_border_window (GtkTextView     *text_view,
                      GtkStyleContext *context)
 {
   GdkWindow *window;
+  gint w, h;
+
 
   if (text_window == NULL)
     return;
 
   window = gtk_text_view_get_window (text_view, text_window->type);
-  if (gtk_cairo_should_draw_window (cr, window))
-    {
-      gint w, h;
+  w = gdk_window_get_width (window);
+  h = gdk_window_get_height (window);
 
-      gtk_style_context_save_to_node (context, text_window->css_node);
+  gtk_style_context_save_to_node (context, text_window->css_node);
 
-      w = gdk_window_get_width (window);
-      h = gdk_window_get_height (window);
-
-      cairo_save (cr);
-      gtk_cairo_transform_to_window (cr, GTK_WIDGET (text_view), window);
-      gtk_render_background (context, cr, 0, 0, w, h);
-      cairo_restore (cr);
+  cairo_save (cr);
+  gtk_cairo_transform_to_window (cr, GTK_WIDGET (text_view), window);
+  gtk_render_background (context, cr, 0, 0, w, h);
+  cairo_restore (cr);
 
-      gtk_style_context_restore (context);
-    }
+  gtk_style_context_restore (context);
 }
 
 static gboolean
@@ -5924,15 +5921,13 @@ gtk_text_view_draw (GtkWidget *widget,
 
   window = gtk_text_view_get_window (GTK_TEXT_VIEW (widget),
                                      GTK_TEXT_WINDOW_TEXT);
-  if (gtk_cairo_should_draw_window (cr, window))
-    {
-      DV(g_print (">Exposed ("G_STRLOC")\n"));
 
-      cairo_save (cr);
-      gtk_cairo_transform_to_window (cr, widget, window);
-      draw_text (widget, cr); 
-      cairo_restore (cr);
-    }
+  DV(g_print (">Exposed ("G_STRLOC")\n"));
+
+  cairo_save (cr);
+  gtk_cairo_transform_to_window (cr, widget, window);
+  draw_text (widget, cr); 
+  cairo_restore (cr);
 
   paint_border_window (GTK_TEXT_VIEW (widget), cr, priv->left_window, context);
   paint_border_window (GTK_TEXT_VIEW (widget), cr, priv->right_window, context);
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index 0e4ab4e9c6..d1c4847b13 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -5362,37 +5362,36 @@ gtk_tree_view_draw (GtkWidget *widget,
                     cairo_t   *cr)
 {
   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
-  GtkWidget   *button;
+  GtkWidget *button;
   GtkStyleContext *context;
+  GList *list;
 
   context = gtk_widget_get_style_context (widget);
 
-  if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
-    {
-      GList *tmp_list;
+  gtk_render_background (context, cr,
+                         0, 0,
+                         gtk_widget_get_allocated_width (widget),
+                         gtk_widget_get_allocated_height (widget));
 
-      cairo_save (cr);
+  cairo_save (cr);
 
-      gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
-      gtk_tree_view_bin_draw (widget, cr);
+  gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
+  gtk_tree_view_bin_draw (widget, cr);
 
-      cairo_restore (cr);
+  cairo_restore (cr);
 
-      /* We can't just chain up to Container::draw as it will try to send the
-       * event to the headers, so we handle propagating it to our children
-       * (eg. widgets being edited) ourselves.
-       */
-      tmp_list = tree_view->priv->children;
-      while (tmp_list)
-        {
-          GtkTreeViewChild *child = tmp_list->data;
-          tmp_list = tmp_list->next;
+  /* We can't just chain up to Container::draw as it will try to send the
+   * event to the headers, so we handle propagating it to our children
+   * (eg. widgets being edited) ourselves.
+   */
+  for (list = tree_view->priv->children; list; list = list->next)
+    {
+      GtkTreeViewChild *child = list->data;
 
-          gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
-        }
+      gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
     }
-  else if (tree_view->priv->drag_highlight_window &&
-           gtk_cairo_should_draw_window (cr, tree_view->priv->drag_highlight_window))
+  
+  if (tree_view->priv->drag_highlight_window)
     {
       GdkRGBA color;
 
@@ -5417,39 +5416,26 @@ gtk_tree_view_draw (GtkWidget *widget,
         }
       cairo_restore (cr);
     }
-  else
-    {
-      gtk_render_background (context, cr,
-                             0, 0,
-                             gtk_widget_get_allocated_width (widget),
-                             gtk_widget_get_allocated_height (widget));
-    }
 
   gtk_style_context_save (context);
   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
 
-  if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
+  for (list = tree_view->priv->columns; list != NULL; list = list->next)
     {
-      GList *list;
-      
-      for (list = tree_view->priv->columns; list != NULL; list = list->next)
-	{
-	  GtkTreeViewColumn *column = list->data;
+      GtkTreeViewColumn *column = list->data;
 
-	  if (column == tree_view->priv->drag_column)
-	    continue;
+      if (column == tree_view->priv->drag_column)
+        continue;
 
-	  if (gtk_tree_view_column_get_visible (column))
-	    {
-	      button = gtk_tree_view_column_get_button (column);
-	      gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
-					    button, cr);
-	    }
-	}
+      if (gtk_tree_view_column_get_visible (column))
+        {
+          button = gtk_tree_view_column_get_button (column);
+          gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
+                                        button, cr);
+        }
     }
-  
-  if (tree_view->priv->drag_window &&
-      gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
+
+  if (tree_view->priv->drag_window)
     {
       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
diff --git a/gtk/gtkviewport.c b/gtk/gtkviewport.c
index 8360dbab4d..40363a8d3f 100644
--- a/gtk/gtkviewport.c
+++ b/gtk/gtkviewport.c
@@ -305,13 +305,8 @@ gtk_viewport_render (GtkCssGadget *gadget,
                      gpointer      data)
 {
   GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
-  GtkViewport *viewport = GTK_VIEWPORT (widget);
-  GtkViewportPrivate *priv = viewport->priv;
 
-  if (gtk_cairo_should_draw_window (cr, priv->bin_window))
-    {
-      GTK_WIDGET_CLASS (gtk_viewport_parent_class)->draw (widget, cr);
-    }
+  GTK_WIDGET_CLASS (gtk_viewport_parent_class)->draw (widget, cr);
 
   return FALSE;
 }
@@ -732,9 +727,7 @@ gtk_viewport_draw (GtkWidget *widget,
   GtkViewport *viewport = GTK_VIEWPORT (widget);
   GtkViewportPrivate *priv = viewport->priv;
 
-  if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)) ||
-      gtk_cairo_should_draw_window (cr, priv->bin_window))
-    gtk_css_gadget_draw (priv->gadget, cr);
+  gtk_css_gadget_draw (priv->gadget, cr);
 
   return FALSE;
 }
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index b5c28d4594..9f212fe430 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -6282,53 +6282,6 @@ gtk_widget_get_renderer (GtkWidget *widget)
   return NULL;
 }
 
-/**
- * gtk_cairo_should_draw_window:
- * @cr: a cairo context
- * @window: the window to check. @window may not be an input-only
- *          window.
- *
- * This function is supposed to be called in #GtkWidget::draw
- * implementations for widgets that support multiple windows.
- * @cr must be untransformed from invoking of the draw function.
- * This function will return %TRUE if the contents of the given
- * @window are supposed to be drawn and %FALSE otherwise. Note
- * that when the drawing was not initiated by the windowing
- * system this function will return %TRUE for all windows, so
- * you need to draw the bottommost window first. Also, do not
- * use “else if” statements to check which window should be drawn.
- *
- * Returns: %TRUE if @window should be drawn
- *
- * Since: 3.0
- */
-gboolean
-gtk_cairo_should_draw_window (cairo_t   *cr,
-                              GdkWindow *window)
-{
-  GdkDrawingContext *context;
-  GdkWindow *tmp;
-
-  g_return_val_if_fail (cr != NULL, FALSE);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
-  if (gtk_cairo_is_marked_for_draw (cr))
-    return TRUE;
-
-  context = gdk_cairo_get_drawing_context (cr);
-  if (context == NULL)
-    return TRUE;
-
-  tmp = gdk_drawing_context_get_window (context);
-  if (tmp == NULL)
-    return TRUE;
-
-  while (!gdk_window_has_native (window))
-    window = gdk_window_get_parent (window);
-
-  return tmp == window;
-}
-
 typedef enum {
   RENDER_SNAPSHOT,
   RENDER_DRAW
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index 25d6de49c1..cea1298db2 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -1110,9 +1110,6 @@ GDK_AVAILABLE_IN_ALL
 gboolean   gtk_widget_get_has_tooltip       (GtkWidget   *widget);
 
 GDK_AVAILABLE_IN_ALL
-gboolean   gtk_cairo_should_draw_window     (cairo_t     *cr,
-                                             GdkWindow   *window);
-GDK_AVAILABLE_IN_ALL
 void       gtk_cairo_transform_to_window    (cairo_t     *cr,
                                              GtkWidget   *widget,
                                              GdkWindow   *window);