main: Use the new widget depth when delivering events

We do this all the time when moving the cursor and we can now do it
without the GList allocations.

gtk/gtkimage.c

@@ -77,16 +77,16 @@
  */
 
 
-struct _GtkImagePrivate
+typedef struct
 {
   GtkIconHelper *icon_helper;
   GtkIconSize icon_size;
 
   float baseline_align;
 
-  gchar                *filename;       /* Only used with GTK_IMAGE_SURFACE */
+  char *filename;
-  gchar                *resource_path;  /* Only used with GTK_IMAGE_SURFACE */
+  char *resource_path;
-};
+} GtkImagePrivate;
 
 
 static void gtk_image_snapshot             (GtkWidget    *widget,

gtk/gtkimage.h

@@ -45,7 +45,6 @@ G_BEGIN_DECLS
 
 
 typedef struct _GtkImage              GtkImage;
-typedef struct _GtkImagePrivate       GtkImagePrivate;
 typedef struct _GtkImageClass         GtkImageClass;
 
 /**

gtk/gtkmain.c

@@ -2459,26 +2459,35 @@ propagate_event_down (GtkWidget *widget,
                       GdkEvent  *event,
                       GtkWidget *topmost)
 {
-  gint handled_event = FALSE;
+  gboolean handled_event = FALSE;
-  GList *widgets = NULL;
+  GtkWidget **widgets;
-  GList *l;
+  int n_widgets = 0;
+  int topmost_depth;
+  int i;
 
-  widgets = g_list_prepend (widgets, g_object_ref (widget));
+  if (topmost)
+    topmost_depth = gtk_widget_get_depth (topmost);
+  else
+    topmost_depth = 0;
+
+  widgets = g_alloca (sizeof (*widgets) *
+                      (gtk_widget_get_depth (widget) - topmost_depth));
   while (widget && widget != topmost)
     {
       widget = gtk_widget_get_parent (widget);
       if (!widget)
         break;
 
-      widgets = g_list_prepend (widgets, g_object_ref (widget));
+      widgets[n_widgets] = g_object_ref (widget);
+      n_widgets ++;
 
       if (widget == topmost)
         break;
     }
 
-  for (l = widgets; l && !handled_event; l = l->next)
+  for (i = n_widgets - 1; i >= 0; i --)
     {
-      widget = (GtkWidget *)l->data;
+      widget = widgets[i];
 
       if (!gtk_widget_is_sensitive (widget))
         {
@@ -2491,9 +2500,17 @@ propagate_event_down (GtkWidget *widget,
             handled_event = TRUE;
         }
       else
-        handled_event = _gtk_widget_captured_event (widget, event);
+        {
+          handled_event = _gtk_widget_captured_event (widget, event);
+        }
+
+      if (handled_event)
+        break;
     }
-  g_list_free_full (widgets, (GDestroyNotify)g_object_unref);
+
+  /* Unref all now */
+  for (i = 0; i < n_widgets; i ++)
+    g_object_unref (widgets[i]);
 
   return handled_event;
 }

gtk/gtkpicture.c

@@ -798,26 +798,36 @@ gtk_picture_set_paintable (GtkPicture   *self,
 
   if (self->paintable)
     {
-      g_signal_handlers_disconnect_by_func (self->paintable,
+      const guint flags = gdk_paintable_get_flags (self->paintable);
-                                            gtk_picture_paintable_invalidate_contents,
+
-                                            self);
+      if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
-      g_signal_handlers_disconnect_by_func (self->paintable,
+        g_signal_handlers_disconnect_by_func (self->paintable,
-                                            gtk_picture_paintable_invalidate_size,
+                                              gtk_picture_paintable_invalidate_contents,
-                                            self);
+                                              self);
+
+      if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+        g_signal_handlers_disconnect_by_func (self->paintable,
+                                              gtk_picture_paintable_invalidate_size,
+                                              self);
     }
 
   self->paintable = paintable;
 
   if (paintable)
     {
-      g_signal_connect (paintable,
+      const guint flags = gdk_paintable_get_flags (paintable);
-                        "invalidate-contents",
+
-                        G_CALLBACK (gtk_picture_paintable_invalidate_contents),
+      if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
-                        self);
+        g_signal_connect (paintable,
-      g_signal_connect (paintable,
+                          "invalidate-contents",
-                        "invalidate-size",
+                          G_CALLBACK (gtk_picture_paintable_invalidate_contents),
-                        G_CALLBACK (gtk_picture_paintable_invalidate_size),
+                          self);
-                        self);
+
+      if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+        g_signal_connect (paintable,
+                          "invalidate-size",
+                          G_CALLBACK (gtk_picture_paintable_invalidate_size),
+                          self);
     }
 
   gtk_widget_queue_resize (GTK_WIDGET (self));

gtk/gtkstack.c

@@ -768,12 +768,12 @@ gtk_stack_progress_updated (GtkStack *stack)
 {
   GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
 
-  gtk_widget_queue_draw (GTK_WIDGET (stack));
-
   if (!priv->vhomogeneous || !priv->hhomogeneous)
     gtk_widget_queue_resize (GTK_WIDGET (stack));
   else if (is_window_moving_transition (priv->active_transition_type))
     gtk_widget_queue_allocate (GTK_WIDGET (stack));
+  else
+    gtk_widget_queue_draw (GTK_WIDGET (stack));
 
   if (gtk_progress_tracker_get_state (&priv->tracker) == GTK_PROGRESS_STATE_AFTER)
     {

gtk/gtkwidget.c

@@ -2802,6 +2802,7 @@ gtk_widget_init (GTypeInstance *instance, gpointer g_class)
   priv->last_child = NULL;
   priv->prev_sibling = NULL;
   priv->next_sibling = NULL;
+  priv->depth = 1;
   priv->allocated_baseline = -1;
   priv->allocated_size_baseline = -1;
 
@@ -2979,6 +2980,22 @@ gtk_widget_new (GType        type,
   return widget;
 }
 
+static void
+gtk_widget_propagate_depth (GtkWidget *widget,
+                            int        new_depth)
+{
+  GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
+  GtkWidget *child;
+
+  priv->depth = new_depth;
+
+  for (child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    gtk_widget_propagate_depth (child, new_depth + 1);
+}
+
+
 /**
  * gtk_widget_unparent:
  * @widget: a #GtkWidget
@@ -3062,6 +3079,7 @@ gtk_widget_unparent (GtkWidget *widget)
   priv->parent = NULL;
   priv->prev_sibling = NULL;
   priv->next_sibling = NULL;
+  gtk_widget_propagate_depth (widget, 1);
 
   /* parent may no longer expand if the removed
    * child was expand=TRUE and could therefore
@@ -6505,6 +6523,7 @@ gtk_widget_reposition_after (GtkWidget *widget,
   gtk_widget_push_verify_invariants (widget);
 
   priv->parent = parent;
+  gtk_widget_propagate_depth (widget, gtk_widget_get_depth (parent) + 1);
 
   if (previous_sibling)
     {

gtk/gtkwidgetprivate.h

@@ -167,6 +167,7 @@ struct _GtkWidgetPrivate
   GtkWidget *next_sibling;
   GtkWidget *first_child;
   GtkWidget *last_child;
+  int depth;
 
   /* only created on-demand */
   GtkListListModel *children_observer;
@@ -481,6 +482,12 @@ _gtk_widget_get_last_child (GtkWidget *widget)
   return widget->priv->last_child;
 }
 
+static inline int
+gtk_widget_get_depth (GtkWidget *widget)
+{
+  return widget->priv->depth;
+}
+
 G_END_DECLS
 
 #endif /* __GTK_WIDGET_PRIVATE_H__ */

gtk/gtkwindow.c

@@ -11260,39 +11260,45 @@ update_cursor (GtkWindow *toplevel,
                GtkWidget *target)
 {
   GdkCursor *cursor = NULL;
-  GList *widgets = NULL, *l;
+  GtkWidget **widgets;
+  int n_widgets = 0;
+  int i;
 
   if (grab_widget && !gtk_widget_is_ancestor (target, grab_widget))
     {
       /* Outside the grab widget, cursor stays to whatever the grab
        * widget says.
        */
-      widgets = g_list_prepend (widgets, grab_widget);
+      widgets = g_alloca (sizeof (*widgets));
+      widgets[0] = grab_widget;
+      n_widgets = 1;
     }
   else
     {
       /* Inside the grab widget or in absence of grabs, allow walking
        * up the hierarchy to find out the cursor.
        */
+      widgets = g_alloca (sizeof (*widgets) * gtk_widget_get_depth (target));
+
       while (target)
         {
-          widgets = g_list_prepend (widgets, target);
+          widgets[n_widgets] = target;
+          n_widgets ++;
           if (grab_widget && target == grab_widget)
             break;
           target = _gtk_widget_get_parent (target);
         }
     }
 
-  for (l = g_list_last (widgets); l; l = l->prev)
+  for (i = 0; i < n_widgets; i ++)
     {
-      cursor = gtk_widget_get_cursor (l->data);
+      cursor = gtk_widget_get_cursor (widgets[i]);
       if (cursor)
         break;
     }
 
   gdk_surface_set_device_cursor (gtk_widget_get_surface (GTK_WIDGET (toplevel)),
-				 device, cursor);
+                                 device, cursor);
-  g_list_free (widgets);
 }
 
 void