Add a quick demo for a range selector

This is a widget that looks like a GtkScale,
except that it has two sliders instead of one.
It lets you select a subrange of a given range.

Only horizontal for now, and reusing the GtkScale
styling.

demos/gtk-demo/dnd.c

@@ -597,6 +597,83 @@ css_button_new (const char *class)
   return button;
 }
 
+typedef struct
+{
+  GtkWidget parent_instance;
+  GdkRGBA color;
+} ColorSwatch;
+
+typedef struct
+{
+  GtkWidgetClass parent_class;
+} ColorSwatchClass;
+
+G_DEFINE_TYPE (ColorSwatch, color_swatch, GTK_TYPE_WIDGET)
+
+static GdkContentProvider *
+color_swatch_drag_prepare (GtkDragSource  *source,
+                           double          x,
+                           double          y,
+                           ColorSwatch    *swatch)
+{
+  return gdk_content_provider_new_typed (GDK_TYPE_RGBA, &swatch->color);
+}
+
+static void
+color_swatch_init (ColorSwatch *swatch)
+{
+  GtkDragSource *source = gtk_drag_source_new ();
+  g_signal_connect (source, "prepare", G_CALLBACK (color_swatch_drag_prepare), swatch);
+  gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (source));
+}
+
+static void
+color_swatch_snapshot (GtkWidget   *widget,
+                       GtkSnapshot *snapshot)
+{
+  ColorSwatch *swatch = (ColorSwatch *)widget;
+  float w = gtk_widget_get_width (widget);
+  float h = gtk_widget_get_height (widget);
+
+  gtk_snapshot_append_color (snapshot, &swatch->color,
+                             &GRAPHENE_RECT_INIT(0, 0, w, h));
+}
+
+void
+color_swatch_measure (GtkWidget      *widget,
+                      GtkOrientation  orientation,
+                      int             for_size,
+                      int            *minimum_size,
+                      int            *natural_size,
+                      int            *minimum_baseline,
+                      int            *natural_baseline)
+{
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum_size = *natural_size = 48;
+  else
+    *minimum_size = *natural_size = 32;
+}
+
+static void
+color_swatch_class_init (ColorSwatchClass *class)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  widget_class->snapshot = color_swatch_snapshot;
+  widget_class->measure = color_swatch_measure;
+  gtk_widget_class_set_css_name (widget_class, "colorswatch");
+}
+
+static GtkWidget *
+color_swatch_new (const char *color)
+{
+  ColorSwatch *swatch = g_object_new (color_swatch_get_type (), NULL);
+
+  gdk_rgba_parse (&swatch->color, color);
+
+  return GTK_WIDGET (swatch);
+}
+
 static GtkWidget *window = NULL;
 
 GtkWidget *
@@ -670,18 +747,7 @@ do_dnd (GtkWidget *do_widget)
       gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), box3);
 
       for (i = 0; colors[i]; i++)
-        {
-          GdkRGBA rgba;
-          GtkWidget *swatch;
-
-          gdk_rgba_parse (&rgba, colors[i]);
-
-          swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
-                                 "rgba", &rgba,
-                                 "selectable", FALSE,
-                                 NULL);
-          gtk_box_append (GTK_BOX (box3), swatch);
-        }
+        gtk_box_append (GTK_BOX (box3), color_swatch_new (colors[i]));
 
       gtk_box_append (GTK_BOX (box3), css_button_new ("rainbow1"));
       gtk_box_append (GTK_BOX (box3), css_button_new ("rainbow2"));

docs/reference/gtk/gtk4-docs.xml

@@ -65,9 +65,9 @@
       <section>
         <xi:include href="xml/gtksorter.xml" />
         <xi:include href="xml/gtkcustomsorter.xml" />
+        <xi:include href="xml/gtkmultisorter.xml" />
         <xi:include href="xml/gtkstringsorter.xml" />
         <xi:include href="xml/gtknumericsorter.xml" />
-        <xi:include href="xml/gtkmultisorter.xml" />
       </section>
       <xi:include href="xml/gtkselectionmodel.xml" />
       <section>
@@ -93,7 +93,9 @@
       <xi:include href="xml/gtklistview.xml" />
       <xi:include href="xml/gtkgridview.xml" />
       <xi:include href="xml/gtkcolumnview.xml" />
-      <xi:include href="xml/gtkcolumnviewcolumn.xml" />
+      <section>
+        <xi:include href="xml/gtkcolumnviewcolumn.xml" />
+      </section>
       <xi:include href="xml/gtkdropdown.xml" />
     </chapter>
 

docs/reference/gtk/gtk4-sections.txt

@@ -3420,6 +3420,7 @@ gtk_tree_list_row_get_type
 <SECTION>
 <FILE>gtktreeexpander</FILE>
 <TITLE>GtkTreeExpander</TITLE>
+GtkTreeExpander
 gtk_tree_expander_new
 gtk_tree_expander_get_child
 gtk_tree_expander_set_child
@@ -7551,6 +7552,17 @@ gtk_object_expression_get_object
 gtk_closure_expression_new
 gtk_cclosure_expression_new
 
+<SUBSECTION>
+GTK_VALUE_HOLDS_EXPRESSION
+gtk_value_set_expression
+gtk_value_take_expression
+gtk_value_get_expression
+gtk_value_dup_expression
+
+<SUBSECTION>
+GtkParamSpecExpression
+gtk_param_spec_expression
+
 <SUBSECTION Standard>
 GTK_IS_EXPRESSION
 GTK_TYPE_EXPRESSION

docs/reference/gtk/gtk4.types.in

@@ -19,6 +19,7 @@ gtk_assistant_get_type
 gtk_assistant_page_get_type
 gtk_bin_layout_get_type
 gtk_bitset_get_type
+gtk_expression_get_type
 gtk_bookmark_list_get_type
 gtk_box_get_type
 gtk_box_layout_get_type
@@ -29,6 +30,7 @@ gtk_builder_list_item_factory_get_type
 gtk_builder_scope_get_type
 gtk_button_get_type
 gtk_calendar_get_type
+gtk_cclosure_expression_get_type
 gtk_cell_area_get_type
 gtk_cell_area_box_get_type
 gtk_cell_area_context_get_type
@@ -46,6 +48,7 @@ gtk_cell_renderer_toggle_get_type
 gtk_cell_view_get_type
 gtk_center_layout_get_type
 gtk_check_button_get_type
+gtk_closure_expression_get_type
 gtk_color_button_get_type
 gtk_color_chooser_get_type
 gtk_color_chooser_dialog_get_type
@@ -54,6 +57,7 @@ gtk_column_view_get_type
 gtk_column_view_column_get_type
 gtk_combo_box_get_type
 gtk_combo_box_text_get_type
+gtk_constant_expression_get_type
 gtk_constraint_get_type
 gtk_constraint_guide_get_type
 gtk_constraint_layout_get_type
@@ -150,6 +154,7 @@ gtk_no_selection_get_type
 gtk_notebook_get_type
 gtk_notebook_page_get_type
 gtk_numeric_sorter_get_type
+gtk_object_expression_get_type
 gtk_orientable_get_type
 gtk_overlay_get_type
 gtk_overlay_layout_get_type
@@ -172,6 +177,7 @@ gtk_print_operation_preview_get_type
 gtk_print_settings_get_type
 @DISABLE_ON_W32@gtk_print_unix_dialog_get_type
 gtk_progress_bar_get_type
+gtk_property_expression_get_type
 gtk_radio_button_get_type
 gtk_range_get_type
 gtk_recent_manager_get_type
@@ -229,6 +235,7 @@ gtk_text_view_get_type
 gtk_toggle_button_get_type
 gtk_tree_drag_dest_get_type
 gtk_tree_drag_source_get_type
+gtk_tree_expander_get_type
 gtk_tree_list_model_get_type
 gtk_tree_list_row_get_type
 gtk_tree_list_row_sorter_get_type

docs/reference/gtk/migrating-3to4.md

@@ -170,7 +170,7 @@ in GTK 3, you can prepare for the switch by using gtk_widget_destroy()
 only on toplevel windows, and replace all other uses with
 gtk_container_remove() or g_object_unref().
 
-### Reduce the use of generic container APIs</title>
+### Reduce the use of generic container APIs
 
 GTK 4 removes gtk_container_add() and gtk_container_remove(). While there
 is not always a replacement for gtk_container_remove() in GTK 3, you can

docs/reference/gtk/section-list-widget.md

@@ -183,7 +183,7 @@ transitioning code for easy lookup:
 | #GtkTreeModel       | #GListModel                         |
 | #GtkTreePath        | #guint position, #GtkTreeListRow    |
 | #GtkTreeIter        | #guint position                     |
-| GtkTreeRowReference | #GObject item                       |
+| #GtkTreeRowReference | #GObject item                       |
 | #GtkListStore       | #GListStore                         |
 | #GtkTreeStore       | #GtkTreeListModel, #GtkTreeExpander |
 | #GtkTreeSelection   | #GtkSelectionModel                  |

gdk/gdkrgba.c

@@ -354,7 +354,7 @@ gdk_rgba_equal (gconstpointer p1,
  *
  * Returns a textual specification of @rgba in the form
  * `rgb(r,g,b)` or
- * `rgba(r g,b,a)`,
+ * `rgba(r,g,b,a)`,
  * where “r”, “g”, “b” and “a” represent the red, green,
  * blue and alpha values respectively. “r”, “g”, and “b” are
  * represented as integers in the range 0 to 255, and “a”

gsk/gl/gskglrenderer.c

@@ -70,7 +70,6 @@ typedef enum
   RESET_CLIP       = 1 << 1,
   RESET_OPACITY    = 1 << 2,
   DUMP_FRAMEBUFFER = 1 << 3,
-  CENTER_CHILD     = 1 << 4,
   NO_CACHE_PLZ     = 1 << 5,
 } OffscreenFlags;
 
@@ -906,6 +905,7 @@ upload_texture (GskGLRenderer *self,
     }
   else
     {
+
       out_region->texture_id =
           gsk_gl_driver_get_texture_for_texture (self->gl_driver,
                                                  texture,
@@ -1152,6 +1152,59 @@ rounded_inner_rect_contains_rect (const GskRoundedRect  *rounded,
   return graphene_rect_contains_rect (&inner, rect);
 }
 
+/* Current clip is NOT rounded but new one is definitely! */
+static inline bool
+intersect_rounded_rectilinear (const graphene_rect_t *non_rounded,
+                               const GskRoundedRect  *rounded,
+                               GskRoundedRect        *result)
+{
+  int n_corners = 0;
+  bool corners[4];
+
+  /* Intersects with top left corner? */
+  n_corners += corners[0] = rounded_rect_has_corner (rounded, 0) &&
+                            graphene_rect_intersection (non_rounded,
+                                                        &rounded_rect_corner (rounded, 0), NULL);
+  /* top right? */
+  n_corners += corners[1] = rounded_rect_has_corner (rounded, 1) &&
+                            graphene_rect_intersection (non_rounded,
+                                                        &rounded_rect_corner (rounded, 1), NULL);
+  /* bottom right? */
+  n_corners += corners[2] = rounded_rect_has_corner (rounded, 2) &&
+                            graphene_rect_intersection (non_rounded,
+                                                        &rounded_rect_corner (rounded, 2), NULL);
+  /* bottom left */
+  n_corners += corners[3] = rounded_rect_has_corner (rounded, 3) &&
+                            graphene_rect_intersection (non_rounded,
+                                                        &rounded_rect_corner (rounded, 3), NULL);
+
+  if (corners[0] && !graphene_rect_contains_rect (non_rounded, &rounded_rect_corner (rounded, 0)))
+    return false;
+  if (corners[1] && !graphene_rect_contains_rect (non_rounded, &rounded_rect_corner (rounded, 1)))
+    return false;
+  if (corners[2] && !graphene_rect_contains_rect (non_rounded, &rounded_rect_corner (rounded, 2)))
+    return false;
+  if (corners[3] && !graphene_rect_contains_rect (non_rounded, &rounded_rect_corner (rounded, 3)))
+    return false;
+
+  /* We do intersect with at least one of the corners, but in such a way that the
+   * intersection between the two clips can still be represented by a single rounded
+   * rect in a trivial way. do that. */
+  graphene_rect_intersection (non_rounded, &rounded->bounds, &result->bounds);
+
+  for (int i = 0; i < 4; i++)
+    {
+      if (corners[i])
+        result->corner[i] = rounded->corner[i];
+      else
+        result->corner[i].width = result->corner[i].height = 0;
+    }
+
+  return true;
+}
+
+/* This code intersects the current (maybe rounded) clip with the new
+ * non-rounded clip */
 static inline void
 render_clipped_child (GskGLRenderer         *self,
                       RenderOpBuilder       *builder,
@@ -1159,112 +1212,57 @@ render_clipped_child (GskGLRenderer         *self,
                       GskRenderNode         *child)
 {
   graphene_rect_t transformed_clip;
-  GskRoundedRect child_clip;
+  GskRoundedRect intersection;
 
   ops_transform_bounds_modelview (builder, clip, &transformed_clip);
 
   if (builder->clip_is_rectilinear)
-    goto trivial;
-
-  {
-    const GskRoundedRect *cur_clip = builder->current_clip;
-    int n_corners = 0;
-    bool corners[4];
-
-    /* Intersects with top left corner? */
-    n_corners += corners[0] = rounded_rect_has_corner (cur_clip, 0) &&
-                              graphene_rect_intersection (&transformed_clip,
-                                                          &rounded_rect_corner (cur_clip, 0), NULL);
-    /* top right? */
-    n_corners += corners[1] = rounded_rect_has_corner (cur_clip, 1) &&
-                              graphene_rect_intersection (&transformed_clip,
-                                                          &rounded_rect_corner (cur_clip, 1), NULL);
-    /* bottom right? */
-    n_corners += corners[2] = rounded_rect_has_corner (cur_clip, 2) &&
-                              graphene_rect_intersection (&transformed_clip,
-                                                          &rounded_rect_corner (cur_clip, 2), NULL);
-    /* bottom left */
-    n_corners += corners[3] = rounded_rect_has_corner (cur_clip, 3) &&
-                              graphene_rect_intersection (&transformed_clip,
-                                                          &rounded_rect_corner (cur_clip, 3), NULL);
-
-    if (n_corners == 0)
-      goto trivial;
-
-    if (corners[0] && !graphene_rect_contains_rect (&transformed_clip, &rounded_rect_corner (cur_clip, 0)))
-      goto rtt;
-    if (corners[1] && !graphene_rect_contains_rect (&transformed_clip, &rounded_rect_corner (cur_clip, 1)))
-      goto rtt;
-    if (corners[2] && !graphene_rect_contains_rect (&transformed_clip, &rounded_rect_corner (cur_clip, 2)))
-      goto rtt;
-    if (corners[3] && !graphene_rect_contains_rect (&transformed_clip, &rounded_rect_corner (cur_clip, 3)))
-      goto rtt;
-
-    /* We do intersect with at least one of the corners, but in such a way that the
-     * intersection between the two clips can still be represented by a single rounded
-     * rect in a trivial way. do that. */
     {
-      GskRoundedRect real_intersection;
+      memset (&intersection, 0, sizeof (GskRoundedRect));
+      graphene_rect_intersection (&transformed_clip,
+                                  &builder->current_clip->bounds,
+                                  &intersection.bounds);
 
-      graphene_rect_intersection (&transformed_clip, &cur_clip->bounds, &real_intersection.bounds);
-
-      for (int i = 0; i < 4; i++)
-        {
-          if (corners[i])
-            real_intersection.corner[i] = cur_clip->corner[i];
-          else
-            real_intersection.corner[i].width = real_intersection.corner[i].height = 0;
-        }
-
-      /* Draw with that new clip */
-      ops_push_clip (builder, &real_intersection);
+      ops_push_clip (builder, &intersection);
       gsk_gl_renderer_add_render_ops (self, child, builder);
       ops_pop_clip (builder);
     }
-    return;
-  }
+  else if (intersect_rounded_rectilinear (&transformed_clip,
+                                          builder->current_clip,
+                                          &intersection))
+    {
+      ops_push_clip (builder, &intersection);
+      gsk_gl_renderer_add_render_ops (self, child, builder);
+      ops_pop_clip (builder);
+    }
+  else
+    {
+      /* well fuck */
+      const float scale = ops_get_scale (builder);
+      gboolean is_offscreen;
+      TextureRegion region;
+      GskRoundedRect scaled_clip;
 
-rtt:
-  {
-    /* well fuck */
-    const float scale = ops_get_scale (builder);
-    gboolean is_offscreen;
-    TextureRegion region;
-    GskRoundedRect scaled_clip;
+      memset (&scaled_clip, 0, sizeof (GskRoundedRect));
 
-    memset (&scaled_clip, 0, sizeof (GskRoundedRect));
+      scaled_clip.bounds.origin.x = clip->origin.x * scale;
+      scaled_clip.bounds.origin.y = clip->origin.y * scale;
+      scaled_clip.bounds.size.width = clip->size.width * scale;
+      scaled_clip.bounds.size.height = clip->size.height * scale;
 
-    scaled_clip.bounds.origin.x = clip->origin.x * scale;
-    scaled_clip.bounds.origin.y = clip->origin.y * scale;
-    scaled_clip.bounds.size.width = clip->size.width * scale;
-    scaled_clip.bounds.size.height = clip->size.height * scale;
+      ops_push_clip (builder, &scaled_clip);
+      if (!add_offscreen_ops (self, builder, &child->bounds,
+                              child,
+                              &region, &is_offscreen,
+                              RESET_OPACITY | FORCE_OFFSCREEN))
+        g_assert_not_reached ();
+      ops_pop_clip (builder);
 
-    ops_push_clip (builder, &scaled_clip);
-    if (!add_offscreen_ops (self, builder, &child->bounds,
-                            child,
-                            &region, &is_offscreen,
-                            RESET_OPACITY | FORCE_OFFSCREEN))
-      g_assert_not_reached ();
-    ops_pop_clip (builder);
+      ops_set_program (builder, &self->programs->blit_program);
+      ops_set_texture (builder, region.texture_id);
 
-    ops_set_program (builder, &self->programs->blit_program);
-    ops_set_texture (builder, region.texture_id);
-
-    load_offscreen_vertex_data (ops_draw (builder, NULL), child, builder);
-    return;
-  }
-
-
-trivial:
-  memset (&child_clip, 0, sizeof (GskRoundedRect));
-  graphene_rect_intersection (&transformed_clip,
-                              &builder->current_clip->bounds,
-                              &child_clip.bounds);
-
-  ops_push_clip (builder, &child_clip);
-  gsk_gl_renderer_add_render_ops (self, child, builder);
-  ops_pop_clip (builder);
-  return;
+      load_offscreen_vertex_data (ops_draw (builder, NULL), child, builder);
+    }
 }
 
 static inline void
@@ -1294,6 +1292,29 @@ render_rounded_clip_node (GskGLRenderer       *self,
     return;
 
   ops_transform_bounds_modelview (builder, &clip->bounds, &transformed_clip.bounds);
+  for (i = 0; i < 4; i ++)
+    {
+      transformed_clip.corner[i].width = clip->corner[i].width * scale;
+      transformed_clip.corner[i].height = clip->corner[i].height * scale;
+    }
+
+  if (builder->clip_is_rectilinear)
+    {
+      GskRoundedRect intersected_clip;
+
+      if (intersect_rounded_rectilinear (&builder->current_clip->bounds,
+                                         &transformed_clip,
+                                         &intersected_clip))
+        {
+          ops_push_clip (builder, &intersected_clip);
+          gsk_gl_renderer_add_render_ops (self, child, builder);
+          ops_pop_clip (builder);
+          return;
+        }
+    }
+
+  /* After this point we are really working with a new and a current clip
+   * which both have rounded corners. */
 
   if (!ops_has_clip (builder))
     need_offscreen = FALSE;
@@ -1307,12 +1328,16 @@ render_rounded_clip_node (GskGLRenderer       *self,
     {
       /* If they don't intersect at all, we can simply set
        * the new clip and add the render ops */
-      for (i = 0; i < 4; i ++)
+
+      /* If the new clip entirely contains the current clip, the intersection is simply
+       * the current clip, so we can ignore the new one */
+      if (rounded_inner_rect_contains_rect (&transformed_clip, &builder->current_clip->bounds))
         {
-          transformed_clip.corner[i].width = clip->corner[i].width * scale;
-          transformed_clip.corner[i].height = clip->corner[i].height * scale;
+          gsk_gl_renderer_add_render_ops (self, child, builder);
+          return;
         }
 
+      /* TODO: Intersect current and new clip */
       ops_push_clip (builder, &transformed_clip);
       gsk_gl_renderer_add_render_ops (self, child, builder);
       ops_pop_clip (builder);
@@ -1354,7 +1379,6 @@ render_rounded_clip_node (GskGLRenderer       *self,
 
       load_offscreen_vertex_data (ops_draw (builder, NULL), node, builder);
     }
-  /* Else this node is entirely out of the current clip node and we don't draw it anyway. */
 }
 
 static inline void
@@ -1762,7 +1786,6 @@ render_unblurred_outset_shadow_node (GskGLRenderer   *self,
 }
 
 
-
 static GdkRGBA COLOR_WHITE = { 1, 1, 1, 1 };
 static inline void
 render_outset_shadow_node (GskGLRenderer   *self,
@@ -1783,19 +1806,32 @@ render_outset_shadow_node (GskGLRenderer   *self,
   OpShadow *shadow;
   int blurred_texture_id;
   int cached_tid;
+  bool do_slicing;
 
   /* scaled_outline is the minimal outline we need to draw the given drop shadow,
    * enlarged by the spread and offset by the blur radius. */
   scaled_outline = *outline;
-  /* Shrink our outline to the minimum size that can still hold all the border radii */
-  gsk_rounded_rect_shrink_to_minimum (&scaled_outline);
-  /* Increase by the spread */
-  gsk_rounded_rect_shrink (&scaled_outline, -spread, -spread, -spread, -spread);
-  /* Grow bounds but don't grow corners */
-  graphene_rect_inset (&scaled_outline.bounds, - extra_blur_pixels, - extra_blur_pixels);
-  /* For the center part, we add a few pixels */
-  scaled_outline.bounds.size.width += SHADOW_EXTRA_SIZE;
-  scaled_outline.bounds.size.height += SHADOW_EXTRA_SIZE;
+
+  if (outline->bounds.size.width < blur_extra ||
+      outline->bounds.size.height < blur_extra)
+    {
+      do_slicing = false;
+      gsk_rounded_rect_shrink (&scaled_outline, -spread, -spread, -spread, -spread);
+    }
+  else
+    {
+      /* Shrink our outline to the minimum size that can still hold all the border radii */
+      gsk_rounded_rect_shrink_to_minimum (&scaled_outline);
+      /* Increase by the spread */
+      gsk_rounded_rect_shrink (&scaled_outline, -spread, -spread, -spread, -spread);
+      /* Grow bounds but don't grow corners */
+      graphene_rect_inset (&scaled_outline.bounds, - blur_extra / 2.0, - blur_extra / 2.0);
+      /* For the center part, we add a few pixels */
+      scaled_outline.bounds.size.width += SHADOW_EXTRA_SIZE;
+      scaled_outline.bounds.size.height += SHADOW_EXTRA_SIZE;
+
+      do_slicing = true;
+    }
 
   texture_width  = (int)ceil ((scaled_outline.bounds.size.width  + blur_extra) * scale);
   texture_height = (int)ceil ((scaled_outline.bounds.size.height + blur_extra) * scale);
@@ -1880,6 +1916,41 @@ render_outset_shadow_node (GskGLRenderer   *self,
       blurred_texture_id = cached_tid;
     }
 
+
+  if (!do_slicing)
+    {
+      const float min_x = floorf (builder->dx + outline->bounds.origin.x - spread - (blur_extra / 2.0) + dx);
+      const float min_y = floorf (builder->dy + outline->bounds.origin.y - spread - (blur_extra / 2.0) + dy);
+      float x1, x2, y1, y2, tx1, tx2, ty1, ty2;
+
+      ops_set_program (builder, &self->programs->outset_shadow_program);
+      ops_set_color (builder, color);
+      ops_set_texture (builder, blurred_texture_id);
+
+      shadow = ops_begin (builder, OP_CHANGE_OUTSET_SHADOW);
+      shadow->outline = transform_rect (self, builder, outline);
+
+      tx1 = 0; tx2 = 1;
+      ty1 = 0; ty2 = 1;
+
+      x1 = min_x;
+      x2 = min_x + texture_width / scale;
+      y1 = min_y;
+      y2 = min_y + texture_height / scale;
+
+      ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
+        { { x1, y1 }, { tx1, ty2 }, },
+        { { x1, y2 }, { tx1, ty1 }, },
+        { { x2, y1 }, { tx2, ty2 }, },
+
+        { { x2, y2 }, { tx2, ty1 }, },
+        { { x1, y2 }, { tx1, ty1 }, },
+        { { x2, y1 }, { tx2, ty2 }, },
+      });
+      return;
+    }
+
+
   ops_set_program (builder, &self->programs->outset_shadow_program);
   ops_set_color (builder, color);
   ops_set_texture (builder, blurred_texture_id);
@@ -3317,19 +3388,8 @@ add_offscreen_ops (GskGLRenderer         *self,
                                            bounds->origin.y * scale,
                                            width, height));
 
-  if (flags & CENTER_CHILD)
-    {
-      ops_offset (builder,
-                    (bounds->size.width - child_node->bounds.size.width) / 2.0 -
-                    child_node->bounds.origin.x,
-                    (bounds->size.height - child_node->bounds.size.height) / 2.0 -
-                    child_node->bounds.origin.y);
-    }
-  else
-    {
-      builder->dx = 0;
-      builder->dy = 0;
-    }
+  builder->dx = 0;
+  builder->dy = 0;
 
   if (flags & RESET_OPACITY)
     prev_opacity = ops_set_opacity (builder, 1.0);

gtk/gtkbitset.c

@@ -27,20 +27,19 @@
  * SECTION:gtkbitset
  * @title: GtkBitset
  * @short_description: Sets of integers
- * @see_also: GtkSelectionModel
+ * @see_also: #GtkSelectionModel
  *
  * #GtkBitset is a data structure for representing a set of unsigned integers.
  * Another name for this data structure is "bitmap".
  *
- * This version is based on [roaring bitmaps](https://roaringbitmap.org/).
+ * The current implemenation is based on [roaring bitmaps](https://roaringbitmap.org/).
  *
  * A bitset allows adding a set of integers and provides support for set operations
  * like unions, intersections and checks for equality or if a value is contained
  * in the set. #GtkBitset also contains various functions to query metadata about
  * the bitset, such as the minimum or maximum values or its size.
  *
- * The fastest way to iterate values in a bitset is #GtkBitsetIter which allows
- * quick iteration of all the values in a bitset.
+ * The fastest way to iterate values in a bitset is #GtkBitsetIter.
  *
  * The main use case for #GtkBitset is implementing complex selections for
  * #GtkSelectionModel.

gtk/gtkbitset.h

@@ -130,7 +130,21 @@ void                    gtk_bitset_splice                       (GtkBitset
                                                                  guint                   removed,
                                                                  guint                   added);
 
-typedef struct {gpointer private_data[10]; } GtkBitsetIter;
+/**
+ * GtkBitsetIter:
+ *
+ * An opaque, stack-allocated struct for iterating
+ * over the elements of a #GtkBitset. Before a GtkBitsetIter
+ * can be used, it needs to be initialized with
+ * gtk_bitset_iter_init_first(), gtk_bitset_iter_init_last()
+ * or gtk_bitset_iter_init_at().
+ */
+typedef struct _GtkBitsetIter GtkBitsetIter;
+
+struct _GtkBitsetIter
+{
+  gpointer private_data[10];
+};
 
 GDK_AVAILABLE_IN_ALL
 gboolean                gtk_bitset_iter_init_first              (GtkBitsetIter          *iter,

gtk/gtkboxlayout.c

@@ -28,7 +28,6 @@
 #include "gtkstylecontextprivate.h"
 #include "gtktypebuiltins.h"
 #include "gtkwidgetprivate.h"
-#include "gtknative.h"
 
 /**
  * SECTION:gtkboxlayout
@@ -250,10 +249,8 @@ gtk_box_layout_compute_size (GtkBoxLayout *self,
       required_nat += (n_visible_children - 1) * spacing;
     }
 
-  if (minimum != NULL)
-    *minimum = required_min;
-  if (natural != NULL)
-    *natural = required_nat;
+  *minimum = required_min;
+  *natural = required_nat;
 }
 
 static void
@@ -420,15 +417,10 @@ gtk_box_layout_compute_opposite_size (GtkBoxLayout *self,
         }
     }
 
-  if (minimum != NULL)
-    *minimum = computed_minimum;
-  if (natural != NULL)
-    *natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
-
-  if (min_baseline != NULL)
-    *min_baseline = computed_minimum_baseline;
-  if (nat_baseline != NULL)
-    *nat_baseline = computed_natural_baseline;
+  *minimum = computed_minimum;
+  *natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
+  *min_baseline = computed_minimum_baseline;
+  *nat_baseline = computed_natural_baseline;
 }
 
 static void

gtk/gtkbutton.c

@@ -294,6 +294,17 @@ gtk_button_class_init (GtkButtonClass *klass)
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_BUTTON_ACCESSIBLE);
   gtk_widget_class_set_css_name (widget_class, I_("button"));
+
+  gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_space, 0,
+                                       "activate", NULL);
+  gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Space, 0,
+                                       "activate", NULL);
+  gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Return, 0,
+                                       "activate", NULL);
+  gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_ISO_Enter, 0,
+                                       "activate", NULL);
+  gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Enter, 0,
+                                       "activate", NULL);
 }
 
 static void

gtk/gtkcolumnview.c

@@ -60,7 +60,7 @@
  * GtkColumnView allows the user to select items according to the selection
  * characteristics of the model. If the provided model is not a #GtkSelectionModel,
  * GtkColumnView will wrap it in a #GtkSingleSelection. For models that allow
- * multiple selected items, it is possible to turn on _rubberband selection_,
+ * multiple selected items, it is possible to turn on *rubberband selection*,
  * using #GtkColumnView:enable-rubberband.
  *
  * The column view supports sorting that can be customized by the user by
@@ -1241,7 +1241,7 @@ gtk_column_view_set_model (GtkColumnView *self,
  *
  * Gets the list of columns in this column view. This list is constant over
  * the lifetime of @self and can be used to monitor changes to the columns
- * of @self by connecting to the GListModel:items-changed signal.
+ * of @self by connecting to the #GListModel:items-changed signal.
  *
  * Returns: (transfer none): The list managing the columns
  **/
@@ -1263,7 +1263,7 @@ gtk_column_view_get_columns (GtkColumnView *self)
  */
 void
 gtk_column_view_set_show_row_separators (GtkColumnView *self,
-                                         gboolean     show_row_separators)
+                                         gboolean       show_row_separators)
 {
   g_return_if_fail (GTK_IS_COLUMN_VIEW (self));
 
@@ -1302,7 +1302,7 @@ gtk_column_view_get_show_row_separators (GtkColumnView *self)
  */
 void
 gtk_column_view_set_show_column_separators (GtkColumnView *self,
-                                            gboolean     show_column_separators)
+                                            gboolean       show_column_separators)
 {
   g_return_if_fail (GTK_IS_COLUMN_VIEW (self));
 
@@ -1486,17 +1486,26 @@ gtk_column_view_get_list_view (GtkColumnView *self)
  * gtk_column_view_get_sorter:
  * @self: a #GtkColumnView
  *
- * Returns the sorter associated with users sorting choices in
- * the column view.
+ * Returns a special sorter that reflects the users sorting
+ * choices in the column view.
  *
  * To allow users to customizable sorting by clicking on column
- * headers, this sorter needs to be set on the sort
- * model(s) underneath the model that is displayed
- * by the view.
+ * headers, this sorter needs to be set on the sort model underneath
+ * the model that is displayed by the view.
  *
- * See gtk_column_view_column_get_sorter() for setting up
+ * See gtk_column_view_column_set_sorter() for setting up
  * per-column sorting.
  *
+ * Here is an example:
+ * |[
+ *   gtk_column_view_column_set_sorter (column, sorter);
+ *   gtk_column_view_append_column (view, column);
+ *   model = gtk_sort_list_model_new (store,
+ *                                    gtk_column_view_get_sorter (view));
+ *   selection = gtk_no_selection_new (model);
+ *   gtk_column_view_set_model (view, selection);
+ * ]|
+ *
  * Returns: (transfer none): the #GtkSorter of @self
  */
 GtkSorter *

gtk/gtkcustomfilter.c

@@ -29,8 +29,8 @@
  * @Title: GtkCustomFilter
  * @Short_description: Filtering with callbacks
  *
- * #GtkCustomFilter is a #GtkFilter that uses a callback to determine whether
- * to include an item or not.
+ * #GtkCustomFilter is a #GtkFilter that uses a callback to determine
+ * whether to include an item or not.
  */
 struct _GtkCustomFilter
 {
@@ -98,11 +98,13 @@ gtk_custom_filter_init (GtkCustomFilter *self)
  * gtk_custom_filter_new:
  * @match_func: (nullable): function to filter items
  * @user_data: (nullable): user data to pass to @match_func
- * @user_destroy: destory notify
+ * @user_destroy: destroy notify for @user_data
  *
  * Creates a new filter using the given @match_func to filter
  * items.
  *
+ * If @match_func is %NULL, the filter matches all items.
+ *
  * If the filter func changes its filtering behavior,
  * gtk_filter_changed() needs to be called.
  *
@@ -127,10 +129,12 @@ gtk_custom_filter_new (GtkCustomFilterFunc match_func,
  * @self: a #GtkCustomFilter
  * @match_func: (nullable): function to filter items
  * @user_data: (nullable): user data to pass to @match_func
- * @user_destroy: destory notify
+ * @user_destroy: destroy notify for @user_data
  *
  * Sets (or unsets) the function used for filtering items.
- * 
+ *
+ * If @match_func is %NULL, the filter matches all items.
+ *
  * If the filter func changes its filtering behavior,
  * gtk_filter_changed() needs to be called.
  *

gtk/gtkcustomsorter.c

@@ -27,7 +27,7 @@
 /**
  * SECTION:gtkcustomsorter
  * @Title: GtkCustomSorter
- * @Short_description: Sorting with a callback
+ * @Short_description: Sorting with a callbacks
  *
  * GtkCustomSorter is a #GtkSorter implementation that sorts
  * via a traditional #GCompareDataFunc callback.
@@ -108,8 +108,10 @@ gtk_custom_sorter_init (GtkCustomSorter *self)
  * Creates a new #GtkSorter that works by calling
  * @sort_func to compare items.
  *
- * Returns: a new #GTkSorter
- */ 
+ * If @sort_func is %NULL, all items are considered equal.
+ *
+ * Returns: a new #GtkSorter
+ */
 GtkSorter *
 gtk_custom_sorter_new (GCompareDataFunc sort_func,
                        gpointer         user_data,
@@ -129,10 +131,12 @@ gtk_custom_sorter_new (GCompareDataFunc sort_func,
  * @self: a #GtkCustomSorter
  * @sort_func: (nullable): function to sort items
  * @user_data: (nullable): user data to pass to @match_func
- * @user_destroy: destory notify
+ * @user_destroy: destroy notify for @user_data
  *
  * Sets (or unsets) the function used for sorting items.
- * 
+ *
+ * If @sort_func is %NULL, all items are considered equal.
+ *
  * If the sort func changes its sorting behavior,
  * gtk_sorter_changed() needs to be called.
  *

gtk/gtkdebug.h

@@ -48,11 +48,10 @@ typedef enum {
   GTK_DEBUG_INTERACTIVE     = 1 << 10,
   GTK_DEBUG_TOUCHSCREEN     = 1 << 11,
   GTK_DEBUG_ACTIONS         = 1 << 12,
-  GTK_DEBUG_RESIZE          = 1 << 13,
-  GTK_DEBUG_LAYOUT          = 1 << 14,
-  GTK_DEBUG_SNAPSHOT        = 1 << 15,
-  GTK_DEBUG_CONSTRAINTS     = 1 << 16,
-  GTK_DEBUG_BUILDER_OBJECTS = 1 << 17,
+  GTK_DEBUG_LAYOUT          = 1 << 13,
+  GTK_DEBUG_SNAPSHOT        = 1 << 14,
+  GTK_DEBUG_CONSTRAINTS     = 1 << 15,
+  GTK_DEBUG_BUILDER_OBJECTS = 1 << 16,
 } GtkDebugFlag;
 
 #ifdef G_ENABLE_DEBUG

gtk/gtkdropdown.c

@@ -70,7 +70,7 @@
  * useful if the list of options is long. To enable the search entry,
  * use gtk_drop_down_set_enable_search().
  *
- * * # CSS nodes
+ * # CSS nodes
  *
  * GtkDropDown has a single CSS node with name dropdown,
  * with the button and popover nodes as children.

gtk/gtkeditablelabel.c

@@ -30,6 +30,7 @@
 #include "gtkshortcut.h"
 #include "gtkshortcuttrigger.h"
 #include "gtkwidgetprivate.h"
+#include "gtkeventcontrollerfocus.h"
 #include "gtkintl.h"
 
 /**
@@ -48,6 +49,22 @@
  * to click or press the Enter key. The default bindings
  * for leaving the edit mode are the Enter key (to save
  * the results) or the Escape key (to cancel the editing).
+ *
+ * # CSS nodes
+ *
+ * |[<!-- language="plain" -->
+ * editablelabel[.editing]
+ * ╰── stack
+ *     ├── label
+ *     ╰── text
+ * ]|
+ *
+ * GtkEditableLabel has a main node with the name editablelabel.
+ * When the entry is in editing mode, it gets the .editing style
+ * class.
+ *
+ * For all the subnodes added to the text node in various situations,
+ * see #GtkText.
  */
 
 struct _GtkEditableLabel
@@ -177,12 +194,20 @@ gtk_editable_label_prepare_drag (GtkDragSource    *source,
                                          gtk_label_get_label (GTK_LABEL (self->label)));
 }
 
+static void
+gtk_editable_label_focus_out (GtkEventController *controller,
+                              GtkEditableLabel   *self)
+{
+  gtk_editable_label_stop_editing (self, TRUE);
+}
+
 static void
 gtk_editable_label_init (GtkEditableLabel *self)
 {
   GtkGesture *gesture;
   GtkDropTarget *target;
   GtkDragSource *source;
+  GtkEventController *controller;
 
   gtk_widget_set_focusable (GTK_WIDGET (self), TRUE);
 
@@ -212,6 +237,10 @@ gtk_editable_label_init (GtkEditableLabel *self)
   g_signal_connect (source, "prepare", G_CALLBACK (gtk_editable_label_prepare_drag), self);
   gtk_widget_add_controller (self->label, GTK_EVENT_CONTROLLER (source));
 
+  controller = gtk_event_controller_focus_new ();
+  g_signal_connect (controller, "leave", G_CALLBACK (gtk_editable_label_focus_out), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
   gtk_editable_init_delegate (GTK_EDITABLE (self));
 }
 
@@ -444,6 +473,8 @@ gtk_editable_label_start_editing (GtkEditableLabel *self)
   gtk_stack_set_visible_child_name (GTK_STACK (self->stack), "entry");
   gtk_widget_grab_focus (self->entry);
 
+  gtk_widget_add_css_class (GTK_WIDGET (self), "editing");
+
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EDITING]);
 }
 
@@ -480,5 +511,8 @@ gtk_editable_label_stop_editing (GtkEditableLabel *self,
     }
 
   gtk_widget_grab_focus (GTK_WIDGET (self));
+
+  gtk_widget_remove_css_class (GTK_WIDGET (self), "editing");
+
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EDITING]);
 }

gtk/gtkexpression.c

@@ -53,26 +53,26 @@
  *
  * Here is an example of a complex expression:
  * |[
- * color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
- *                                           NULL, "item");
- * expression = gtk_property_expression_new (GTK_TYPE_COLOR,
- *                                           color_expr,
- *                                           "name");
+ *   color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
+ *                                             NULL, "item");
+ *   expression = gtk_property_expression_new (GTK_TYPE_COLOR,
+ *                                             color_expr, "name");
  * ]|
+ *
  * when evaluated with `this` being a GtkListItem, it will obtain the
  * "item" property from the GtkListItem, and then obtain the "name" property
  * from the resulting object (which is assumed to be of type GTK_TYPE_COLOR).
  *
  * A more concise way to describe this would be
  * |[
- * this->item->name
+ *   this->item->name
  * ]|
  *
  * The most likely place where you will encounter expressions is in the context
  * of list models and list widgets using them. For example, #GtkDropDown is
  * evaluating a GtkExpression to obtain strings from the items in its model
  * that it can then use to match against the contents of its search entry.
- * #GtkStringFilter is using a GtkExpression for a similar reason.
+ * #GtkStringFilter is using a GtkExpression for similar reasons.
  *
  * By default, expressions are not paying attention to changes and evaluation is
  * just a snapshot of the current state at a given time. To get informed about
@@ -127,11 +127,11 @@
  * attribute to specify the object type, and a `name` attribute to specify the property
  * to look up. The content of <lookup> can either be an element specfiying the expression
  * to use the object, or a string that specifies the name of the object to use.
- * 
+ *
  * Example:
  * |[
  *   <lookup name='search'>string_filter</lookup>
- * |]
+ * ]|
  *
  * To create a constant expression, use the <constant> element. If the type attribute
  * is specified, the element content is interpreted as a value of that type. Otherwise,

gtk/gtkfilter.c

@@ -30,20 +30,21 @@
  * @Short_description: Filtering items
  * @See_also: #GtkFilerListModel
  *
- * #GtkFilter is the way to describe filters to be used in #GtkFilterListModel.
- * 
- * The model will use a filter to determine if it should filter items or not
- * by calling gtk_filter_match() for each item and only keeping the ones
- * visible that the function returns %TRUE for.
+ * A #GtkFilter object describes the filtering to be performed by a
+ * #GtkFilterListModel.
+ *
+ * The model will use the filter to determine if it should include items
+ * or not by calling gtk_filter_match() for each item and only keeping the
+ * ones that the function returns %TRUE for.
  *
  * Filters may change what items they match through their lifetime. In that
- * case, they can call gtk_filter_changed() which will emit the #GtkFilter:changed
- * signal to notify that previous filter results are no longer valid and that
- * items should be checked via gtk_filter_match() again.
+ * case, they will emit the #GtkFilter:changed signal to notify that previous
+ * filter results are no longer valid and that items should be checked again
+ * via gtk_filter_match().
  *
- * GTK provides various premade filter implementations for common filtering
+ * GTK provides various pre-made filter implementations for common filtering
  * operations. These filters often include properties that can be linked to
- * various widgets to easily allow searches.  
+ * various widgets to easily allow searches.
  *
  * However, in particular for large lists or complex search methods, it is
  * also possible to subclass #GtkFilter and provide one's own filter.
@@ -118,7 +119,7 @@ gtk_filter_init (GtkFilter *self)
  * @self: a #GtkFilter
  * @item: (type GObject) (transfer none): The item to check
  *
- * Checks if the given @item is matched by the filter or not. 
+ * Checks if the given @item is matched by the filter or not.
  *
  * Returns: %TRUE if the filter matches the item and a filter model should
  *     keep it, %FALSE if not.
@@ -140,7 +141,7 @@ gtk_filter_match (GtkFilter *self,
  * Gets the known strictness of @filters. If the strictness is not known,
  * %GTK_FILTER_MATCH_SOME is returned.
  *
- * This value may change after emission of the GtkFilter:changed signal.
+ * This value may change after emission of the #GtkFilter:changed signal.
  *
  * This function is meant purely for optimization purposes, filters can
  * choose to omit implementing it, but #GtkFilterListModel uses it.

gtk/gtkfilterlistmodel.c

@@ -771,8 +771,8 @@ gtk_filter_list_model_get_model (GtkFilterListModel *self)
  * @self: a #GtkFilterListModel
  * @incremental: %TRUE to enable incremental filtering
  *
- * When incremental filtering is enabled, the filterlistmodel will not run
- * filters immediately, but will instead queue an idle handler that
+ * When incremental filtering is enabled, the GtkFilterListModel will not
+ * run filters immediately, but will instead queue an idle handler that
  * incrementally filters the items and adds them to the list. This of course
  * means that items are not instantly added to the list, but only appear
  * incrementally.
@@ -837,8 +837,14 @@ gtk_filter_list_model_get_incremental (GtkFilterListModel *self)
  *
  * You can use this value to check if @self is busy filtering by
  * comparing the return value to 0 or you can compute the percentage
- * of the filter remaining by dividing the return value by
- * g_list_model_get_n_items(gtk_filter_list_model_get_model (self)).
+ * of the filter remaining by dividing the return value by the total
+ * number of items in the underlying model:
+ *
+ * |[
+ *   pending = gtk_filter_list_model_get_pending (self);
+ *   model = gtk_filter_list_model_get_model (self);
+ *   percentage = pending / (double) g_list_model_get_n_items (model);
+ * ]|
  *
  * Returns: The number of items not yet filtered
  **/

gtk/gtkgridview.c

@@ -45,7 +45,7 @@
 /**
  * SECTION:gtkgridview
  * @title: GtkGridView
- * @short_description: A widget for displaying lists in a grid
+ * @short_description: A widget for displaying grids
  * @see_also: #GListModel, #GtkListView, #GtkColumnView
  *
  * GtkGridView is a widget to present a view into a large dynamic grid of items.

gtk/gtkicontheme.c

@@ -3858,11 +3858,11 @@ gtk_icon_paintable_ensure_texture (GtkIconPaintable *self)
 
 static void
 init_color_matrix (graphene_matrix_t *color_matrix,
-                   graphene_vec4_t *color_offset,
-                   const GdkRGBA *foreground_color,
-                   const GdkRGBA *success_color,
-                   const GdkRGBA *warning_color,
-                   const GdkRGBA *error_color)
+                   graphene_vec4_t   *color_offset,
+                   const GdkRGBA     *foreground_color,
+                   const GdkRGBA     *success_color,
+                   const GdkRGBA     *warning_color,
+                   const GdkRGBA     *error_color)
 {
   GdkRGBA fg_default = { 0.7450980392156863, 0.7450980392156863, 0.7450980392156863, 1.0};
   GdkRGBA success_default = { 0.3046921492332342,0.6015716792553597, 0.023437857633325704, 1.0};

gtk/gtklistitem.c

@@ -26,7 +26,7 @@
 /**
  * SECTION:gtklistitem
  * @title: GtkListItem
- * @short_description: Object used to represent items of a ListModel
+ * @short_description: Object used to represent items of a list model
  * @see_also: #GtkListView, #GListModel
  *
  * #GtkListItem is the object that list-handling containers such

gtk/gtkmain.c

@@ -181,7 +181,6 @@ static const GdkDebugKey gtk_debug_keys[] = {
   { "no-css-cache", GTK_DEBUG_NO_CSS_CACHE, "Disable style property cache" },
   { "interactive", GTK_DEBUG_INTERACTIVE, "Enable the GTK inspector" },
   { "touchscreen", GTK_DEBUG_TOUCHSCREEN, "Pretend the pointer is a touchscreen" },
-  { "resize", GTK_DEBUG_RESIZE, "Highlight resizing widgets" },
   { "layout", GTK_DEBUG_LAYOUT, "Show layout borders" },
   { "snapshot", GTK_DEBUG_SNAPSHOT, "Generate debug render nodes" },
 };

gtk/gtkmultifilter.c

@@ -25,6 +25,13 @@
 #include "gtkintl.h"
 #include "gtktypebuiltins.h"
 
+#define GDK_ARRAY_TYPE_NAME GtkFilters
+#define GDK_ARRAY_NAME gtk_filters
+#define GDK_ARRAY_ELEMENT_TYPE GtkFilter *
+#define GDK_ARRAY_FREE_FUNC g_object_unref
+
+#include "gdk/gdkarrayimpl.c"
+
 /*** MULTI FILTER ***/
 
 /**
@@ -35,17 +42,17 @@
  * GtkMultiFilter is the base type that implements support for handling
  * multiple filters.
  *
- * GtkAnyFilter is an implementation of GtkMultiFilter that matches an item
+ * GtkAnyFilter is a subclass of GtkMultiFilter that matches an item
  * when at least one of its filters matches.
  *
- * GtkEveryFilter is an implementation of GtkMultiFilter that matches an item
+ * GtkEveryFilter is a subclass of GtkMultiFilter that matches an item
  * when each of its filters matches.
  */
 struct _GtkMultiFilter
 {
   GtkFilter parent_instance;
 
-  GSequence *filters;
+  GtkFilters filters;
 };
 
 struct _GtkMultiFilterClass
@@ -67,7 +74,7 @@ gtk_multi_filter_get_n_items (GListModel *list)
 {
   GtkMultiFilter *self = GTK_MULTI_FILTER (list);
 
-  return g_sequence_get_length (self->filters);
+  return gtk_filters_get_size (&self->filters);
 }
 
 static gpointer
@@ -75,14 +82,11 @@ gtk_multi_filter_get_item (GListModel *list,
                            guint       position)
 {
   GtkMultiFilter *self = GTK_MULTI_FILTER (list);
-  GSequenceIter *iter;
 
-  iter = g_sequence_get_iter_at_pos (self->filters, position);
-
-  if (g_sequence_iter_is_end (iter))
-    return NULL;
+  if (position < gtk_filters_get_size (&self->filters))
+    return g_object_ref (gtk_filters_get (&self->filters, position));
   else
-    return g_object_ref (g_sequence_get (iter));
+    return NULL;
 }
 
 static void
@@ -127,53 +131,35 @@ gtk_multi_filter_changed_cb (GtkFilter       *filter,
   gtk_filter_changed (GTK_FILTER (self), change);
 }
 
-static void
-gtk_multi_filter_remove_iter (GtkMultiFilter *self,
-                              GSequenceIter  *iter)
-{
-  GtkFilter *filter;
-
-  filter = g_sequence_get (iter);
-  g_signal_handlers_disconnect_by_func (filter, gtk_multi_filter_changed_cb, self);
-  g_object_unref (filter);
-  g_sequence_remove (iter);
-}
-
 static void
 gtk_multi_filter_dispose (GObject *object)
 {
   GtkMultiFilter *self = GTK_MULTI_FILTER (object);
+  guint i;
 
-  while (!g_sequence_is_empty (self->filters))
-    gtk_multi_filter_remove_iter (self, g_sequence_get_begin_iter (self->filters));
+  for (i = 0; i < gtk_filters_get_size (&self->filters); i++)
+    {
+      GtkFilter *filter = gtk_filters_get (&self->filters, i);
+      g_signal_handlers_disconnect_by_func (filter, gtk_multi_filter_changed_cb, self);
+    }
+
+  gtk_filters_clear (&self->filters);
 
   G_OBJECT_CLASS (gtk_multi_filter_parent_class)->dispose (object);
 }
 
-static void
-gtk_multi_filter_finalize (GObject *object)
-{
-  GtkMultiFilter *self = GTK_MULTI_FILTER (object);
-
-  g_assert (g_sequence_is_empty (self->filters));
-  g_sequence_free (self->filters);
-
-  G_OBJECT_CLASS (gtk_multi_filter_parent_class)->finalize (object);
-}
-
 static void
 gtk_multi_filter_class_init (GtkMultiFilterClass *class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (class);
 
   object_class->dispose = gtk_multi_filter_dispose;
-  object_class->finalize = gtk_multi_filter_finalize;
 }
 
 static void
 gtk_multi_filter_init (GtkMultiFilter *self)
 {
-  self->filters = g_sequence_new (NULL);
+  gtk_filters_init (&self->filters);
 }
 
 /**
@@ -191,7 +177,7 @@ gtk_multi_filter_append (GtkMultiFilter *self,
   g_return_if_fail (GTK_IS_FILTER (filter));
 
   g_signal_connect (filter, "changed", G_CALLBACK (gtk_multi_filter_changed_cb), self);
-  g_sequence_append (self->filters, filter);
+  gtk_filters_append (&self->filters, filter);
 
   gtk_filter_changed (GTK_FILTER (self),
                       GTK_MULTI_FILTER_GET_CLASS (self)->addition_change);
@@ -211,15 +197,16 @@ void
 gtk_multi_filter_remove (GtkMultiFilter *self,
                          guint           position)
 {
-  GSequenceIter *iter;
   guint length;
+  GtkFilter *filter;
 
-  length = g_sequence_get_length (self->filters);
+  length = gtk_filters_get_size (&self->filters);
   if (position >= length)
     return;
 
-  iter = g_sequence_get_iter_at_pos (self->filters, position);
-  gtk_multi_filter_remove_iter (self, iter);
+  filter = gtk_filters_get (&self->filters, position);
+  g_signal_handlers_disconnect_by_func (filter, gtk_multi_filter_changed_cb, self);
+  gtk_filters_splice (&self->filters, position, 1, NULL, 0);
 
   gtk_filter_changed (GTK_FILTER (self),
                       GTK_MULTI_FILTER_GET_CLASS (self)->removal_change);
@@ -244,13 +231,11 @@ gtk_any_filter_match (GtkFilter *filter,
                       gpointer   item)
 {
   GtkMultiFilter *self = GTK_MULTI_FILTER (filter);
-  GSequenceIter *iter;
+  guint i;
 
-  for (iter = g_sequence_get_begin_iter (self->filters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_filters_get_size (&self->filters); i++)
     {
-      GtkFilter *child = g_sequence_get (iter);
+      GtkFilter *child = gtk_filters_get (&self->filters, i);
 
       if (gtk_filter_match (child, item))
         return TRUE;
@@ -262,15 +247,13 @@ gtk_any_filter_match (GtkFilter *filter,
 static GtkFilterMatch
 gtk_any_filter_get_strictness (GtkFilter *filter)
 {
-  GtkMultiFilter *multi = GTK_MULTI_FILTER (filter);
-  GSequenceIter *iter;
+  GtkMultiFilter *self = GTK_MULTI_FILTER (filter);
+  guint i;
   GtkFilterMatch result = GTK_FILTER_MATCH_NONE;
 
-  for (iter = g_sequence_get_begin_iter (multi->filters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_filters_get_size (&self->filters); i++)
     {
-      GtkFilter *child = g_sequence_get (iter);
+      GtkFilter *child = gtk_filters_get (&self->filters, i);
 
       switch (gtk_filter_get_strictness (child))
       {
@@ -346,13 +329,11 @@ gtk_every_filter_match (GtkFilter *filter,
                         gpointer   item)
 {
   GtkMultiFilter *self = GTK_MULTI_FILTER (filter);
-  GSequenceIter *iter;
+  guint i;
 
-  for (iter = g_sequence_get_begin_iter (self->filters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_filters_get_size (&self->filters); i++)
     {
-      GtkFilter *child = g_sequence_get (iter);
+      GtkFilter *child = gtk_filters_get (&self->filters, i);
 
       if (!gtk_filter_match (child, item))
         return FALSE;
@@ -364,15 +345,13 @@ gtk_every_filter_match (GtkFilter *filter,
 static GtkFilterMatch
 gtk_every_filter_get_strictness (GtkFilter *filter)
 {
-  GtkMultiFilter *multi = GTK_MULTI_FILTER (filter);
-  GSequenceIter *iter;
+  GtkMultiFilter *self = GTK_MULTI_FILTER (filter);
+  guint i;
   GtkFilterMatch result = GTK_FILTER_MATCH_ALL;
 
-  for (iter = g_sequence_get_begin_iter (multi->filters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_filters_get_size (&self->filters); i++)
     {
-      GtkFilter *child = g_sequence_get (iter);
+      GtkFilter *child = gtk_filters_get (&self->filters, i);
 
       switch (gtk_filter_get_strictness (child))
       {
@@ -413,7 +392,7 @@ gtk_every_filter_init (GtkEveryFilter *self)
 /**
  * gtk_every_filter_new:
  *
- * Creates a new empty "every" filter.  
+ * Creates a new empty "every" filter.
  * Use gtk_multi_filter_append() to add filters to it.
  *
  * This filter matches an item if each of the filters added to it

gtk/gtkmultisorter.c

@@ -25,6 +25,13 @@
 #include "gtkintl.h"
 #include "gtktypebuiltins.h"
 
+#define GDK_ARRAY_TYPE_NAME GtkSorters
+#define GDK_ARRAY_NAME gtk_sorters
+#define GDK_ARRAY_ELEMENT_TYPE GtkSorter *
+#define GDK_ARRAY_FREE_FUNC g_object_unref
+
+#include "gdk/gdkarrayimpl.c"
+
 /**
  * SECTION:gtkmultisorter
  * @Title: GtkMultiSorter
@@ -38,7 +45,7 @@ struct _GtkMultiSorter
 {
   GtkSorter parent_instance;
 
-  GSequence *sorters;
+  GtkSorters sorters;
 };
 
 static GType
@@ -52,7 +59,7 @@ gtk_multi_sorter_get_n_items (GListModel *list)
 {
   GtkMultiSorter *self = GTK_MULTI_SORTER (list);
 
-  return g_sequence_get_length (self->sorters);
+  return gtk_sorters_get_size (&self->sorters);
 }
 
 static gpointer
@@ -60,14 +67,11 @@ gtk_multi_sorter_get_item (GListModel *list,
                            guint       position)
 {
   GtkMultiSorter *self = GTK_MULTI_SORTER (list);
-  GSequenceIter *iter;
 
-  iter = g_sequence_get_iter_at_pos (self->sorters, position);
-
-  if (g_sequence_iter_is_end (iter))
-    return NULL;
+  if (position < gtk_sorters_get_size (&self->sorters))
+    return g_object_ref (gtk_sorters_get (&self->sorters, position));
   else
-    return g_object_ref (g_sequence_get (iter));
+    return NULL;
 }
 
 static void
@@ -111,13 +115,11 @@ gtk_multi_sorter_compare (GtkSorter *sorter,
 {
   GtkMultiSorter *self = GTK_MULTI_SORTER (sorter);
   GtkOrdering result = GTK_ORDERING_EQUAL;
-  GSequenceIter *iter;
+  guint i;
 
-  for (iter = g_sequence_get_begin_iter (self->sorters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
     {
-      GtkSorter *child = g_sequence_get (iter);
+      GtkSorter *child = gtk_sorters_get (&self->sorters, i);
 
       result = gtk_sorter_compare (child, item1, item2);
       if (result != GTK_ORDERING_EQUAL)
@@ -132,13 +134,11 @@ gtk_multi_sorter_get_order (GtkSorter *sorter)
 {
   GtkMultiSorter *self = GTK_MULTI_SORTER (sorter);
   GtkSorterOrder result = GTK_SORTER_ORDER_NONE;
-  GSequenceIter *iter;
+  guint i;
 
-  for (iter = g_sequence_get_begin_iter (self->sorters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
     {
-      GtkSorter *child = g_sequence_get (iter);
+      GtkSorter *child = gtk_sorters_get (&self->sorters, i);
       GtkSorterOrder child_order;
 
       child_order = gtk_sorter_get_order (child);
@@ -166,12 +166,14 @@ gtk_multi_sorter_changed_cb (GtkSorter       *sorter,
                              GtkMultiSorter  *self)
 {
   /* Using an enum on purpose, so gcc complains about this case if
-   * new values are added to the enum */
+   * new values are added to the enum
+   */
   switch (change)
   {
     case GTK_SORTER_CHANGE_INVERTED:
-      /* This could do a lot better with change handling, in particular in cases where self->n_sorters == 1
-       * or if sorter == self->sorters[0] */
+      /* This could do a lot better with change handling, in particular in
+       * cases where self->n_sorters == 1 or if sorter == self->sorters[0]
+       */
       change = GTK_SORTER_CHANGE_DIFFERENT;
       break;
 
@@ -187,39 +189,22 @@ gtk_multi_sorter_changed_cb (GtkSorter       *sorter,
   gtk_sorter_changed (GTK_SORTER (self), change);
 }
 
-static void
-gtk_multi_sorter_remove_iter (GtkMultiSorter *self,
-                              GSequenceIter  *iter)
-{
-  GtkSorter *sorter;
-
-  sorter = g_sequence_get (iter);
-  g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
-  g_object_unref (sorter);
-  g_sequence_remove (iter);
-}
-
 static void
 gtk_multi_sorter_dispose (GObject *object)
 {
   GtkMultiSorter *self = GTK_MULTI_SORTER (object);
+  guint i;
 
-  while (!g_sequence_is_empty (self->sorters))
-    gtk_multi_sorter_remove_iter (self, g_sequence_get_begin_iter (self->sorters));
+  for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
+    {
+      GtkSorter *sorter = gtk_sorters_get (&self->sorters, i);
+      g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
+    }
+  gtk_sorters_clear (&self->sorters);
 
   G_OBJECT_CLASS (gtk_multi_sorter_parent_class)->dispose (object);
 }
 
-static void
-gtk_multi_sorter_finalize (GObject *object)
-{
-  GtkMultiSorter *self = GTK_MULTI_SORTER (object);
-
-  g_sequence_free (self->sorters);
-
-  G_OBJECT_CLASS (gtk_multi_sorter_parent_class)->finalize (object);
-}
-
 static void
 gtk_multi_sorter_class_init (GtkMultiSorterClass *class)
 {
@@ -230,13 +215,12 @@ gtk_multi_sorter_class_init (GtkMultiSorterClass *class)
   sorter_class->get_order = gtk_multi_sorter_get_order;
 
   object_class->dispose = gtk_multi_sorter_dispose;
-  object_class->finalize = gtk_multi_sorter_finalize;
 }
 
 static void
 gtk_multi_sorter_init (GtkMultiSorter *self)
 {
-  self->sorters = g_sequence_new (NULL);
+  gtk_sorters_init (&self->sorters);
 }
 
 /**
@@ -274,7 +258,7 @@ gtk_multi_sorter_append (GtkMultiSorter *self,
   g_return_if_fail (GTK_IS_SORTER (sorter));
 
   g_signal_connect (sorter, "changed", G_CALLBACK (gtk_multi_sorter_changed_cb), self);
-  g_sequence_append (self->sorters, sorter);
+  gtk_sorters_append (&self->sorters, sorter);
 
   gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_MORE_STRICT);
 }
@@ -293,17 +277,18 @@ void
 gtk_multi_sorter_remove (GtkMultiSorter *self,
                          guint           position)
 {
-  GSequenceIter *iter;
   guint length;
+  GtkSorter *sorter;
 
   g_return_if_fail (GTK_IS_MULTI_SORTER (self));
 
-  length = g_sequence_get_length (self->sorters);
+  length = gtk_sorters_get_size (&self->sorters);
   if (position >= length)
     return;
 
-  iter = g_sequence_get_iter_at_pos (self->sorters, position);
-  gtk_multi_sorter_remove_iter (self, iter);
+  sorter = gtk_sorters_get (&self->sorters, position);
+  g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
+  gtk_sorters_splice (&self->sorters, position, 1, NULL, 0);
 
   gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_LESS_STRICT);
 }

gtk/gtksnapshot.c

@@ -351,9 +351,6 @@ gtk_snapshot_collect_debug (GtkSnapshot      *snapshot,
   if (node == NULL)
     return NULL;
 
-  if (state->data.debug.message == NULL)
-    return node;
-
   debug_node = gsk_debug_node_new (node, state->data.debug.message);
 
   gsk_render_node_unref (node);
@@ -377,15 +374,17 @@ gtk_snapshot_push_debug (GtkSnapshot *snapshot,
                          ...)
 {
   GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
-  GtkSnapshotState *state;
-
-  state = gtk_snapshot_push_state (snapshot,
-                                   current_state->transform,
-                                   gtk_snapshot_collect_debug);
 
   if (GTK_DEBUG_CHECK (SNAPSHOT))
     {
       va_list args;
+      GtkSnapshotState *state;
+
+      state = gtk_snapshot_push_state (snapshot,
+                                       current_state->transform,
+                                       gtk_snapshot_collect_debug);
+
+
 
       va_start (args, message);
       state->data.debug.message = g_strdup_vprintf (message, args);
@@ -393,7 +392,9 @@ gtk_snapshot_push_debug (GtkSnapshot *snapshot,
     }
   else
     {
-      state->data.debug.message = NULL;
+      gtk_snapshot_push_state (snapshot,
+                               current_state->transform,
+                               gtk_snapshot_collect_default);
     }
 }
 
@@ -1822,7 +1823,7 @@ gtk_snapshot_render_layout (GtkSnapshot     *snapshot,
   fg_color = gtk_css_color_value_get_rgba (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR));
 
   shadows_value = _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_TEXT_SHADOW);
-    has_shadow = gtk_css_shadow_value_push_snapshot (shadows_value, snapshot);
+  has_shadow = gtk_css_shadow_value_push_snapshot (shadows_value, snapshot);
 
   gtk_snapshot_append_layout (snapshot, layout, fg_color);
 

gtk/gtksorter.c

@@ -37,9 +37,8 @@
  * by calling gtk_sorter_compare() for pairs of items.
  *
  * Sorters may change their sorting behavior through their lifetime. In that case,
- * they call gtk_sorter_changed(), which will emit the #GtkSorter::changed signal to
- * notify that the sort order is no longer valid and should be updated by calling
- * gtk_sorter_compare() again.
+ * they will emit the #GtkSorter::changed signal to notify that the sort order is
+ * no longer valid and should be updated by calling gtk_sorter_compare() again.
  *
  * GTK provides various pre-made sorter implementations for common sorting operations.
  * #GtkColumnView has built-in support for sorting lists via the #GtkColumnViewColumn:sorter

gtk/gtkstringfilter.c

@@ -27,7 +27,7 @@
 /**
  * SECTION:gtkstringfilter
  * @Title: GtkStringFilter
- * @Short_description: Filtering by string
+ * @Short_description: Filtering by strings
  *
  * GtkStringFilter determines whether to include items by looking
  * at strings and comparing them to a fixed search term. The strings
@@ -302,7 +302,7 @@ gtk_string_filter_init (GtkStringFilter *self)
 }
 
 /**
- * gtk_s tring_filter_new:
+ * gtk_string_filter_new:
  * @expression: (transfer full) (nullable): The expression to evaluate
  *     or %NULL for none
  *

gtk/gtkstringfilter.h

@@ -51,7 +51,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkStringFilter, gtk_string_filter, GTK, STRING_FILTER, GtkFilter)
 
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_string_filter_new                   (GtkExpression          *exporession);
+GtkFilter *             gtk_string_filter_new                   (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 const char *            gtk_string_filter_get_search            (GtkStringFilter        *self);

gtk/gtktext.c

@@ -2681,6 +2681,7 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
     {
       priv->in_click = TRUE;
       gtk_widget_grab_focus (widget);
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
       priv->in_click = FALSE;
     }
 
@@ -2689,6 +2690,7 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
   if (gdk_event_triggers_context_menu (event))
     {
       gtk_text_do_popup (self, widget_x, widget_y);
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
     }
   else if (n_press == 1 && button == GDK_BUTTON_MIDDLE &&
            get_middle_click_paste (self))
@@ -2702,6 +2704,8 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
         {
           gtk_widget_error_bell (widget);
         }
+
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
     }
   else if (button == GDK_BUTTON_PRIMARY)
     {
@@ -2821,13 +2825,9 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
             gtk_text_set_positions (self, end, start);
         }
 
-
       gtk_text_update_handles (self);
     }
 
-  if (button != GDK_BUTTON_PRIMARY || n_press >= 3)
-    gtk_gesture_set_state (priv->drag_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
-
   if (n_press >= 3)
     gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
 }

gtk/gtktreeview.h

@@ -50,11 +50,15 @@ typedef enum
   GTK_TREE_VIEW_DROP_INTO_OR_AFTER
 } GtkTreeViewDropPosition;
 
-#define GTK_TYPE_TREE_VIEW		(gtk_tree_view_get_type ())
-#define GTK_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW, GtkTreeView))
-#define GTK_IS_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW))
+#define GTK_TYPE_TREE_VIEW            (gtk_tree_view_get_type ())
+#define GTK_TREE_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW, GtkTreeView))
+#define GTK_IS_TREE_VIEW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW))
+#define GTK_TREE_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW, GtkTreeViewClass))
+#define GTK_IS_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW))
+#define GTK_TREE_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW, GtkTreeViewClass))
 
 typedef struct _GtkTreeView           GtkTreeView;
+typedef struct _GtkTreeViewClass      GtkTreeViewClass;
 typedef struct _GtkTreeSelection      GtkTreeSelection;
 
 /**
@@ -133,10 +137,59 @@ typedef gboolean (*GtkTreeViewRowSeparatorFunc) (GtkTreeModel      *model,
 						 GtkTreeIter       *iter,
 						 gpointer           data);
 
+struct _GtkTreeView
+{
+  GtkWidget parent_instance;
+};
+
+struct _GtkTreeViewClass
+{
+  GtkWidgetClass parent_class;
+
+  void     (* row_activated)              (GtkTreeView       *tree_view,
+                                           GtkTreePath       *path,
+                                           GtkTreeViewColumn *column);
+  gboolean (* test_expand_row)            (GtkTreeView       *tree_view,
+                                           GtkTreeIter       *iter,
+                                           GtkTreePath       *path);
+  gboolean (* test_collapse_row)          (GtkTreeView       *tree_view,
+                                           GtkTreeIter       *iter,
+                                           GtkTreePath       *path);
+  void     (* row_expanded)               (GtkTreeView       *tree_view,
+                                           GtkTreeIter       *iter,
+                                           GtkTreePath       *path);
+  void     (* row_collapsed)              (GtkTreeView       *tree_view,
+                                           GtkTreeIter       *iter,
+                                           GtkTreePath       *path);
+  void     (* columns_changed)            (GtkTreeView       *tree_view);
+  void     (* cursor_changed)             (GtkTreeView       *tree_view);
+
+  /* Key Binding signals */
+  gboolean (* move_cursor)                (GtkTreeView       *tree_view,
+                                           GtkMovementStep    step,
+                                           gint               count,
+                                           gboolean           extend,
+                                           gboolean           modify);
+  gboolean (* select_all)                 (GtkTreeView       *tree_view);
+  gboolean (* unselect_all)               (GtkTreeView       *tree_view);
+  gboolean (* select_cursor_row)          (GtkTreeView       *tree_view,
+                                           gboolean           start_editing);
+  gboolean (* toggle_cursor_row)          (GtkTreeView       *tree_view);
+  gboolean (* expand_collapse_cursor_row) (GtkTreeView       *tree_view,
+                                           gboolean           logical,
+                                           gboolean           expand,
+                                           gboolean           open_all);
+  gboolean (* select_cursor_parent)       (GtkTreeView       *tree_view);
+  gboolean (* start_interactive_search)   (GtkTreeView       *tree_view);
+
+  /*< private >*/
+  gpointer _reserved[16];
+};
 
-/* Creators */
 GDK_AVAILABLE_IN_ALL
 GType                  gtk_tree_view_get_type                      (void) G_GNUC_CONST;
+
+/* Creators */
 GDK_AVAILABLE_IN_ALL
 GtkWidget             *gtk_tree_view_new                           (void);
 GDK_AVAILABLE_IN_ALL

gtk/gtkwidget.c

@@ -2254,9 +2254,6 @@ gtk_widget_init (GTypeInstance *instance, gpointer g_class)
   priv->alloc_needed_on_child = TRUE;
   priv->draw_needed = TRUE;
   priv->focus_on_click = TRUE;
-#ifdef G_ENABLE_DEBUG
-  priv->highlight_resize = FALSE;
-#endif
   priv->can_focus = TRUE;
   priv->focusable = FALSE;
   priv->can_target = TRUE;
@@ -3811,12 +3808,6 @@ gtk_widget_allocate (GtkWidget    *widget,
     }
 
 #ifdef G_ENABLE_DEBUG
-  if (GTK_DISPLAY_DEBUG_CHECK (_gtk_widget_get_display (widget), RESIZE))
-    {
-      priv->highlight_resize = TRUE;
-      gtk_widget_queue_draw (widget);
-    }
-
   if (gtk_widget_get_resize_needed (widget))
     {
       g_warning ("Allocating size to %s %p without calling gtk_widget_measure(). "
@@ -11356,32 +11347,6 @@ gtk_widget_list_controllers (GtkWidget           *widget,
   return (GtkEventController **)g_ptr_array_free (controllers, FALSE);
 }
 
-static inline void
-gtk_widget_maybe_add_debug_render_nodes (GtkWidget   *widget,
-                                         GtkSnapshot *snapshot)
-{
-#ifdef G_ENABLE_DEBUG
-  GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
-  GdkDisplay *display = _gtk_widget_get_display (widget);
-
-  if (GTK_DISPLAY_DEBUG_CHECK (display, RESIZE) && priv->highlight_resize)
-    {
-      GdkRGBA blue = {0, 0, 1, 0.2};
-      graphene_rect_t bounds;
-
-      graphene_rect_init (&bounds,
-                          0, 0,
-                          priv->width, priv->height);
-
-      gtk_snapshot_append_color (snapshot,
-                                 &blue,
-                                 &bounds);
-      priv->highlight_resize = FALSE;
-      gtk_widget_queue_draw (widget);
-    }
-#endif
-}
-
 static GskRenderNode *
 gtk_widget_create_render_node (GtkWidget   *widget,
                                GtkSnapshot *snapshot)
@@ -11408,9 +11373,8 @@ gtk_widget_create_render_node (GtkWidget   *widget,
                            "RenderNode for %s %p",
                            G_OBJECT_TYPE_NAME (widget), widget);
 
-  filter_value = gtk_css_node_get_style (priv->cssnode)->other->filter;
-  if (filter_value)
-    gtk_css_filter_value_push_snapshot (filter_value, snapshot);
+  filter_value = style->other->filter;
+  gtk_css_filter_value_push_snapshot (filter_value, snapshot);
 
   if (opacity < 1.0)
     gtk_snapshot_push_opacity (snapshot, opacity);
@@ -11436,10 +11400,6 @@ gtk_widget_create_render_node (GtkWidget   *widget,
 
   gtk_css_filter_value_pop_snapshot (filter_value, snapshot);
 
-#ifdef G_ENABLE_DEBUG
-  gtk_widget_maybe_add_debug_render_nodes (widget, snapshot);
-#endif
-
   gtk_snapshot_pop (snapshot);
 
   return gtk_snapshot_pop_collect (snapshot);

gtk/gtkwidgetprivate.h

@@ -66,10 +66,6 @@ struct _GtkWidgetPrivate
 
   guint direction             : 2;
 
-#ifdef G_ENABLE_DEBUG
-  guint highlight_resize      : 1;
-#endif
-
   guint in_destruction        : 1;
   guint realized              : 1;
   guint mapped                : 1;

gtk/inspector/action-editor.c

@@ -24,9 +24,14 @@
 #include "gtktogglebutton.h"
 #include "gtkentry.h"
 #include "gtklabel.h"
+#include "gtkbox.h"
+#include "gtkboxlayout.h"
+#include "gtkorientable.h"
 
-struct _GtkInspectorActionEditorPrivate
+struct _GtkInspectorActionEditor
 {
+  GtkWidget parent;
+
   GActionGroup *group;
   gchar *name;
   gboolean enabled;
@@ -38,6 +43,11 @@ struct _GtkInspectorActionEditorPrivate
   GtkSizeGroup *sg;
 };
 
+typedef struct
+{
+  GtkWidgetClass parent;
+} GtkInspectorActionEditorClass;
+
 enum
 {
   PROP_0,
@@ -46,21 +56,22 @@ enum
   PROP_SIZEGROUP
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorActionEditor, gtk_inspector_action_editor, GTK_TYPE_BOX)
+G_DEFINE_TYPE (GtkInspectorActionEditor, gtk_inspector_action_editor, GTK_TYPE_WIDGET)
 
 static void
 gtk_inspector_action_editor_init (GtkInspectorActionEditor *editor)
 {
-  editor->priv = gtk_inspector_action_editor_get_instance_private (editor);
-  g_object_set (editor,
-                "orientation", GTK_ORIENTATION_HORIZONTAL,
-                "spacing", 10,
-                NULL);
+  GtkBoxLayout *layout;
+
+  layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (editor)));
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_HORIZONTAL);
+  gtk_box_layout_set_spacing (layout, 10);
 }
 
 typedef void (*VariantEditorChanged) (GtkWidget *editor, gpointer data);
 
-typedef struct {
+typedef struct
+{
   GtkWidget *editor;
   VariantEditorChanged callback;
   gpointer   data;
@@ -92,7 +103,7 @@ variant_editor_new (const GVariantType   *type,
     {
       editor = gtk_toggle_button_new_with_label ("FALSE");
       g_signal_connect (editor, "notify::active", G_CALLBACK (variant_editor_changed_cb), d);
-    }   
+    }
   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
     {
       editor = gtk_entry_new ();
@@ -195,9 +206,9 @@ activate_action (GtkWidget                *button,
 {
   GVariant *parameter = NULL;
 
-  if (r->priv->parameter_entry)
-    parameter = variant_editor_get_value (r->priv->parameter_entry);
-  g_action_group_activate_action (r->priv->group, r->priv->name, parameter);
+  if (r->parameter_entry)
+    parameter = variant_editor_get_value (r->parameter_entry);
+  g_action_group_activate_action (r->group, r->name, parameter);
 }
 
 static void
@@ -208,7 +219,7 @@ parameter_changed (GtkWidget *editor,
   GVariant *value;
 
   value = variant_editor_get_value (editor);
-  gtk_widget_set_sensitive (r->priv->activate_button, r->priv->enabled && value != NULL);
+  gtk_widget_set_sensitive (r->activate_button, r->enabled && value != NULL);
   if (value)
     g_variant_unref (value);
 }
@@ -222,21 +233,21 @@ state_changed (GtkWidget *editor,
 
   value = variant_editor_get_value (editor);
   if (value)
-    g_action_group_change_action_state (r->priv->group, r->priv->name, value);
+    g_action_group_change_action_state (r->group, r->name, value);
 }
 
 static void
 update_enabled (GtkInspectorActionEditor *r,
                 gboolean                  enabled)
 {
-  r->priv->enabled = enabled;
-  if (r->priv->parameter_entry)
+  r->enabled = enabled;
+  if (r->parameter_entry)
     {
-      gtk_widget_set_sensitive (r->priv->parameter_entry, enabled);
-      parameter_changed (r->priv->parameter_entry, r);
+      gtk_widget_set_sensitive (r->parameter_entry, enabled);
+      parameter_changed (r->parameter_entry, r);
     }
-  if (r->priv->activate_button)
-    gtk_widget_set_sensitive (r->priv->activate_button, enabled);
+  if (r->activate_button)
+    gtk_widget_set_sensitive (r->activate_button, enabled);
 }
 
 static void
@@ -245,18 +256,16 @@ action_enabled_changed_cb (GActionGroup             *group,
                            gboolean                  enabled,
                            GtkInspectorActionEditor *r)
 {
-  if (!g_str_equal (action_name, r->priv->name))
-    return;
-
-  update_enabled (r, enabled);
+  if (g_str_equal (action_name, r->name))
+    update_enabled (r, enabled);
 }
 
 static void
 update_state (GtkInspectorActionEditor *r,
               GVariant                 *state)
 {
-  if (r->priv->state_entry)
-    variant_editor_set_value (r->priv->state_entry, state);
+  if (r->state_entry)
+    variant_editor_set_value (r->state_entry, state);
 }
 
 static void
@@ -265,10 +274,8 @@ action_state_changed_cb (GActionGroup             *group,
                          GVariant                 *state,
                          GtkInspectorActionEditor *r)
 {
-  if (!g_str_equal (action_name, r->priv->name))
-    return;
-
-  update_state (r, state);
+  if (g_str_equal (action_name, r->name))
+    update_state (r, state);
 }
 
 static void
@@ -280,64 +287,68 @@ constructed (GObject *object)
   GtkWidget *activate;
   GtkWidget *label;
 
-  r->priv->enabled = g_action_group_get_action_enabled (r->priv->group, r->priv->name);
-  state = g_action_group_get_action_state (r->priv->group, r->priv->name);
+  r->enabled = g_action_group_get_action_enabled (r->group, r->name);
+  state = g_action_group_get_action_state (r->group, r->name);
 
   row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
   activate = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
   gtk_box_append (GTK_BOX (row), activate);
-  if (r->priv->sg)
-    gtk_size_group_add_widget (r->priv->sg, activate);
+  if (r->sg)
+    gtk_size_group_add_widget (r->sg, activate);
 
-  r->priv->activate_button = gtk_button_new_with_label (_("Activate"));
-  g_signal_connect (r->priv->activate_button, "clicked", G_CALLBACK (activate_action), r);
+  r->activate_button = gtk_button_new_with_label (_("Activate"));
+  g_signal_connect (r->activate_button, "clicked", G_CALLBACK (activate_action), r);
 
-  gtk_widget_set_sensitive (r->priv->activate_button, r->priv->enabled);
-  gtk_box_append (GTK_BOX (activate), r->priv->activate_button);
+  gtk_widget_set_sensitive (r->activate_button, r->enabled);
+  gtk_box_append (GTK_BOX (activate), r->activate_button);
 
-  r->priv->parameter_type = g_action_group_get_action_parameter_type (r->priv->group, r->priv->name);
-  if (r->priv->parameter_type)
+  r->parameter_type = g_action_group_get_action_parameter_type (r->group, r->name);
+  if (r->parameter_type)
     {
-      r->priv->parameter_entry = variant_editor_new (r->priv->parameter_type, parameter_changed, r);
-      gtk_widget_set_sensitive (r->priv->parameter_entry, r->priv->enabled);
-      gtk_box_append (GTK_BOX (activate), r->priv->parameter_entry);
+      r->parameter_entry = variant_editor_new (r->parameter_type, parameter_changed, r);
+      gtk_widget_set_sensitive (r->parameter_entry, r->enabled);
+      gtk_box_append (GTK_BOX (activate), r->parameter_entry);
     }
 
-  gtk_box_append (GTK_BOX (r), row);
+  gtk_widget_set_parent (row, GTK_WIDGET (r));
 
   if (state)
     {
-      r->priv->state_type = g_variant_type_copy (g_variant_get_type (state));
+      r->state_type = g_variant_type_copy (g_variant_get_type (state));
       row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
       label = gtk_label_new (_("Set State"));
-      if (r->priv->sg)
-        gtk_size_group_add_widget (r->priv->sg, label);
+      if (r->sg)
+        gtk_size_group_add_widget (r->sg, label);
       gtk_box_append (GTK_BOX (row), label);
-      r->priv->state_entry = variant_editor_new (r->priv->state_type, state_changed, r);
-      variant_editor_set_value (r->priv->state_entry, state);
-      gtk_box_append (GTK_BOX (row), r->priv->state_entry);
-      gtk_box_append (GTK_BOX (r), row);
+      r->state_entry = variant_editor_new (r->state_type, state_changed, r);
+      variant_editor_set_value (r->state_entry, state);
+      gtk_box_append (GTK_BOX (row), r->state_entry);
+      gtk_widget_set_parent (row, GTK_WIDGET (r));
     }
 
-  g_signal_connect (r->priv->group, "action-enabled-changed",
+  g_signal_connect (r->group, "action-enabled-changed",
                     G_CALLBACK (action_enabled_changed_cb), r);
-  g_signal_connect (r->priv->group, "action-state-changed",
+  g_signal_connect (r->group, "action-state-changed",
                     G_CALLBACK (action_state_changed_cb), r);
 }
 
 static void
-finalize (GObject *object)
+dispose (GObject *object)
 {
   GtkInspectorActionEditor *r = GTK_INSPECTOR_ACTION_EDITOR (object);
+  GtkWidget *child;
 
-  g_free (r->priv->name);
-  g_clear_object (&r->priv->sg);
-  if (r->priv->state_type)
-    g_variant_type_free (r->priv->state_type);
-  g_signal_handlers_disconnect_by_func (r->priv->group, action_enabled_changed_cb, r);
-  g_signal_handlers_disconnect_by_func (r->priv->group, action_state_changed_cb, r);
+  g_free (r->name);
+  g_clear_object (&r->sg);
+  if (r->state_type)
+    g_variant_type_free (r->state_type);
+  g_signal_handlers_disconnect_by_func (r->group, action_enabled_changed_cb, r);
+  g_signal_handlers_disconnect_by_func (r->group, action_state_changed_cb, r);
 
-  G_OBJECT_CLASS (gtk_inspector_action_editor_parent_class)->finalize (object);
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (r))))
+    gtk_widget_unparent (child);
+
+  G_OBJECT_CLASS (gtk_inspector_action_editor_parent_class)->dispose (object);
 }
 
 static void
@@ -351,15 +362,15 @@ get_property (GObject    *object,
   switch (param_id)
     {
     case PROP_GROUP:
-      g_value_set_object (value, r->priv->group);
+      g_value_set_object (value, r->group);
       break;
 
     case PROP_NAME:
-      g_value_set_string (value, r->priv->name);
+      g_value_set_string (value, r->name);
       break;
 
     case PROP_SIZEGROUP:
-      g_value_set_object (value, r->priv->sg);
+      g_value_set_object (value, r->sg);
       break;
 
     default:
@@ -379,16 +390,16 @@ set_property (GObject      *object,
   switch (param_id)
     {
     case PROP_GROUP:
-      r->priv->group = g_value_get_object (value);
+      r->group = g_value_get_object (value);
       break;
 
     case PROP_NAME:
-      g_free (r->priv->name);
-      r->priv->name = g_value_dup_string (value);
+      g_free (r->name);
+      r->name = g_value_dup_string (value);
       break;
 
     case PROP_SIZEGROUP:
-      r->priv->sg = g_value_dup_object (value);
+      r->sg = g_value_dup_object (value);
       break;
 
     default:
@@ -401,9 +412,10 @@ static void
 gtk_inspector_action_editor_class_init (GtkInspectorActionEditorClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
   object_class->constructed = constructed;
-  object_class->finalize = finalize;
+  object_class->dispose = dispose;
   object_class->get_property = get_property;
   object_class->set_property = set_property;
 
@@ -417,6 +429,8 @@ gtk_inspector_action_editor_class_init (GtkInspectorActionEditorClass *klass)
   g_object_class_install_property (object_class, PROP_SIZEGROUP,
       g_param_spec_object ("sizegroup", "Size Group", "The Size Group for activate", 
                            GTK_TYPE_SIZE_GROUP, G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT);
 }
 
 GtkWidget *

gtk/inspector/action-editor.h

@@ -19,34 +19,19 @@
 #define _GTK_INSPECTOR_ACTION_EDITOR_H_
 
 
-#include <gtk/gtkbox.h>
+#include <gtk/gtkwidget.h>
 #include <gtk/gtksizegroup.h>
 
 
 #define GTK_TYPE_INSPECTOR_ACTION_EDITOR            (gtk_inspector_action_editor_get_type())
 #define GTK_INSPECTOR_ACTION_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditor))
-#define GTK_INSPECTOR_ACTION_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
 #define GTK_INSPECTOR_IS_ACTION_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
-#define GTK_INSPECTOR_IS_ACTION_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
-#define GTK_INSPECTOR_ACTION_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
 
-typedef struct _GtkInspectorActionEditorPrivate GtkInspectorActionEditorPrivate;
-
-typedef struct
-{
-  GtkBox parent;
-  GtkInspectorActionEditorPrivate *priv;
-} GtkInspectorActionEditor;
-
-typedef struct
-{
-  GtkBoxClass parent;
-} GtkInspectorActionEditorClass;
 
+typedef struct _GtkInspectorActionEditor GtkInspectorActionEditor;
 
 G_BEGIN_DECLS
 
-
 GType      gtk_inspector_action_editor_get_type (void);
 GtkWidget *gtk_inspector_action_editor_new      (GActionGroup *group,
                                                  const gchar  *name,

gtk/inspector/actions.c

@@ -34,9 +34,13 @@
 #include "gtklistbox.h"
 #include "gtkstylecontext.h"
 #include "gtksizegroup.h"
+#include "gtkboxlayout.h"
 
-struct _GtkInspectorActionsPrivate
+
+struct _GtkInspectorActions
 {
+  GtkWidget parent;
+
   GtkWidget *list;
   GtkWidget *button;
 
@@ -45,18 +49,27 @@ struct _GtkInspectorActionsPrivate
   GtkColumnViewColumn *name;
 };
 
+typedef struct _GtkInspectorActionsClass
+{
+  GtkWidgetClass parent;
+} GtkInspectorActionsClass;
+
 enum {
   PROP_0,
   PROP_BUTTON
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorActions, gtk_inspector_actions, GTK_TYPE_BOX)
+G_DEFINE_TYPE (GtkInspectorActions, gtk_inspector_actions, GTK_TYPE_WIDGET)
 
 static void
 gtk_inspector_actions_init (GtkInspectorActions *sl)
 {
-  sl->priv = gtk_inspector_actions_get_instance_private (sl);
+ GtkBoxLayout *layout;
+
   gtk_widget_init_template (GTK_WIDGET (sl));
+
+  layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (sl)));
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_VERTICAL);
 }
 
 static void
@@ -65,7 +78,7 @@ action_added_cb (GActionGroup        *group,
                  GtkInspectorActions *sl)
 {
   ActionHolder *holder = action_holder_new (group, action_name);
-  g_list_store_append (G_LIST_STORE (sl->priv->actions), holder);
+  g_list_store_append (G_LIST_STORE (sl->actions), holder);
   g_object_unref (holder);
 }
 
@@ -233,13 +246,13 @@ action_removed_cb (GActionGroup        *group,
 {
   int i;
 
-  for (i = 0; i < g_list_model_get_n_items (sl->priv->actions); i++)
+  for (i = 0; i < g_list_model_get_n_items (sl->actions); i++)
     {
-      ActionHolder *holder = g_list_model_get_item (sl->priv->actions, i);
+      ActionHolder *holder = g_list_model_get_item (sl->actions, i);
 
       if (group == action_holder_get_group (holder) &&
           strcmp (action_name, action_holder_get_name (holder)) == 0)
-        g_list_store_remove (G_LIST_STORE (sl->priv->actions), i);
+        g_list_store_remove (G_LIST_STORE (sl->actions), i);
 
       g_object_unref (holder);
     }
@@ -252,13 +265,13 @@ notify_action_changed (GtkInspectorActions *sl,
 {
   int i;
 
-  for (i = 0; i < g_list_model_get_n_items (sl->priv->actions); i++)
+  for (i = 0; i < g_list_model_get_n_items (sl->actions); i++)
     {
-      ActionHolder *holder = g_list_model_get_item (sl->priv->actions, i);
+      ActionHolder *holder = g_list_model_get_item (sl->actions, i);
 
       if (group == action_holder_get_group (holder) &&
           strcmp (action_name, action_holder_get_name (holder)) == 0)
-        g_list_model_items_changed (sl->priv->actions, i, 1, 1);
+        g_list_model_items_changed (sl->actions, i, 1, 1);
 
       g_object_unref (holder);
     }
@@ -285,8 +298,8 @@ action_state_changed_cb (GActionGroup        *group,
 static void
 refresh_all (GtkInspectorActions *sl)
 {
-  guint n = g_list_model_get_n_items (sl->priv->actions);
-  g_list_model_items_changed (sl->priv->actions, 0, n, n);
+  guint n = g_list_model_get_n_items (sl->actions);
+  g_list_model_items_changed (sl->actions, 0, n, n);
 }
 
 static void
@@ -326,7 +339,7 @@ add_group (GtkInspectorActions *sl,
     action_added_cb (group, names[i], sl);
   g_strfreev (names);
 
-  g_set_object (&sl->priv->group, group);
+  g_set_object (&sl->group, group);
 }
 
 static void
@@ -336,7 +349,7 @@ remove_group (GtkInspectorActions *sl,
 {
   disconnect_group (group, sl);
 
-  g_set_object (&sl->priv->group, NULL);
+  g_set_object (&sl->group, NULL);
 }
 
 void
@@ -351,10 +364,10 @@ gtk_inspector_actions_set_object (GtkInspectorActions *sl,
 
   g_object_set (page, "visible", FALSE, NULL);
 
-  if (sl->priv->group)
-    remove_group (sl, page, sl->priv->group);
+  if (sl->group)
+    remove_group (sl, page, sl->group);
 
-  g_list_store_remove_all (G_LIST_STORE (sl->priv->actions));
+  g_list_store_remove_all (G_LIST_STORE (sl->actions));
 
   if (GTK_IS_APPLICATION (object))
     add_group (sl, page, G_ACTION_GROUP (object));
@@ -367,7 +380,7 @@ gtk_inspector_actions_set_object (GtkInspectorActions *sl,
         add_group (sl, page, G_ACTION_GROUP (muxer));
     }
 
-  gtk_column_view_sort_by_column (GTK_COLUMN_VIEW (sl->priv->list), sl->priv->name, GTK_SORT_ASCENDING);
+  gtk_column_view_sort_by_column (GTK_COLUMN_VIEW (sl->list), sl->name, GTK_SORT_ASCENDING);
 }
 
 static void
@@ -381,7 +394,7 @@ get_property (GObject    *object,
   switch (param_id)
     {
     case PROP_BUTTON:
-      g_value_set_object (value, sl->priv->button);
+      g_value_set_object (value, sl->button);
       break;
 
     default:
@@ -401,7 +414,7 @@ set_property (GObject      *object,
   switch (param_id)
     {
     case PROP_BUTTON:
-      sl->priv->button = g_value_get_object (value);
+      sl->button = g_value_get_object (value);
       break;
 
     default:
@@ -424,7 +437,7 @@ constructed (GObject *object)
   GListModel *sorted;
   GListModel *model;
 
-  g_signal_connect_swapped (sl->priv->button, "clicked",
+  g_signal_connect_swapped (sl->button, "clicked",
                             G_CALLBACK (refresh_all), sl);
 
   sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING,
@@ -432,26 +445,30 @@ constructed (GObject *object)
                                                                0, NULL,
                                                                (GCallback)holder_name,
                                                                NULL, NULL));
-  gtk_column_view_column_set_sorter (sl->priv->name, sorter);
+  gtk_column_view_column_set_sorter (sl->name, sorter);
   g_object_unref (sorter);
   
-  sl->priv->actions = G_LIST_MODEL (g_list_store_new (ACTION_TYPE_HOLDER));
-  sorted = G_LIST_MODEL (gtk_sort_list_model_new (sl->priv->actions,
-                                                  gtk_column_view_get_sorter (GTK_COLUMN_VIEW (sl->priv->list))));
+  sl->actions = G_LIST_MODEL (g_list_store_new (ACTION_TYPE_HOLDER));
+  sorted = G_LIST_MODEL (gtk_sort_list_model_new (sl->actions,
+                                                  gtk_column_view_get_sorter (GTK_COLUMN_VIEW (sl->list))));
   model = G_LIST_MODEL (gtk_no_selection_new (sorted));
-  gtk_column_view_set_model (GTK_COLUMN_VIEW (sl->priv->list), model);
+  gtk_column_view_set_model (GTK_COLUMN_VIEW (sl->list), model);
   g_object_unref (sorted);
   g_object_unref (model);
 }
 
 static void
-finalize (GObject *object)
+dispose (GObject *object)
 {
   GtkInspectorActions *sl = GTK_INSPECTOR_ACTIONS (object);
+  GtkWidget *child;
 
-  g_object_unref (sl->priv->actions);
+  g_clear_object (&sl->actions);
 
-  G_OBJECT_CLASS (gtk_inspector_actions_parent_class)->finalize (object);
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (sl))))
+    gtk_widget_unparent (child);
+
+  G_OBJECT_CLASS (gtk_inspector_actions_parent_class)->dispose (object);
 }
 
 static void
@@ -459,8 +476,8 @@ gtk_inspector_actions_class_init (GtkInspectorActionsClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
-  
-  object_class->finalize = finalize;
+
+  object_class->dispose = dispose;
   object_class->get_property = get_property;
   object_class->set_property = set_property;
   object_class->constructed = constructed;
@@ -470,8 +487,8 @@ gtk_inspector_actions_class_init (GtkInspectorActionsClass *klass)
                            GTK_TYPE_WIDGET, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/actions.ui");
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorActions, list);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorActions, name);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorActions, list);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorActions, name);
   gtk_widget_class_bind_template_callback (widget_class, setup_name_cb);
   gtk_widget_class_bind_template_callback (widget_class, bind_name_cb);
   gtk_widget_class_bind_template_callback (widget_class, setup_enabled_cb);
@@ -482,6 +499,8 @@ gtk_inspector_actions_class_init (GtkInspectorActionsClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, bind_state_cb);
   gtk_widget_class_bind_template_callback (widget_class, bind_changes_cb);
   gtk_widget_class_bind_template_callback (widget_class, unbind_changes_cb);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT);
 }
 
 // vim: set et sw=2 ts=2:

gtk/inspector/actions.h

@@ -18,28 +18,13 @@
 #ifndef _GTK_INSPECTOR_ACTIONS_H_
 #define _GTK_INSPECTOR_ACTIONS_H_
 
-#include <gtk/gtkbox.h>
+#include <gtk/gtkwidget.h>
 
 #define GTK_TYPE_INSPECTOR_ACTIONS            (gtk_inspector_actions_get_type())
 #define GTK_INSPECTOR_ACTIONS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActions))
-#define GTK_INSPECTOR_ACTIONS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
 #define GTK_INSPECTOR_IS_ACTIONS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTIONS))
-#define GTK_INSPECTOR_IS_ACTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTIONS))
-#define GTK_INSPECTOR_ACTIONS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
 
-
-typedef struct _GtkInspectorActionsPrivate GtkInspectorActionsPrivate;
-
-typedef struct _GtkInspectorActions
-{
-  GtkBox parent;
-  GtkInspectorActionsPrivate *priv;
-} GtkInspectorActions;
-
-typedef struct _GtkInspectorActionsClass
-{
-  GtkBoxClass parent;
-} GtkInspectorActionsClass;
+typedef struct _GtkInspectorActions GtkInspectorActions;
 
 G_BEGIN_DECLS
 

gtk/inspector/actions.ui

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface domain="gtk40">
-  <template class="GtkInspectorActions" parent="GtkBox">
-    <property name="orientation">vertical</property>
+  <template class="GtkInspectorActions" parent="GtkWidget">
     <style>
       <class name="view"/>
     </style>

gtk/inspector/general.c

@@ -61,8 +61,10 @@
 #include <vulkan/vulkan.h>
 #endif
 
-struct _GtkInspectorGeneralPrivate
+struct _GtkInspectorGeneral
 {
+  GtkWidget parent;
+
   GtkWidget *swin;
   GtkWidget *box;
   GtkWidget *version_box;
@@ -97,7 +99,12 @@ struct _GtkInspectorGeneralPrivate
   GdkDisplay *display;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorGeneral, gtk_inspector_general, GTK_TYPE_WIDGET)
+typedef struct _GtkInspectorGeneralClass
+{
+  GtkWidgetClass parent_class;
+} GtkInspectorGeneralClass;
+
+G_DEFINE_TYPE (GtkInspectorGeneral, gtk_inspector_general, GTK_TYPE_WIDGET)
 
 static void
 init_version (GtkInspectorGeneral *gen)
@@ -108,33 +115,33 @@ init_version (GtkInspectorGeneral *gen)
   const char *renderer;
 
 #ifdef GDK_WINDOWING_X11
-  if (GDK_IS_X11_DISPLAY (gen->priv->display))
+  if (GDK_IS_X11_DISPLAY (gen->display))
     backend = "X11";
   else
 #endif
 #ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (gen->priv->display))
+  if (GDK_IS_WAYLAND_DISPLAY (gen->display))
     backend = "Wayland";
   else
 #endif
 #ifdef GDK_WINDOWING_BROADWAY
-  if (GDK_IS_BROADWAY_DISPLAY (gen->priv->display))
+  if (GDK_IS_BROADWAY_DISPLAY (gen->display))
     backend = "Broadway";
   else
 #endif
 #ifdef GDK_WINDOWING_WIN32
-  if (GDK_IS_WIN32_DISPLAY (gen->priv->display))
+  if (GDK_IS_WIN32_DISPLAY (gen->display))
     backend = "Windows";
   else
 #endif
 #ifdef GDK_WINDOWING_QUARTZ
-  if (GDK_IS_QUARTZ_DISPLAY (gen->priv->display))
+  if (GDK_IS_QUARTZ_DISPLAY (gen->display))
     backend = "Quartz";
   else
 #endif
     backend = "Unknown";
 
-  surface = gdk_surface_new_toplevel (gen->priv->display, 10, 10);
+  surface = gdk_surface_new_toplevel (gen->display, 10, 10);
   gsk_renderer = gsk_renderer_new_for_surface (surface);
   if (strcmp (G_OBJECT_TYPE_NAME (gsk_renderer), "GskVulkanRenderer") == 0)
     renderer = "Vulkan";
@@ -149,9 +156,9 @@ init_version (GtkInspectorGeneral *gen)
   g_object_unref (gsk_renderer);
   gdk_surface_destroy (surface);
 
-  gtk_label_set_text (GTK_LABEL (gen->priv->gtk_version), GTK_VERSION);
-  gtk_label_set_text (GTK_LABEL (gen->priv->gdk_backend), backend);
-  gtk_label_set_text (GTK_LABEL (gen->priv->gsk_renderer), renderer);
+  gtk_label_set_text (GTK_LABEL (gen->gtk_version), GTK_VERSION);
+  gtk_label_set_text (GTK_LABEL (gen->gdk_backend), backend);
+  gtk_label_set_text (GTK_LABEL (gen->gsk_renderer), renderer);
 }
 
 static G_GNUC_UNUSED void
@@ -191,7 +198,7 @@ add_check_row (GtkInspectorGeneral *gen,
   gtk_widget_set_hexpand (box, FALSE);
   gtk_list_box_insert (list, row, -1);
 
-  gtk_size_group_add_widget (GTK_SIZE_GROUP (gen->priv->labels), label);
+  gtk_size_group_add_widget (GTK_SIZE_GROUP (gen->labels), label);
 }
 
 static void
@@ -234,7 +241,7 @@ add_label_row (GtkInspectorGeneral *gen,
   gtk_widget_set_hexpand (box, FALSE);
   gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
 
-  gtk_size_group_add_widget (GTK_SIZE_GROUP (gen->priv->labels), label);
+  gtk_size_group_add_widget (GTK_SIZE_GROUP (gen->labels), label);
 }
 
 #ifdef GDK_WINDOWING_X11
@@ -243,7 +250,7 @@ append_glx_extension_row (GtkInspectorGeneral *gen,
                           Display             *dpy,
                           const gchar         *ext)
 {
-  add_check_row (gen, GTK_LIST_BOX (gen->priv->gl_box), ext, epoxy_has_glx_extension (dpy, 0, ext), 0);
+  add_check_row (gen, GTK_LIST_BOX (gen->gl_box), ext, epoxy_has_glx_extension (dpy, 0, ext), 0);
 }
 #endif
 
@@ -253,7 +260,7 @@ append_egl_extension_row (GtkInspectorGeneral *gen,
                           EGLDisplay          dpy,
                           const gchar         *ext)
 {
-  add_check_row (gen, GTK_LIST_BOX (gen->priv->gl_box), ext, epoxy_has_egl_extension (dpy, ext), 0);
+  add_check_row (gen, GTK_LIST_BOX (gen->gl_box), ext, epoxy_has_egl_extension (dpy, ext), 0);
 }
 
 static EGLDisplay
@@ -296,18 +303,18 @@ static void
 init_gl (GtkInspectorGeneral *gen)
 {
 #ifdef GDK_WINDOWING_X11
-  if (GDK_IS_X11_DISPLAY (gen->priv->display))
+  if (GDK_IS_X11_DISPLAY (gen->display))
     {
-      Display *dpy = GDK_DISPLAY_XDISPLAY (gen->priv->display);
+      Display *dpy = GDK_DISPLAY_XDISPLAY (gen->display);
       int error_base, event_base;
       gchar *version;
       if (!glXQueryExtension (dpy, &error_base, &event_base))
         return;
 
       version = g_strconcat ("GLX ", glXGetClientString (dpy, GLX_VERSION), NULL);
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_version), version);
+      gtk_label_set_text (GTK_LABEL (gen->gl_version), version);
       g_free (version);
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_vendor), glXGetClientString (dpy, GLX_VENDOR));
+      gtk_label_set_text (GTK_LABEL (gen->gl_vendor), glXGetClientString (dpy, GLX_VENDOR));
 
       append_glx_extension_row (gen, dpy, "GLX_ARB_create_context_profile");
       append_glx_extension_row (gen, dpy, "GLX_SGI_swap_control");
@@ -321,21 +328,21 @@ init_gl (GtkInspectorGeneral *gen)
   else
 #endif
 #ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (gen->priv->display))
+  if (GDK_IS_WAYLAND_DISPLAY (gen->display))
     {
       EGLDisplay dpy;
       EGLint major, minor;
       gchar *version;
 
-      dpy = wayland_get_display (gdk_wayland_display_get_wl_display (gen->priv->display));
+      dpy = wayland_get_display (gdk_wayland_display_get_wl_display (gen->display));
 
       if (!eglInitialize (dpy, &major, &minor))
         return;
 
       version = g_strconcat ("EGL ", eglQueryString (dpy, EGL_VERSION), NULL);
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_version), version);
+      gtk_label_set_text (GTK_LABEL (gen->gl_version), version);
       g_free (version);
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_vendor), eglQueryString (dpy, EGL_VENDOR));
+      gtk_label_set_text (GTK_LABEL (gen->gl_vendor), eglQueryString (dpy, EGL_VENDOR));
 
       append_egl_extension_row (gen, dpy, "EGL_KHR_create_context");
       append_egl_extension_row (gen, dpy, "EGL_EXT_buffer_age");
@@ -345,8 +352,8 @@ init_gl (GtkInspectorGeneral *gen)
   else
 #endif
     {
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_version), C_("GL version", "None"));
-      gtk_label_set_text (GTK_LABEL (gen->priv->gl_vendor), C_("GL vendor", "None"));
+      gtk_label_set_text (GTK_LABEL (gen->gl_version), C_("GL version", "None"));
+      gtk_label_set_text (GTK_LABEL (gen->gl_vendor), C_("GL vendor", "None"));
     }
 }
 
@@ -395,7 +402,7 @@ init_vulkan (GtkInspectorGeneral *gen)
   GdkSurface *surface;
   GdkVulkanContext *context;
 
-  surface = gdk_surface_new_toplevel (gen->priv->display, 10, 10);
+  surface = gdk_surface_new_toplevel (gen->display, 10, 10);
   context = gdk_surface_create_vulkan_context (surface, NULL);
   gdk_surface_destroy (surface);
 
@@ -420,26 +427,26 @@ init_vulkan (GtkInspectorGeneral *gen)
                                         VK_VERSION_MINOR (props.driverVersion),
                                         VK_VERSION_PATCH (props.driverVersion));
 
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_device), device_name);
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_api_version), api_version);
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_driver_version), driver_version);
+      gtk_label_set_text (GTK_LABEL (gen->vk_device), device_name);
+      gtk_label_set_text (GTK_LABEL (gen->vk_api_version), api_version);
+      gtk_label_set_text (GTK_LABEL (gen->vk_driver_version), driver_version);
 
       g_free (device_name);
       g_free (api_version);
       g_free (driver_version);
 
-      add_check_row (gen, GTK_LIST_BOX (gen->priv->vulkan_box), VK_KHR_SURFACE_EXTENSION_NAME, TRUE, 0);
+      add_check_row (gen, GTK_LIST_BOX (gen->vulkan_box), VK_KHR_SURFACE_EXTENSION_NAME, TRUE, 0);
 #ifdef GDK_WINDOWING_X11
-      if (GDK_IS_X11_DISPLAY (gen->priv->display))
-        add_check_row (gen, GTK_LIST_BOX (gen->priv->vulkan_box), "VK_KHR_xlib_surface", TRUE, 0);
+      if (GDK_IS_X11_DISPLAY (gen->display))
+        add_check_row (gen, GTK_LIST_BOX (gen->vulkan_box), "VK_KHR_xlib_surface", TRUE, 0);
 #endif
 #ifdef GDK_WINDOWING_WAYLAND
-      if (GDK_IS_WAYLAND_DISPLAY (gen->priv->display))
-        add_check_row (gen, GTK_LIST_BOX (gen->priv->vulkan_box), "VK_KHR_wayland_surface", TRUE, 0);
+      if (GDK_IS_WAYLAND_DISPLAY (gen->display))
+        add_check_row (gen, GTK_LIST_BOX (gen->vulkan_box), "VK_KHR_wayland_surface", TRUE, 0);
 #endif
-      add_check_row (gen, GTK_LIST_BOX (gen->priv->vulkan_box), VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+      add_check_row (gen, GTK_LIST_BOX (gen->vulkan_box), VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
                      has_debug_extension (context), 0);
-      add_check_row (gen, GTK_LIST_BOX (gen->priv->vulkan_box), "VK_LAYER_LUNARG_standard_validation",
+      add_check_row (gen, GTK_LIST_BOX (gen->vulkan_box), "VK_LAYER_LUNARG_standard_validation",
                      has_validation_layer (context), 0);
 
       g_object_unref (context);
@@ -447,9 +454,9 @@ init_vulkan (GtkInspectorGeneral *gen)
   else
 #endif
     {
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_device), C_("Vulkan device", "None"));
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_api_version), C_("Vulkan version", "None"));
-      gtk_label_set_text (GTK_LABEL (gen->priv->vk_driver_version), C_("Vulkan version", "None"));
+      gtk_label_set_text (GTK_LABEL (gen->vk_device), C_("Vulkan device", "None"));
+      gtk_label_set_text (GTK_LABEL (gen->vk_api_version), C_("Vulkan version", "None"));
+      gtk_label_set_text (GTK_LABEL (gen->vk_driver_version), C_("Vulkan version", "None"));
     }
 }
 
@@ -488,14 +495,14 @@ set_path_label (GtkWidget   *w,
 static void
 init_env (GtkInspectorGeneral *gen)
 {
-  set_monospace_font (gen->priv->prefix);
-  gtk_label_set_text (GTK_LABEL (gen->priv->prefix), _gtk_get_data_prefix ());
-  set_path_label (gen->priv->xdg_data_home, "XDG_DATA_HOME");
-  set_path_label (gen->priv->xdg_data_dirs, "XDG_DATA_DIRS");
-  set_path_label (gen->priv->gtk_path, "GTK_PATH");
-  set_path_label (gen->priv->gtk_exe_prefix, "GTK_EXE_PREFIX");
-  set_path_label (gen->priv->gtk_data_prefix, "GTK_DATA_PREFIX");
-  set_path_label (gen->priv->gsettings_schema_dir, "GSETTINGS_SCHEMA_DIR");
+  set_monospace_font (gen->prefix);
+  gtk_label_set_text (GTK_LABEL (gen->prefix), _gtk_get_data_prefix ());
+  set_path_label (gen->xdg_data_home, "XDG_DATA_HOME");
+  set_path_label (gen->xdg_data_dirs, "XDG_DATA_DIRS");
+  set_path_label (gen->gtk_path, "GTK_PATH");
+  set_path_label (gen->gtk_exe_prefix, "GTK_EXE_PREFIX");
+  set_path_label (gen->gtk_data_prefix, "GTK_DATA_PREFIX");
+  set_path_label (gen->gsettings_schema_dir, "GSETTINGS_SCHEMA_DIR");
 }
 
 static const char *
@@ -520,8 +527,8 @@ populate_display (GdkDisplay *display, GtkInspectorGeneral *gen)
   GtkWidget *child;
   GtkListBox *list;
 
-  gtk_widget_show (gen->priv->display_composited);
-  list = GTK_LIST_BOX (gen->priv->display_box);
+  gtk_widget_show (gen->display_composited);
+  list = GTK_LIST_BOX (gen->display_box);
   children = NULL;
   for (child = gtk_widget_get_first_child (GTK_WIDGET (list));
        child != NULL;
@@ -533,20 +540,20 @@ populate_display (GdkDisplay *display, GtkInspectorGeneral *gen)
   for (l = children; l; l = l->next)
     {
       child = l->data;
-      if (gtk_widget_is_ancestor (gen->priv->display_name, child) ||
-          gtk_widget_is_ancestor (gen->priv->display_rgba, child) ||
-          gtk_widget_is_ancestor (gen->priv->display_composited, child))
+      if (gtk_widget_is_ancestor (gen->display_name, child) ||
+          gtk_widget_is_ancestor (gen->display_rgba, child) ||
+          gtk_widget_is_ancestor (gen->display_composited, child))
         continue;
 
       gtk_list_box_remove (list, child);
     }
   g_list_free (children);
 
-  gtk_label_set_label (GTK_LABEL (gen->priv->display_name), gdk_display_get_name (display));
+  gtk_label_set_label (GTK_LABEL (gen->display_name), gdk_display_get_name (display));
 
-  gtk_widget_set_visible (gen->priv->display_rgba,
+  gtk_widget_set_visible (gen->display_rgba,
                           gdk_display_is_rgba (display));
-  gtk_widget_set_visible (gen->priv->display_composited,
+  gtk_widget_set_visible (gen->display_composited,
                           gdk_display_is_composited (display));
 }
 
@@ -624,13 +631,13 @@ populate_display_notify_cb (GdkDisplay          *display,
 static void
 init_display (GtkInspectorGeneral *gen)
 {
-  g_signal_connect (gen->priv->display, "notify", G_CALLBACK (populate_display_notify_cb), gen);
-  gtk_list_box_bind_model (GTK_LIST_BOX (gen->priv->monitor_box),
-                           gdk_display_get_monitors (gen->priv->display),
+  g_signal_connect (gen->display, "notify", G_CALLBACK (populate_display_notify_cb), gen);
+  gtk_list_box_bind_model (GTK_LIST_BOX (gen->monitor_box),
+                           gdk_display_get_monitors (gen->display),
                            populate_monitor,
                            gen, NULL);
 
-  populate_display (gen->priv->display, gen);
+  populate_display (gen->display, gen);
 }
 
 static void
@@ -651,7 +658,7 @@ init_pango (GtkInspectorGeneral *gen)
   else
     name = type;
 
-  gtk_label_set_label (GTK_LABEL (gen->priv->pango_fontmap), name);
+  gtk_label_set_label (GTK_LABEL (gen->pango_fontmap), name);
 }
 
 static void
@@ -662,7 +669,7 @@ init_media (GtkInspectorGeneral *gen)
 
   e = gtk_media_file_get_extension ();
   name = g_io_extension_get_name (e);
-  gtk_label_set_label (GTK_LABEL (gen->priv->media_backend), name);
+  gtk_label_set_label (GTK_LABEL (gen->media_backend), name);
 }
 
 static void populate_seats (GtkInspectorGeneral *gen);
@@ -704,7 +711,7 @@ add_device (GtkInspectorGeneral *gen,
 
   name = gdk_device_get_name (device);
   value = source_name[gdk_device_get_source (device)];
-  add_label_row (gen, GTK_LIST_BOX (gen->priv->device_box), name, value, 10);
+  add_label_row (gen, GTK_LIST_BOX (gen->device_box), name, value, 10);
 
   str = g_string_new ("");
 
@@ -720,7 +727,7 @@ add_device (GtkInspectorGeneral *gen,
     }
 
   if (str->len > 0)
-    add_label_row (gen, GTK_LIST_BOX (gen->priv->device_box), "Axes", str->str, 20);
+    add_label_row (gen, GTK_LIST_BOX (gen->device_box), "Axes", str->str, 20);
 
   g_string_free (str, TRUE);
 
@@ -728,7 +735,7 @@ add_device (GtkInspectorGeneral *gen,
   if (n_touches > 0)
     {
       text = g_strdup_printf ("%d", n_touches);
-      add_label_row (gen, GTK_LIST_BOX (gen->priv->device_box), "Touches", text, 20);
+      add_label_row (gen, GTK_LIST_BOX (gen->device_box), "Touches", text, 20);
       g_free (text);
     }
 }
@@ -784,7 +791,7 @@ add_seat (GtkInspectorGeneral *gen,
   text = g_strdup_printf ("Seat %d", num);
   caps = get_seat_capabilities (seat);
 
-  add_label_row (gen, GTK_LIST_BOX (gen->priv->device_box), text, caps, 0);
+  add_label_row (gen, GTK_LIST_BOX (gen->device_box), text, caps, 0);
   g_free (text);
   g_free (caps);
 
@@ -803,10 +810,10 @@ populate_seats (GtkInspectorGeneral *gen)
   GList *list, *l;
   int i;
 
-  while ((child = gtk_widget_get_first_child (gen->priv->device_box)))
-    gtk_list_box_remove (GTK_LIST_BOX (gen->priv->device_box), child);
+  while ((child = gtk_widget_get_first_child (gen->device_box)))
+    gtk_list_box_remove (GTK_LIST_BOX (gen->device_box), child);
 
-  list = gdk_display_list_seats (gen->priv->display);
+  list = gdk_display_list_seats (gen->display);
 
   for (l = list, i = 0; l; l = l->next, i++)
     add_seat (gen, GDK_SEAT (l->data), i);
@@ -817,8 +824,8 @@ populate_seats (GtkInspectorGeneral *gen)
 static void
 init_device (GtkInspectorGeneral *gen)
 {
-  g_signal_connect_swapped (gen->priv->display, "seat-added", G_CALLBACK (populate_seats), gen);
-  g_signal_connect_swapped (gen->priv->display, "seat-removed", G_CALLBACK (populate_seats), gen);
+  g_signal_connect_swapped (gen->display, "seat-added", G_CALLBACK (populate_seats), gen);
+  g_signal_connect_swapped (gen->display, "seat-removed", G_CALLBACK (populate_seats), gen);
 
   populate_seats (gen);
 }
@@ -826,7 +833,6 @@ init_device (GtkInspectorGeneral *gen)
 static void
 gtk_inspector_general_init (GtkInspectorGeneral *gen)
 {
-  gen->priv = gtk_inspector_general_get_instance_private (gen);
   gtk_widget_init_template (GTK_WIDGET (gen));
 }
 
@@ -835,30 +841,30 @@ keynav_failed (GtkWidget *widget, GtkDirectionType direction, GtkInspectorGenera
 {
   GtkWidget *next;
 
-  if (direction == GTK_DIR_DOWN && widget == gen->priv->version_box)
-    next = gen->priv->env_box;
-  else if (direction == GTK_DIR_DOWN && widget == gen->priv->env_box)
-    next = gen->priv->display_box;
-  else if (direction == GTK_DIR_DOWN && widget == gen->priv->display_box)
-    next = gen->priv->monitor_box;
-  else if (direction == GTK_DIR_DOWN && widget == gen->priv->monitor_box)
-    next = gen->priv->gl_box;
-  else if (direction == GTK_DIR_DOWN && widget == gen->priv->gl_box)
-    next = gen->priv->vulkan_box;
-  else if (direction == GTK_DIR_DOWN && widget == gen->priv->vulkan_box)
-    next = gen->priv->device_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->device_box)
-    next = gen->priv->vulkan_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->vulkan_box)
-    next = gen->priv->gl_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->gl_box)
-    next = gen->priv->monitor_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->monitor_box)
-    next = gen->priv->display_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->display_box)
-    next = gen->priv->env_box;
-  else if (direction == GTK_DIR_UP && widget == gen->priv->env_box)
-    next = gen->priv->version_box;
+  if (direction == GTK_DIR_DOWN && widget == gen->version_box)
+    next = gen->env_box;
+  else if (direction == GTK_DIR_DOWN && widget == gen->env_box)
+    next = gen->display_box;
+  else if (direction == GTK_DIR_DOWN && widget == gen->display_box)
+    next = gen->monitor_box;
+  else if (direction == GTK_DIR_DOWN && widget == gen->monitor_box)
+    next = gen->gl_box;
+  else if (direction == GTK_DIR_DOWN && widget == gen->gl_box)
+    next = gen->vulkan_box;
+  else if (direction == GTK_DIR_DOWN && widget == gen->vulkan_box)
+    next = gen->device_box;
+  else if (direction == GTK_DIR_UP && widget == gen->device_box)
+    next = gen->vulkan_box;
+  else if (direction == GTK_DIR_UP && widget == gen->vulkan_box)
+    next = gen->gl_box;
+  else if (direction == GTK_DIR_UP && widget == gen->gl_box)
+    next = gen->monitor_box;
+  else if (direction == GTK_DIR_UP && widget == gen->monitor_box)
+    next = gen->display_box;
+  else if (direction == GTK_DIR_UP && widget == gen->display_box)
+    next = gen->env_box;
+  else if (direction == GTK_DIR_UP && widget == gen->env_box)
+    next = gen->version_box;
   else
     next = NULL;
 
@@ -878,13 +884,13 @@ gtk_inspector_general_constructed (GObject *object)
 
   G_OBJECT_CLASS (gtk_inspector_general_parent_class)->constructed (object);
 
-   g_signal_connect (gen->priv->version_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->env_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->display_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->monitor_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->gl_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->vulkan_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
-   g_signal_connect (gen->priv->device_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->version_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->env_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->display_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->monitor_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->gl_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->vulkan_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
+   g_signal_connect (gen->device_box, "keynav-failed", G_CALLBACK (keynav_failed), gen);
 }
 
 static void
@@ -892,7 +898,7 @@ gtk_inspector_general_dispose (GObject *object)
 {
   GtkInspectorGeneral *gen = GTK_INSPECTOR_GENERAL (object);
 
-  g_clear_pointer (&gen->priv->swin, gtk_widget_unparent);
+  g_clear_pointer (&gen->swin, gtk_widget_unparent);
 
   G_OBJECT_CLASS (gtk_inspector_general_parent_class)->dispose (object);
 }
@@ -907,36 +913,36 @@ gtk_inspector_general_class_init (GtkInspectorGeneralClass *klass)
   object_class->dispose = gtk_inspector_general_dispose;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/general.ui");
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, swin);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, version_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, env_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, display_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, monitor_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gl_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, vulkan_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gtk_version);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gdk_backend);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gsk_renderer);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, pango_fontmap);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, media_backend);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gl_version);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gl_vendor);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, vk_device);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, vk_api_version);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, vk_driver_version);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, prefix);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, xdg_data_home);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, xdg_data_dirs);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gtk_path);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gtk_exe_prefix);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gtk_data_prefix);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, gsettings_schema_dir);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, labels);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, display_name);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, display_composited);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, display_rgba);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorGeneral, device_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, swin);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, version_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, env_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, display_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, monitor_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gl_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, vulkan_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gtk_version);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gdk_backend);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gsk_renderer);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, pango_fontmap);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, media_backend);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gl_version);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gl_vendor);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, vk_device);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, vk_api_version);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, vk_driver_version);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, prefix);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, xdg_data_home);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, xdg_data_dirs);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gtk_path);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gtk_exe_prefix);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gtk_data_prefix);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, gsettings_schema_dir);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, labels);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, display_name);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, display_composited);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, display_rgba);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorGeneral, device_box);
 
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
 }
@@ -945,7 +951,7 @@ void
 gtk_inspector_general_set_display (GtkInspectorGeneral *gen,
                                    GdkDisplay *display)
 {
-  gen->priv->display = display;
+  gen->display = display;
 
   init_version (gen);
   init_env (gen);

gtk/inspector/general.h

@@ -18,29 +18,13 @@
 #ifndef _GTK_INSPECTOR_GENERAL_H_
 #define _GTK_INSPECTOR_GENERAL_H_
 
-#include <gtk/gtkscrolledwindow.h>
+#include <gtk/gtkwidget.h>
 
 #define GTK_TYPE_INSPECTOR_GENERAL            (gtk_inspector_general_get_type())
 #define GTK_INSPECTOR_GENERAL(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneral))
-#define GTK_INSPECTOR_GENERAL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneralClass))
 #define GTK_INSPECTOR_IS_GENERAL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_GENERAL))
-#define GTK_INSPECTOR_IS_GENERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_GENERAL))
-#define GTK_INSPECTOR_GENERAL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneralClass))
 
-
-typedef struct _GtkInspectorGeneralPrivate GtkInspectorGeneralPrivate;
-
-typedef struct _GtkInspectorGeneral
-{
-  GtkWidget parent;
-
-  GtkInspectorGeneralPrivate *priv;
-} GtkInspectorGeneral;
-
-typedef struct _GtkInspectorGeneralClass
-{
-  GtkWidgetClass parent_class;
-} GtkInspectorGeneralClass;
+typedef struct _GtkInspectorGeneral GtkInspectorGeneral;
 
 G_BEGIN_DECLS
 

gtk/inspector/list-data.c

@@ -187,13 +187,15 @@ unbind_props (GtkSignalListItemFactory *factory,
 }
 
 static void
-finalize (GObject *object)
+dispose (GObject *object)
 {
   GtkInspectorListData *sl = GTK_INSPECTOR_LIST_DATA (object);
+  GtkWidget *child;
 
-  gtk_inspector_list_data_set_object (sl, NULL);
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (sl))))
+    gtk_widget_unparent (child);
 
-  G_OBJECT_CLASS (gtk_inspector_list_data_parent_class)->finalize (object);
+  G_OBJECT_CLASS (gtk_inspector_list_data_parent_class)->dispose (object);
 }
 
 static void
@@ -202,7 +204,7 @@ gtk_inspector_list_data_class_init (GtkInspectorListDataClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
-  object_class->finalize = finalize;
+  object_class->dispose = dispose;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/list-data.ui");
   gtk_widget_class_bind_template_child (widget_class, GtkInspectorListData, view);

gtk/inspector/logs.c

@@ -40,10 +40,13 @@
 #include "gtknative.h"
 #include "gskdebugprivate.h"
 #include "gskrendererprivate.h"
+#include "gtkboxlayout.h"
 
 
-struct _GtkInspectorLogsPrivate
+struct _GtkInspectorLogs
 {
+  GtkWidget parent;
+
   GtkWidget *events;
   GtkWidget *misc;
   GtkWidget *dnd;
@@ -77,21 +80,28 @@ struct _GtkInspectorLogsPrivate
   GdkDisplay *display;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorLogs, gtk_inspector_logs, GTK_TYPE_BOX)
+typedef struct _GtkInspectorLogsClass
+{
+  GtkWidgetClass parent;
+} GtkInspectorLogsClass;
+
+G_DEFINE_TYPE (GtkInspectorLogs, gtk_inspector_logs, GTK_TYPE_WIDGET)
 
 static void
 gtk_inspector_logs_init (GtkInspectorLogs *logs)
 {
-  logs->priv = gtk_inspector_logs_get_instance_private (logs);
   gtk_widget_init_template (GTK_WIDGET (logs));
 }
 
 static void
-finalize (GObject *object)
+dispose (GObject *object)
 {
-  //GtkInspectorLogs *logs = GTK_INSPECTOR_LOGS (object);
+  GtkWidget *child;
 
-  G_OBJECT_CLASS (gtk_inspector_logs_parent_class)->finalize (object);
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (object))))
+    gtk_widget_unparent (child);
+
+  G_OBJECT_CLASS (gtk_inspector_logs_parent_class)->dispose (object);
 }
 
 static void
@@ -112,28 +122,28 @@ flag_toggled (GtkWidget        *button,
   guint flags;
   GList *toplevels, *l;
 
-  flags = gdk_display_get_debug_flags (logs->priv->display);
-  update_flag (logs->priv->events, &flags, GDK_DEBUG_EVENTS);
-  update_flag (logs->priv->misc, &flags, GDK_DEBUG_MISC);
-  update_flag (logs->priv->dnd, &flags, GDK_DEBUG_DND);
-  update_flag (logs->priv->input, &flags, GDK_DEBUG_INPUT);
-  update_flag (logs->priv->eventloop, &flags, GDK_DEBUG_EVENTLOOP);
-  update_flag (logs->priv->frames, &flags, GDK_DEBUG_FRAMES);
-  update_flag (logs->priv->settings, &flags, GDK_DEBUG_SETTINGS);
-  update_flag (logs->priv->opengl, &flags, GDK_DEBUG_OPENGL);
-  update_flag (logs->priv->vulkan, &flags, GDK_DEBUG_VULKAN);
-  update_flag (logs->priv->selection, &flags, GDK_DEBUG_SELECTION);
-  update_flag (logs->priv->clipboard, &flags, GDK_DEBUG_CLIPBOARD);
-  gdk_display_set_debug_flags (logs->priv->display, flags);
+  flags = gdk_display_get_debug_flags (logs->display);
+  update_flag (logs->events, &flags, GDK_DEBUG_EVENTS);
+  update_flag (logs->misc, &flags, GDK_DEBUG_MISC);
+  update_flag (logs->dnd, &flags, GDK_DEBUG_DND);
+  update_flag (logs->input, &flags, GDK_DEBUG_INPUT);
+  update_flag (logs->eventloop, &flags, GDK_DEBUG_EVENTLOOP);
+  update_flag (logs->frames, &flags, GDK_DEBUG_FRAMES);
+  update_flag (logs->settings, &flags, GDK_DEBUG_SETTINGS);
+  update_flag (logs->opengl, &flags, GDK_DEBUG_OPENGL);
+  update_flag (logs->vulkan, &flags, GDK_DEBUG_VULKAN);
+  update_flag (logs->selection, &flags, GDK_DEBUG_SELECTION);
+  update_flag (logs->clipboard, &flags, GDK_DEBUG_CLIPBOARD);
+  gdk_display_set_debug_flags (logs->display, flags);
 
   flags = gsk_get_debug_flags ();
-  update_flag (logs->priv->renderer, &flags, GSK_DEBUG_RENDERER);
-  update_flag (logs->priv->cairo, &flags, GSK_DEBUG_CAIRO);
-  update_flag (logs->priv->opengl_gsk, &flags, GSK_DEBUG_OPENGL);
-  update_flag (logs->priv->vulkan_gsk, &flags, GSK_DEBUG_VULKAN);
-  update_flag (logs->priv->shaders, &flags, GSK_DEBUG_SHADERS);
-  update_flag (logs->priv->surface, &flags, GSK_DEBUG_SURFACE);
-  update_flag (logs->priv->glyphcache, &flags, GSK_DEBUG_GLYPH_CACHE);
+  update_flag (logs->renderer, &flags, GSK_DEBUG_RENDERER);
+  update_flag (logs->cairo, &flags, GSK_DEBUG_CAIRO);
+  update_flag (logs->opengl_gsk, &flags, GSK_DEBUG_OPENGL);
+  update_flag (logs->vulkan_gsk, &flags, GSK_DEBUG_VULKAN);
+  update_flag (logs->shaders, &flags, GSK_DEBUG_SHADERS);
+  update_flag (logs->surface, &flags, GSK_DEBUG_SURFACE);
+  update_flag (logs->glyphcache, &flags, GSK_DEBUG_GLYPH_CACHE);
   gsk_set_debug_flags (flags);
 
   toplevels = gtk_window_list_toplevels ();
@@ -141,7 +151,7 @@ flag_toggled (GtkWidget        *button,
     {
       GtkWidget *toplevel = l->data;
 
-      if (gtk_root_get_display (GTK_ROOT (toplevel)) == logs->priv->display)
+      if (gtk_root_get_display (GTK_ROOT (toplevel)) == logs->display)
         {
           GskRenderer *renderer = gtk_native_get_renderer (GTK_NATIVE (toplevel));
           if (renderer)
@@ -150,17 +160,17 @@ flag_toggled (GtkWidget        *button,
     }
   g_list_free (toplevels);
 
-  flags = gtk_get_display_debug_flags (logs->priv->display);
-  update_flag (logs->priv->actions, &flags, GTK_DEBUG_ACTIONS);
-  update_flag (logs->priv->builder, &flags, GTK_DEBUG_BUILDER);
-  update_flag (logs->priv->sizes, &flags, GTK_DEBUG_SIZE_REQUEST);
-  update_flag (logs->priv->icons, &flags, GTK_DEBUG_ICONTHEME);
-  update_flag (logs->priv->keybindings, &flags, GTK_DEBUG_KEYBINDINGS);
-  update_flag (logs->priv->modules, &flags, GTK_DEBUG_MODULES);
-  update_flag (logs->priv->printing, &flags, GTK_DEBUG_PRINTING);
-  update_flag (logs->priv->tree, &flags, GTK_DEBUG_TREE);
-  update_flag (logs->priv->text, &flags, GTK_DEBUG_TEXT);
-  gtk_set_display_debug_flags (logs->priv->display, flags);
+  flags = gtk_get_display_debug_flags (logs->display);
+  update_flag (logs->actions, &flags, GTK_DEBUG_ACTIONS);
+  update_flag (logs->builder, &flags, GTK_DEBUG_BUILDER);
+  update_flag (logs->sizes, &flags, GTK_DEBUG_SIZE_REQUEST);
+  update_flag (logs->icons, &flags, GTK_DEBUG_ICONTHEME);
+  update_flag (logs->keybindings, &flags, GTK_DEBUG_KEYBINDINGS);
+  update_flag (logs->modules, &flags, GTK_DEBUG_MODULES);
+  update_flag (logs->printing, &flags, GTK_DEBUG_PRINTING);
+  update_flag (logs->tree, &flags, GTK_DEBUG_TREE);
+  update_flag (logs->text, &flags, GTK_DEBUG_TEXT);
+  gtk_set_display_debug_flags (logs->display, flags);
 }
 
 static void
@@ -169,46 +179,48 @@ gtk_inspector_logs_class_init (GtkInspectorLogsClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
-  object_class->finalize = finalize;
+  object_class->dispose = dispose;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/logs.ui");
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, events);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, misc);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, dnd);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, input);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, eventloop);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, frames);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, settings);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, opengl);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, vulkan);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, selection);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, clipboard);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, events);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, misc);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, dnd);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, input);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, eventloop);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, frames);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, settings);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, opengl);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, vulkan);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, selection);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, clipboard);
 
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, renderer);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, cairo);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, opengl_gsk);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, vulkan_gsk);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, shaders);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, surface);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, glyphcache);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, renderer);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, cairo);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, opengl_gsk);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, vulkan_gsk);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, shaders);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, surface);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, glyphcache);
 
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, actions);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, builder);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, sizes);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, icons);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, keybindings);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, modules);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, printing);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, tree);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorLogs, text);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, actions);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, builder);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, sizes);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, icons);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, keybindings);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, modules);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, printing);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, tree);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorLogs, text);
   gtk_widget_class_bind_template_callback (widget_class, flag_toggled);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT);
 }
 
 void
 gtk_inspector_logs_set_display (GtkInspectorLogs *logs,
                                 GdkDisplay *display)
 {
-  logs->priv->display = display;
+  logs->display = display;
 }
 
 // vim: set et sw=2 ts=2:

gtk/inspector/logs.h

@@ -23,28 +23,14 @@
 #ifndef _GTK_INSPECTOR_LOGS_H_
 #define _GTK_INSPECTOR_LOGS_H_
 
-#include <gtk/gtkbox.h>
+#include <gtk/gtkwidget.h>
 
 #define GTK_TYPE_INSPECTOR_LOGS            (gtk_inspector_logs_get_type())
 #define GTK_INSPECTOR_LOGS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogs))
-#define GTK_INSPECTOR_LOGS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogsClass))
 #define GTK_INSPECTOR_IS_LOGS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_LOGS))
-#define GTK_INSPECTOR_IS_LOGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_LOGS))
-#define GTK_INSPECTOR_LOGS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogsClass))
 
 
-typedef struct _GtkInspectorLogsPrivate GtkInspectorLogsPrivate;
-
-typedef struct _GtkInspectorLogs
-{
-  GtkBox parent;
-  GtkInspectorLogsPrivate *priv;
-} GtkInspectorLogs;
-
-typedef struct _GtkInspectorLogsClass
-{
-  GtkBoxClass parent;
-} GtkInspectorLogsClass;
+typedef struct _GtkInspectorLogs GtkInspectorLogs;
 
 G_BEGIN_DECLS
 

gtk/inspector/logs.ui

@@ -1,5 +1,5 @@
 <interface domain="gtk40">
-  <template class="GtkInspectorLogs" parent="GtkBox">
+  <template class="GtkInspectorLogs" parent="GtkWidget">
     <child>
       <object class="GtkBox">
         <property name="margin-start">20</property>

gtk/inspector/misc-info.c

@@ -33,7 +33,10 @@
 #include "gtkbinlayout.h"
 
 
-struct _GtkInspectorMiscInfoPrivate {
+struct _GtkInspectorMiscInfo
+{
+  GtkWidget parent;
+
   GObject *object;
 
   GtkWidget *swin;
@@ -88,7 +91,12 @@ struct _GtkInspectorMiscInfoPrivate {
   gint64 last_frame;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorMiscInfo, gtk_inspector_misc_info, GTK_TYPE_WIDGET)
+typedef struct _GtkInspectorMiscInfoClass
+{
+  GtkWidgetClass parent_class;
+} GtkInspectorMiscInfoClass;
+
+G_DEFINE_TYPE (GtkInspectorMiscInfo, gtk_inspector_misc_info, GTK_TYPE_WIDGET)
 
 static gchar *
 format_state_flags (GtkStateFlags state)
@@ -125,7 +133,7 @@ state_flags_changed (GtkWidget *w, GtkStateFlags old_flags, GtkInspectorMiscInfo
   gchar *s;
 
   s = format_state_flags (gtk_widget_get_state_flags (w));
-  gtk_label_set_label (GTK_LABEL (sl->priv->state), s);
+  gtk_label_set_label (GTK_LABEL (sl->state), s);
   g_free (s);
 }
 
@@ -143,16 +151,16 @@ update_allocation (GtkWidget            *w,
                                 alloc.width, alloc.height,
                                 alloc.x, alloc.y);
 
-  gtk_label_set_label (GTK_LABEL (sl->priv->allocated_size), size_label);
+  gtk_label_set_label (GTK_LABEL (sl->allocated_size), size_label);
   g_free (size_label);
 
   size_label = g_strdup_printf ("%d", gtk_widget_get_allocated_baseline (w));
-  gtk_label_set_label (GTK_LABEL (sl->priv->baseline), size_label);
+  gtk_label_set_label (GTK_LABEL (sl->baseline), size_label);
   g_free (size_label);
 
   class = G_ENUM_CLASS (g_type_class_ref (GTK_TYPE_SIZE_REQUEST_MODE));
   value = g_enum_get_value (class, gtk_widget_get_request_mode (w));
-  gtk_label_set_label (GTK_LABEL (sl->priv->request_mode), value->value_nick);
+  gtk_label_set_label (GTK_LABEL (sl->request_mode), value->value_nick);
   g_type_class_unref (class);
 }
 
@@ -163,7 +171,7 @@ disconnect_each_other (gpointer  still_alive,
   if (GTK_INSPECTOR_IS_MISC_INFO (still_alive))
     {
       GtkInspectorMiscInfo *self = GTK_INSPECTOR_MISC_INFO (still_alive);
-      self->priv->object = NULL;
+      self->object = NULL;
     }
 
   g_signal_handlers_disconnect_matched (still_alive, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, for_science);
@@ -191,7 +199,7 @@ show_surface (GtkWidget *button, GtkInspectorMiscInfo *sl)
 
   iw = GTK_INSPECTOR_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (sl), GTK_TYPE_INSPECTOR_WINDOW));
 
-  surface = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->priv->object));
+  surface = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->object));
   if (surface)
     gtk_inspector_window_push_object (iw, surface, CHILD_KIND_OTHER, 0);
 }
@@ -204,7 +212,7 @@ show_renderer (GtkWidget *button, GtkInspectorMiscInfo *sl)
 
   iw = GTK_INSPECTOR_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (sl), GTK_TYPE_INSPECTOR_WINDOW));
 
-  renderer = (GObject *)gtk_native_get_renderer (GTK_NATIVE (sl->priv->object));
+  renderer = (GObject *)gtk_native_get_renderer (GTK_NATIVE (sl->object));
   if (renderer)
     gtk_inspector_window_push_object (iw, renderer, CHILD_KIND_OTHER, 0);
 }
@@ -217,7 +225,7 @@ show_frame_clock (GtkWidget *button, GtkInspectorMiscInfo *sl)
 
   iw = GTK_INSPECTOR_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (sl), GTK_TYPE_INSPECTOR_WINDOW));
 
-  clock = (GObject *)gtk_widget_get_frame_clock (GTK_WIDGET (sl->priv->object));
+  clock = (GObject *)gtk_widget_get_frame_clock (GTK_WIDGET (sl->object));
   if (clock)
     gtk_inspector_window_push_object (iw, clock, CHILD_KIND_OTHER, 0);
 }
@@ -225,72 +233,72 @@ show_frame_clock (GtkWidget *button, GtkInspectorMiscInfo *sl)
 static void
 update_surface (GtkInspectorMiscInfo *sl)
 {
-  if (GTK_IS_NATIVE (sl->priv->object))
+  if (GTK_IS_NATIVE (sl->object))
     {
       GObject *obj;
       char *tmp;
 
-      gtk_widget_show (sl->priv->surface_row);
+      gtk_widget_show (sl->surface_row);
 
-      obj = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->priv->object));
+      obj = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->object));
       tmp = g_strdup_printf ("%p", obj);
-      gtk_label_set_label (GTK_LABEL (sl->priv->surface), tmp);
+      gtk_label_set_label (GTK_LABEL (sl->surface), tmp);
       g_free (tmp);
     }
   else
     {
-      gtk_widget_hide (sl->priv->surface_row);
+      gtk_widget_hide (sl->surface_row);
     }
 }
 
 static void
 update_renderer (GtkInspectorMiscInfo *sl)
 {
-  if (GTK_IS_NATIVE (sl->priv->object))
+  if (GTK_IS_NATIVE (sl->object))
     {
       GObject *obj;
       char *tmp;
 
-      gtk_widget_show (sl->priv->renderer_row);
+      gtk_widget_show (sl->renderer_row);
 
-      obj = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->priv->object));
+      obj = (GObject *)gtk_native_get_surface (GTK_NATIVE (sl->object));
       tmp = g_strdup_printf ("%p", obj);
-      gtk_label_set_label (GTK_LABEL (sl->priv->renderer), tmp);
+      gtk_label_set_label (GTK_LABEL (sl->renderer), tmp);
       g_free (tmp);
     }
   else
     {
-      gtk_widget_hide (sl->priv->renderer_row);
+      gtk_widget_hide (sl->renderer_row);
     }
 }
 
 static void
 update_frame_clock (GtkInspectorMiscInfo *sl)
 {
-  if (GTK_IS_ROOT (sl->priv->object))
+  if (GTK_IS_ROOT (sl->object))
     {
       GObject *clock;
 
-      gtk_widget_show (sl->priv->frame_clock_row);
+      gtk_widget_show (sl->frame_clock_row);
 
-      clock = (GObject *)gtk_widget_get_frame_clock (GTK_WIDGET (sl->priv->object));
+      clock = (GObject *)gtk_widget_get_frame_clock (GTK_WIDGET (sl->object));
       if (clock)
         {
           gchar *tmp;
           tmp = g_strdup_printf ("%p", clock);
-          gtk_label_set_label (GTK_LABEL (sl->priv->frame_clock), tmp);
+          gtk_label_set_label (GTK_LABEL (sl->frame_clock), tmp);
           g_free (tmp);
-          gtk_widget_set_sensitive (sl->priv->frame_clock_button, TRUE);
+          gtk_widget_set_sensitive (sl->frame_clock_button, TRUE);
         }
       else
         {
-          gtk_label_set_label (GTK_LABEL (sl->priv->frame_clock), "NULL");
-          gtk_widget_set_sensitive (sl->priv->frame_clock_button, FALSE);
+          gtk_label_set_label (GTK_LABEL (sl->frame_clock), "NULL");
+          gtk_widget_set_sensitive (sl->frame_clock_button, FALSE);
         }
     }
   else
     {
-      gtk_widget_hide (sl->priv->frame_clock_row);
+      gtk_widget_hide (sl->frame_clock_row);
     }
 }
 
@@ -301,34 +309,34 @@ update_info (gpointer data)
   gchar *tmp;
   GType gtype;
 
-  tmp = g_strdup_printf ("%p", sl->priv->object);
-  gtk_label_set_text (GTK_LABEL (sl->priv->address), tmp);
+  tmp = g_strdup_printf ("%p", sl->object);
+  gtk_label_set_text (GTK_LABEL (sl->address), tmp);
   g_free (tmp);
 
-  gtype = G_TYPE_FROM_INSTANCE (sl->priv->object);
+  gtype = G_TYPE_FROM_INSTANCE (sl->object);
 
-  gtk_menu_button_set_label (GTK_MENU_BUTTON (sl->priv->type), g_type_name (gtype));
-  gtk_inspector_type_popover_set_gtype (GTK_INSPECTOR_TYPE_POPOVER (sl->priv->type_popover),
+  gtk_menu_button_set_label (GTK_MENU_BUTTON (sl->type), g_type_name (gtype));
+  gtk_inspector_type_popover_set_gtype (GTK_INSPECTOR_TYPE_POPOVER (sl->type_popover),
                                         gtype);
 
-  if (G_IS_OBJECT (sl->priv->object))
+  if (G_IS_OBJECT (sl->object))
     {
-      tmp = g_strdup_printf ("%d", sl->priv->object->ref_count);
-      gtk_label_set_text (GTK_LABEL (sl->priv->refcount), tmp);
+      tmp = g_strdup_printf ("%d", sl->object->ref_count);
+      gtk_label_set_text (GTK_LABEL (sl->refcount), tmp);
       g_free (tmp);
     }
 
-  if (GTK_IS_WIDGET (sl->priv->object))
+  if (GTK_IS_WIDGET (sl->object))
     {
       GtkWidget *child;
       AtkObject *accessible;
       AtkRole role;
       GList *list, *l;
 
-       while ((child = gtk_widget_get_first_child (sl->priv->mnemonic_label)))
-         gtk_box_remove (GTK_BOX (sl->priv->mnemonic_label), child);
+       while ((child = gtk_widget_get_first_child (sl->mnemonic_label)))
+         gtk_box_remove (GTK_BOX (sl->mnemonic_label), child);
 
-      list = gtk_widget_list_mnemonic_labels (GTK_WIDGET (sl->priv->object));
+      list = gtk_widget_list_mnemonic_labels (GTK_WIDGET (sl->object));
       for (l = list; l; l = l->next)
         {
           GtkWidget *button;
@@ -337,36 +345,36 @@ update_info (gpointer data)
           button = gtk_button_new_with_label (tmp);
           g_free (tmp);
           gtk_widget_show (button);
-          gtk_box_append (GTK_BOX (sl->priv->mnemonic_label), button);
+          gtk_box_append (GTK_BOX (sl->mnemonic_label), button);
           g_object_set_data (G_OBJECT (button), "mnemonic-label", l->data);
           g_signal_connect (button, "clicked", G_CALLBACK (show_mnemonic_label), sl);
         }
       g_list_free (list);
 
-      gtk_widget_set_visible (sl->priv->tick_callback, gtk_widget_has_tick_callback (GTK_WIDGET (sl->priv->object)));
+      gtk_widget_set_visible (sl->tick_callback, gtk_widget_has_tick_callback (GTK_WIDGET (sl->object)));
 
-      accessible = ATK_OBJECT (gtk_widget_get_accessible (GTK_WIDGET (sl->priv->object)));
+      accessible = ATK_OBJECT (gtk_widget_get_accessible (GTK_WIDGET (sl->object)));
       role = atk_object_get_role (accessible);
-      gtk_label_set_text (GTK_LABEL (sl->priv->accessible_role), atk_role_get_name (role));
-      gtk_label_set_text (GTK_LABEL (sl->priv->accessible_name), atk_object_get_name (accessible));
-      gtk_label_set_text (GTK_LABEL (sl->priv->accessible_description), atk_object_get_description (accessible));
-      gtk_widget_set_visible (sl->priv->mapped, gtk_widget_get_mapped (GTK_WIDGET (sl->priv->object)));
-      gtk_widget_set_visible (sl->priv->realized, gtk_widget_get_realized (GTK_WIDGET (sl->priv->object)));
-      gtk_widget_set_visible (sl->priv->is_toplevel, GTK_IS_ROOT (sl->priv->object));
-      gtk_widget_set_visible (sl->priv->child_visible, gtk_widget_get_child_visible (GTK_WIDGET (sl->priv->object)));
+      gtk_label_set_text (GTK_LABEL (sl->accessible_role), atk_role_get_name (role));
+      gtk_label_set_text (GTK_LABEL (sl->accessible_name), atk_object_get_name (accessible));
+      gtk_label_set_text (GTK_LABEL (sl->accessible_description), atk_object_get_description (accessible));
+      gtk_widget_set_visible (sl->mapped, gtk_widget_get_mapped (GTK_WIDGET (sl->object)));
+      gtk_widget_set_visible (sl->realized, gtk_widget_get_realized (GTK_WIDGET (sl->object)));
+      gtk_widget_set_visible (sl->is_toplevel, GTK_IS_ROOT (sl->object));
+      gtk_widget_set_visible (sl->child_visible, gtk_widget_get_child_visible (GTK_WIDGET (sl->object)));
     }
 
   update_surface (sl);
   update_renderer (sl);
   update_frame_clock (sl);
 
-  if (GTK_IS_BUILDABLE (sl->priv->object))
+  if (GTK_IS_BUILDABLE (sl->object))
     {
-      gtk_label_set_text (GTK_LABEL (sl->priv->buildable_id),
-                          gtk_buildable_get_name (GTK_BUILDABLE (sl->priv->object)));
+      gtk_label_set_text (GTK_LABEL (sl->buildable_id),
+                          gtk_buildable_get_name (GTK_BUILDABLE (sl->object)));
     }
 
-  if (GDK_IS_FRAME_CLOCK (sl->priv->object))
+  if (GDK_IS_FRAME_CLOCK (sl->object))
     {
       GdkFrameClock *clock;
       gint64 frame;
@@ -376,31 +384,31 @@ update_info (gpointer data)
       gint64 previous_frame_time;
       GdkFrameTimings *previous_timings;
 
-      clock = GDK_FRAME_CLOCK (sl->priv->object);
+      clock = GDK_FRAME_CLOCK (sl->object);
       frame = gdk_frame_clock_get_frame_counter (clock);
       frame_time = gdk_frame_clock_get_frame_time (clock);
 
       tmp = g_strdup_printf ("%"G_GINT64_FORMAT, frame);
-      gtk_label_set_label (GTK_LABEL (sl->priv->framecount), tmp);
+      gtk_label_set_label (GTK_LABEL (sl->framecount), tmp);
       g_free (tmp);
 
       history_start = gdk_frame_clock_get_history_start (clock);
       history_len = frame - history_start;
 
-      if (history_len > 0 && sl->priv->last_frame != frame)
+      if (history_len > 0 && sl->last_frame != frame)
         {
           previous_timings = gdk_frame_clock_get_timings (clock, history_start);
           previous_frame_time = gdk_frame_timings_get_frame_time (previous_timings);
           tmp = g_strdup_printf ("%4.1f ⁄ s", (G_USEC_PER_SEC * history_len) / (double) (frame_time - previous_frame_time));
-          gtk_label_set_label (GTK_LABEL (sl->priv->framerate), tmp);
+          gtk_label_set_label (GTK_LABEL (sl->framerate), tmp);
           g_free (tmp);
         }
       else
         {
-          gtk_label_set_label (GTK_LABEL (sl->priv->framerate), "—");
+          gtk_label_set_label (GTK_LABEL (sl->framerate), "—");
         }
 
-      sl->priv->last_frame = frame;
+      sl->last_frame = frame;
     }
 
   return G_SOURCE_CONTINUE;
@@ -410,79 +418,79 @@ void
 gtk_inspector_misc_info_set_object (GtkInspectorMiscInfo *sl,
                                     GObject              *object)
 {
-  if (sl->priv->object)
+  if (sl->object)
     {
-      g_signal_handlers_disconnect_by_func (sl->priv->object, state_flags_changed, sl);
-      disconnect_each_other (sl->priv->object, G_OBJECT (sl));
-      disconnect_each_other (sl, sl->priv->object);
-      sl->priv->object = NULL;
+      g_signal_handlers_disconnect_by_func (sl->object, state_flags_changed, sl);
+      disconnect_each_other (sl->object, G_OBJECT (sl));
+      disconnect_each_other (sl, sl->object);
+      sl->object = NULL;
     }
 
   gtk_widget_show (GTK_WIDGET (sl));
 
-  sl->priv->object = object;
+  sl->object = object;
   g_object_weak_ref (G_OBJECT (sl), disconnect_each_other, object);
   g_object_weak_ref (object, disconnect_each_other, sl);
 
   if (GTK_IS_WIDGET (object))
     {
-      gtk_widget_show (sl->priv->refcount_row);
-      gtk_widget_show (sl->priv->state_row);
-      gtk_widget_show (sl->priv->request_mode_row);
-      gtk_widget_show (sl->priv->allocated_size_row);
-      gtk_widget_show (sl->priv->baseline_row);
-      gtk_widget_show (sl->priv->mnemonic_label_row);
-      gtk_widget_show (sl->priv->tick_callback_row);
-      gtk_widget_show (sl->priv->accessible_role_row);
-      gtk_widget_show (sl->priv->accessible_name_row);
-      gtk_widget_show (sl->priv->accessible_description_row);
-      gtk_widget_show (sl->priv->mapped_row);
-      gtk_widget_show (sl->priv->realized_row);
-      gtk_widget_show (sl->priv->is_toplevel_row);
-      gtk_widget_show (sl->priv->is_toplevel_row);
-      gtk_widget_show (sl->priv->frame_clock_row);
+      gtk_widget_show (sl->refcount_row);
+      gtk_widget_show (sl->state_row);
+      gtk_widget_show (sl->request_mode_row);
+      gtk_widget_show (sl->allocated_size_row);
+      gtk_widget_show (sl->baseline_row);
+      gtk_widget_show (sl->mnemonic_label_row);
+      gtk_widget_show (sl->tick_callback_row);
+      gtk_widget_show (sl->accessible_role_row);
+      gtk_widget_show (sl->accessible_name_row);
+      gtk_widget_show (sl->accessible_description_row);
+      gtk_widget_show (sl->mapped_row);
+      gtk_widget_show (sl->realized_row);
+      gtk_widget_show (sl->is_toplevel_row);
+      gtk_widget_show (sl->is_toplevel_row);
+      gtk_widget_show (sl->frame_clock_row);
 
       g_signal_connect_object (object, "state-flags-changed", G_CALLBACK (state_flags_changed), sl, 0);
-      state_flags_changed (GTK_WIDGET (sl->priv->object), 0, sl);
+      state_flags_changed (GTK_WIDGET (sl->object), 0, sl);
 
-      update_allocation (GTK_WIDGET (sl->priv->object), sl);
+      update_allocation (GTK_WIDGET (sl->object), sl);
     }
   else
     {
-      gtk_widget_hide (sl->priv->state_row);
-      gtk_widget_hide (sl->priv->request_mode_row);
-      gtk_widget_hide (sl->priv->mnemonic_label_row);
-      gtk_widget_hide (sl->priv->allocated_size_row);
-      gtk_widget_hide (sl->priv->baseline_row);
-      gtk_widget_hide (sl->priv->tick_callback_row);
-      gtk_widget_hide (sl->priv->accessible_role_row);
-      gtk_widget_hide (sl->priv->accessible_name_row);
-      gtk_widget_hide (sl->priv->accessible_description_row);
-      gtk_widget_hide (sl->priv->mapped_row);
-      gtk_widget_hide (sl->priv->realized_row);
-      gtk_widget_hide (sl->priv->is_toplevel_row);
-      gtk_widget_hide (sl->priv->child_visible_row);
-      gtk_widget_hide (sl->priv->frame_clock_row);
+      gtk_widget_hide (sl->state_row);
+      gtk_widget_hide (sl->request_mode_row);
+      gtk_widget_hide (sl->mnemonic_label_row);
+      gtk_widget_hide (sl->allocated_size_row);
+      gtk_widget_hide (sl->baseline_row);
+      gtk_widget_hide (sl->tick_callback_row);
+      gtk_widget_hide (sl->accessible_role_row);
+      gtk_widget_hide (sl->accessible_name_row);
+      gtk_widget_hide (sl->accessible_description_row);
+      gtk_widget_hide (sl->mapped_row);
+      gtk_widget_hide (sl->realized_row);
+      gtk_widget_hide (sl->is_toplevel_row);
+      gtk_widget_hide (sl->child_visible_row);
+      gtk_widget_hide (sl->frame_clock_row);
     }
 
   if (GTK_IS_BUILDABLE (object))
     {
-      gtk_widget_show (sl->priv->buildable_id_row);
+      gtk_widget_show (sl->buildable_id_row);
     }
   else
     {
-      gtk_widget_hide (sl->priv->buildable_id_row);
+      gtk_widget_hide (sl->buildable_id_row);
     }
 
   if (GDK_IS_FRAME_CLOCK (object))
     {
-      gtk_widget_show (sl->priv->framecount_row);
-      gtk_widget_show (sl->priv->framerate_row);
+      gtk_widget_show (sl->framecount_row);
+      gtk_widget_show (sl->framerate_row);
     }
   else
     {
-      gtk_widget_hide (sl->priv->framecount_row);
-      gtk_widget_hide (sl->priv->framerate_row);
+      gtk_widget_hide (sl->framecount_row);
+      gtk_widget_hide (sl->framerate_row);
     }
 
   update_info (sl);
@@ -491,12 +499,11 @@ gtk_inspector_misc_info_set_object (GtkInspectorMiscInfo *sl,
 static void
 gtk_inspector_misc_info_init (GtkInspectorMiscInfo *sl)
 {
-  sl->priv = gtk_inspector_misc_info_get_instance_private (sl);
   gtk_widget_init_template (GTK_WIDGET (sl));
 
-  sl->priv->type_popover = g_object_new (GTK_TYPE_INSPECTOR_TYPE_POPOVER, NULL);
-  gtk_menu_button_set_popover (GTK_MENU_BUTTON (sl->priv->type),
-                               sl->priv->type_popover);
+  sl->type_popover = g_object_new (GTK_TYPE_INSPECTOR_TYPE_POPOVER, NULL);
+  gtk_menu_button_set_popover (GTK_MENU_BUTTON (sl->type),
+                               sl->type_popover);
 
 }
 
@@ -507,7 +514,7 @@ map (GtkWidget *widget)
 
   GTK_WIDGET_CLASS (gtk_inspector_misc_info_parent_class)->map (widget);
 
-  sl->priv->update_source_id = g_timeout_add_seconds (1, update_info, sl);
+  sl->update_source_id = g_timeout_add_seconds (1, update_info, sl);
   update_info (sl);
 }
 
@@ -516,8 +523,8 @@ unmap (GtkWidget *widget)
 {
   GtkInspectorMiscInfo *sl = GTK_INSPECTOR_MISC_INFO (widget);
 
-  g_source_remove (sl->priv->update_source_id);
-  sl->priv->update_source_id = 0;
+  g_source_remove (sl->update_source_id);
+  sl->update_source_id = 0;
 
   GTK_WIDGET_CLASS (gtk_inspector_misc_info_parent_class)->unmap (widget);
 }
@@ -527,7 +534,7 @@ dispose (GObject *o)
 {
   GtkInspectorMiscInfo *sl = GTK_INSPECTOR_MISC_INFO (o);
 
-  g_clear_pointer (&sl->priv->swin, gtk_widget_unparent);
+  g_clear_pointer (&sl->swin, gtk_widget_unparent);
 
   G_OBJECT_CLASS (gtk_inspector_misc_info_parent_class)->dispose (o);
 }
@@ -544,52 +551,52 @@ gtk_inspector_misc_info_class_init (GtkInspectorMiscInfoClass *klass)
   widget_class->unmap = unmap;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/misc-info.ui");
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, swin);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, address);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, type);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, refcount_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, refcount);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, state_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, state);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, buildable_id_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, buildable_id);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, mnemonic_label_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, mnemonic_label);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, request_mode_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, request_mode);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, allocated_size_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, allocated_size);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, baseline_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, baseline);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, surface_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, surface);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, surface_button);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, renderer_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, renderer);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, renderer_button);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, frame_clock_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, frame_clock);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, frame_clock_button);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, tick_callback_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, tick_callback);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, framecount_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, framecount);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, framerate_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, framerate);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_role_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_role);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_name_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_name);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_description_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, accessible_description);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, mapped_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, mapped);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, realized_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, realized);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, is_toplevel_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, is_toplevel);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, child_visible_row);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMiscInfo, child_visible);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, swin);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, address);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, type);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, refcount_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, refcount);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, state_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, state);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, buildable_id_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, buildable_id);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, mnemonic_label_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, mnemonic_label);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, request_mode_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, request_mode);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, allocated_size_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, allocated_size);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, baseline_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, baseline);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, surface_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, surface);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, surface_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, renderer_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, renderer);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, renderer_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, frame_clock_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, frame_clock);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, frame_clock_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, tick_callback_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, tick_callback);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, framecount_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, framecount);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, framerate_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, framerate);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_role_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_role);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_name_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_name);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_description_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, accessible_description);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, mapped_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, mapped);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, realized_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, realized);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, is_toplevel_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, is_toplevel);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, child_visible_row);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorMiscInfo, child_visible);
 
   gtk_widget_class_bind_template_callback (widget_class, show_surface);
   gtk_widget_class_bind_template_callback (widget_class, show_renderer);

gtk/inspector/misc-info.h

@@ -22,24 +22,9 @@
 
 #define GTK_TYPE_INSPECTOR_MISC_INFO            (gtk_inspector_misc_info_get_type())
 #define GTK_INSPECTOR_MISC_INFO(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfo))
-#define GTK_INSPECTOR_MISC_INFO_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfoClass))
 #define GTK_INSPECTOR_IS_MISC_INFO(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_MISC_INFO))
-#define GTK_INSPECTOR_IS_MISC_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_MISC_INFO))
-#define GTK_INSPECTOR_MISC_INFO_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfoClass))
 
-
-typedef struct _GtkInspectorMiscInfoPrivate GtkInspectorMiscInfoPrivate;
-
-typedef struct _GtkInspectorMiscInfo
-{
-  GtkWidget parent;
-  GtkInspectorMiscInfoPrivate *priv;
-} GtkInspectorMiscInfo;
-
-typedef struct _GtkInspectorMiscInfoClass
-{
-  GtkWidgetClass parent_class;
-} GtkInspectorMiscInfoClass;
+typedef struct _GtkInspectorMiscInfo GtkInspectorMiscInfo;
 
 G_BEGIN_DECLS
 

gtk/inspector/prop-editor.c

@@ -1741,12 +1741,16 @@ static void
 gtk_inspector_prop_editor_class_init (GtkInspectorPropEditorClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
   object_class->constructed = constructed;
   object_class->finalize = finalize;
   object_class->get_property = get_property;
   object_class->set_property = set_property;
 
+  widget_class->focus = gtk_widget_focus_child;
+  widget_class->grab_focus = gtk_widget_grab_focus_child;
+
   signals[SHOW_OBJECT] =
     g_signal_new ("show-object",
                   G_TYPE_FROM_CLASS (object_class),

gtk/inspector/recorder.c

@@ -52,13 +52,16 @@
 #include "renderrecording.h"
 #include "startrecording.h"
 
-struct _GtkInspectorRecorderPrivate
+struct _GtkInspectorRecorder
 {
+  GtkWidget parent;
+
   GListModel *recordings;
   GtkTreeListModel *render_node_model;
   GListStore *render_node_root_model;
   GtkSingleSelection *render_node_selection;
 
+  GtkWidget *box;
   GtkWidget *recordings_list;
   GtkWidget *render_node_view;
   GtkWidget *render_node_list;
@@ -71,6 +74,12 @@ struct _GtkInspectorRecorderPrivate
   gboolean debug_nodes;
 };
 
+typedef struct _GtkInspectorRecorderClass
+{
+  GtkWidgetClass parent;
+} GtkInspectorRecorderClass;
+
+
 enum
 {
   PROP_0,
@@ -81,7 +90,7 @@ enum
 
 static GParamSpec *props[LAST_PROP] = { NULL, };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorRecorder, gtk_inspector_recorder, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE (GtkInspectorRecorder, gtk_inspector_recorder, GTK_TYPE_WIDGET)
 
 static GListModel *
 create_render_node_list_model (GskRenderNode **nodes,
@@ -201,9 +210,7 @@ static void
 recordings_clear_all (GtkButton            *button,
                       GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
-
-  g_list_store_remove_all (G_LIST_STORE (priv->recordings));
+  g_list_store_remove_all (G_LIST_STORE (recorder->recordings));
 }
 
 static const char *
@@ -361,11 +368,10 @@ recordings_list_row_selected (GtkListBox           *box,
                               GtkListBoxRow        *row,
                               GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   GtkInspectorRecording *recording;
 
   if (row)
-    recording = g_list_model_get_item (priv->recordings, gtk_list_box_row_get_index (row));
+    recording = g_list_model_get_item (recorder->recordings, gtk_list_box_row_get_index (row));
   else
     recording = NULL;
 
@@ -378,18 +384,18 @@ recordings_list_row_selected (GtkListBox           *box,
       node = gtk_inspector_render_recording_get_node (GTK_INSPECTOR_RENDER_RECORDING (recording));
       gsk_render_node_get_bounds (node, &bounds);
       paintable = gtk_render_node_paintable_new (node, &bounds);
-      gtk_picture_set_paintable (GTK_PICTURE (priv->render_node_view), paintable);
+      gtk_picture_set_paintable (GTK_PICTURE (recorder->render_node_view), paintable);
 
-      g_list_store_splice (priv->render_node_root_model,
-                           0, g_list_model_get_n_items (G_LIST_MODEL (priv->render_node_root_model)),
+      g_list_store_splice (recorder->render_node_root_model,
+                           0, g_list_model_get_n_items (G_LIST_MODEL (recorder->render_node_root_model)),
                            (gpointer[1]) { paintable },
                            1);
       g_object_unref (paintable);
     }
   else
     {
-      gtk_picture_set_paintable (GTK_PICTURE (priv->render_node_view), NULL);
-      g_list_store_remove_all (priv->render_node_root_model);
+      gtk_picture_set_paintable (GTK_PICTURE (recorder->render_node_view), NULL);
+      g_list_store_remove_all (recorder->render_node_root_model);
     }
 
   if (recording)
@@ -906,12 +912,11 @@ populate_render_node_properties (GtkListStore  *store,
 static GskRenderNode *
 get_selected_node (GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   GtkTreeListRow *row_item;
   GdkPaintable *paintable;
   GskRenderNode *node;
 
-  row_item = gtk_single_selection_get_selected_item (priv->render_node_selection);
+  row_item = gtk_single_selection_get_selected_item (recorder->render_node_selection);
   if (row_item == NULL)
     return NULL;
 
@@ -927,21 +932,20 @@ render_node_list_selection_changed (GtkListBox           *list,
                                     GtkListBoxRow        *row,
                                     GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   GskRenderNode *node;
   GdkPaintable *paintable;
   GtkTreeListRow *row_item;
 
-  row_item = gtk_single_selection_get_selected_item (priv->render_node_selection);
+  row_item = gtk_single_selection_get_selected_item (recorder->render_node_selection);
   if (row_item == NULL)
     return;
 
   paintable = gtk_tree_list_row_get_item (row_item);
 
-  gtk_widget_set_sensitive (priv->render_node_save_button, TRUE);
-  gtk_picture_set_paintable (GTK_PICTURE (priv->render_node_view), paintable);
+  gtk_widget_set_sensitive (recorder->render_node_save_button, TRUE);
+  gtk_picture_set_paintable (GTK_PICTURE (recorder->render_node_view), paintable);
   node = gtk_render_node_paintable_get_render_node (GTK_RENDER_NODE_PAINTABLE (paintable));
-  populate_render_node_properties (GTK_LIST_STORE (priv->render_node_properties), node);
+  populate_render_node_properties (GTK_LIST_STORE (recorder->render_node_properties), node);
 
   g_object_unref (paintable);
 }
@@ -1077,7 +1081,6 @@ node_property_activated (GtkTreeView *tv,
                          GtkTreeViewColumn *col,
                          GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   GtkTreeIter iter;
   GdkRectangle rect;
   GdkTexture *texture;
@@ -1085,8 +1088,8 @@ node_property_activated (GtkTreeView *tv,
   GtkWidget *popover;
   GtkWidget *image;
 
-  gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->render_node_properties), &iter, path);
-  gtk_tree_model_get (GTK_TREE_MODEL (priv->render_node_properties), &iter,
+  gtk_tree_model_get_iter (GTK_TREE_MODEL (recorder->render_node_properties), &iter, path);
+  gtk_tree_model_get (GTK_TREE_MODEL (recorder->render_node_properties), &iter,
                       2, &visible,
                       3, &texture,
                       -1);
@@ -1120,16 +1123,15 @@ gtk_inspector_recorder_get_property (GObject    *object,
                                      GParamSpec *pspec)
 {
   GtkInspectorRecorder *recorder = GTK_INSPECTOR_RECORDER (object);
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
 
   switch (param_id)
     {
     case PROP_RECORDING:
-      g_value_set_boolean (value, priv->recording != NULL);
+      g_value_set_boolean (value, recorder->recording != NULL);
       break;
 
     case PROP_DEBUG_NODES:
-      g_value_set_boolean (value, priv->debug_nodes);
+      g_value_set_boolean (value, recorder->debug_nodes);
       break;
 
     default:
@@ -1166,11 +1168,11 @@ static void
 gtk_inspector_recorder_dispose (GObject *object)
 {
   GtkInspectorRecorder *recorder = GTK_INSPECTOR_RECORDER (object);
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
 
-  g_clear_object (&priv->render_node_model);
-  g_clear_object (&priv->render_node_root_model);
-  g_clear_object (&priv->render_node_selection);
+  g_clear_pointer (&recorder->box, gtk_widget_unparent);
+  g_clear_object (&recorder->render_node_model);
+  g_clear_object (&recorder->render_node_root_model);
+  g_clear_object (&recorder->render_node_selection);
 
   G_OBJECT_CLASS (gtk_inspector_recorder_parent_class)->dispose (object);
 }
@@ -1202,12 +1204,13 @@ gtk_inspector_recorder_class_init (GtkInspectorRecorderClass *klass)
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/recorder.ui");
 
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, recordings);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, recordings_list);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, render_node_view);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, render_node_list);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, render_node_save_button);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorRecorder, node_property_tree);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, recordings);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, recordings_list);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, render_node_view);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, render_node_list);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, render_node_save_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorRecorder, node_property_tree);
 
   gtk_widget_class_bind_template_callback (widget_class, recordings_clear_all);
   gtk_widget_class_bind_template_callback (widget_class, recordings_list_row_selected);
@@ -1220,66 +1223,61 @@ gtk_inspector_recorder_class_init (GtkInspectorRecorderClass *klass)
 static void
 gtk_inspector_recorder_init (GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   GtkListItemFactory *factory;
 
   gtk_widget_init_template (GTK_WIDGET (recorder));
 
-  gtk_list_box_bind_model (GTK_LIST_BOX (priv->recordings_list),
-                           priv->recordings,
+  gtk_list_box_bind_model (GTK_LIST_BOX (recorder->recordings_list),
+                           recorder->recordings,
                            gtk_inspector_recorder_recordings_list_create_widget,
                            recorder,
                            NULL);
 
-  priv->render_node_root_model = g_list_store_new (GDK_TYPE_PAINTABLE);
-  priv->render_node_model = gtk_tree_list_model_new (FALSE,
-                                                     G_LIST_MODEL (priv->render_node_root_model),
+  recorder->render_node_root_model = g_list_store_new (GDK_TYPE_PAINTABLE);
+  recorder->render_node_model = gtk_tree_list_model_new (FALSE,
+                                                     G_LIST_MODEL (recorder->render_node_root_model),
                                                      TRUE,
                                                      create_list_model_for_render_node_paintable,
                                                      NULL, NULL);
-  priv->render_node_selection = gtk_single_selection_new (G_LIST_MODEL (priv->render_node_model));
-  g_signal_connect (priv->render_node_selection, "notify::selected-item", G_CALLBACK (render_node_list_selection_changed), recorder);
+  recorder->render_node_selection = gtk_single_selection_new (G_LIST_MODEL (recorder->render_node_model));
+  g_signal_connect (recorder->render_node_selection, "notify::selected-item", G_CALLBACK (render_node_list_selection_changed), recorder);
 
   factory = gtk_signal_list_item_factory_new ();
   g_signal_connect (factory, "setup", G_CALLBACK (setup_widget_for_render_node), NULL);
   g_signal_connect (factory, "bind", G_CALLBACK (bind_widget_for_render_node), NULL);
 
-  gtk_list_view_set_factory (GTK_LIST_VIEW (priv->render_node_list), factory);
+  gtk_list_view_set_factory (GTK_LIST_VIEW (recorder->render_node_list), factory);
   g_object_unref (factory);
-  gtk_list_view_set_model (GTK_LIST_VIEW (priv->render_node_list),
-                           G_LIST_MODEL (priv->render_node_selection));
+  gtk_list_view_set_model (GTK_LIST_VIEW (recorder->render_node_list),
+                           G_LIST_MODEL (recorder->render_node_selection));
 
-  priv->render_node_properties = GTK_TREE_MODEL (gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_TEXTURE));
-  gtk_tree_view_set_model (GTK_TREE_VIEW (priv->node_property_tree), priv->render_node_properties);
-  g_object_unref (priv->render_node_properties);
+  recorder->render_node_properties = GTK_TREE_MODEL (gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_TEXTURE));
+  gtk_tree_view_set_model (GTK_TREE_VIEW (recorder->node_property_tree), recorder->render_node_properties);
+  g_object_unref (recorder->render_node_properties);
 }
 
 static void
 gtk_inspector_recorder_add_recording (GtkInspectorRecorder  *recorder,
                                       GtkInspectorRecording *recording)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
-
-  g_list_store_append (G_LIST_STORE (priv->recordings), recording);
+  g_list_store_append (G_LIST_STORE (recorder->recordings), recording);
 }
 
 void
 gtk_inspector_recorder_set_recording (GtkInspectorRecorder *recorder,
                                       gboolean              recording)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
-
   if (gtk_inspector_recorder_is_recording (recorder) == recording)
     return;
 
   if (recording)
     {
-      priv->recording = gtk_inspector_start_recording_new ();
-      gtk_inspector_recorder_add_recording (recorder, priv->recording);
+      recorder->recording = gtk_inspector_start_recording_new ();
+      gtk_inspector_recorder_add_recording (recorder, recorder->recording);
     }
   else
     {
-      g_clear_object (&priv->recording);
+      g_clear_object (&recorder->recording);
     }
 
   g_object_notify_by_pspec (G_OBJECT (recorder), props[PROP_RECORDING]);
@@ -1288,9 +1286,7 @@ gtk_inspector_recorder_set_recording (GtkInspectorRecorder *recorder,
 gboolean
 gtk_inspector_recorder_is_recording (GtkInspectorRecorder *recorder)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
-
-  return priv->recording != NULL;
+  return recorder->recording != NULL;
 }
 
 void
@@ -1324,13 +1320,12 @@ void
 gtk_inspector_recorder_set_debug_nodes (GtkInspectorRecorder *recorder,
                                         gboolean              debug_nodes)
 {
-  GtkInspectorRecorderPrivate *priv = gtk_inspector_recorder_get_instance_private (recorder);
   guint flags;
 
-  if (priv->debug_nodes == debug_nodes)
+  if (recorder->debug_nodes == debug_nodes)
     return;
 
-  priv->debug_nodes = debug_nodes;
+  recorder->debug_nodes = debug_nodes;
 
   flags = gtk_get_debug_flags ();
 

gtk/inspector/recorder.h

@@ -22,23 +22,9 @@
 
 #define GTK_TYPE_INSPECTOR_RECORDER            (gtk_inspector_recorder_get_type())
 #define GTK_INSPECTOR_RECORDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorder))
-#define GTK_INSPECTOR_RECORDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorderClass))
 #define GTK_INSPECTOR_IS_RECORDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_RECORDER))
-#define GTK_INSPECTOR_IS_RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_RECORDER))
-#define GTK_INSPECTOR_RECORDER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorderClass))
 
-
-typedef struct _GtkInspectorRecorderPrivate GtkInspectorRecorderPrivate;
-
-typedef struct _GtkInspectorRecorder
-{
-  GtkWidget parent;
-} GtkInspectorRecorder;
-
-typedef struct _GtkInspectorRecorderClass
-{
-  GtkWidgetClass parent;
-} GtkInspectorRecorderClass;
+typedef struct _GtkInspectorRecorder GtkInspectorRecorder;
 
 G_BEGIN_DECLS
 

gtk/inspector/recorder.ui

@@ -2,7 +2,7 @@
   <object class="GListStore" id="recordings"/>
   <template class="GtkInspectorRecorder" parent="GtkWidget">
     <child>
-      <object class="GtkBox">
+      <object class="GtkBox" id="box">
         <property name="orientation">vertical</property>
         <child>
           <object class="GtkBox">

gtk/inspector/shortcuts.c

@@ -141,12 +141,26 @@ gtk_inspector_shortcuts_size_allocate (GtkWidget *widget,
                             baseline);
 }
 
+static void
+dispose (GObject *object)
+{
+  GtkInspectorShortcuts *shortcuts = GTK_INSPECTOR_SHORTCUTS (object);
+  GtkWidget *child;
+
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (shortcuts))))
+    gtk_widget_unparent (child);
+
+  G_OBJECT_CLASS (gtk_inspector_shortcuts_parent_class)->dispose (object);
+}
 
 static void
 gtk_inspector_shortcuts_class_init (GtkInspectorShortcutsClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
+  object_class->dispose = dispose;
+
   widget_class->measure = gtk_inspector_shortcuts_measure;
   widget_class->size_allocate = gtk_inspector_shortcuts_size_allocate;
 

gtk/inspector/tree-data.c

@@ -171,11 +171,26 @@ toggle_show (GtkToggleButton      *button,
     show_types (sl);
 }
 
+static void
+dispose (GObject *object)
+{
+  GtkInspectorTreeData *sl = GTK_INSPECTOR_TREE_DATA (object);
+  GtkWidget *child;
+
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (sl))))
+    gtk_widget_unparent (child);
+
+  G_OBJECT_CLASS (gtk_inspector_tree_data_parent_class)->dispose (object);
+}
+
 static void
 gtk_inspector_tree_data_class_init (GtkInspectorTreeDataClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
+  object_class->dispose = dispose;
+
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/tree-data.ui");
   gtk_widget_class_bind_template_child (widget_class, GtkInspectorTreeData, view);
   gtk_widget_class_bind_template_child (widget_class, GtkInspectorTreeData, object_title);

gtk/inspector/visual.c

@@ -56,8 +56,10 @@
 
 #define EPSILON               1e-10
 
-struct _GtkInspectorVisualPrivate
+struct _GtkInspectorVisual
 {
+  GtkWidget widget;
+
   GtkWidget *swin;
   GtkWidget *box;
   GtkWidget *visual_box;
@@ -83,7 +85,6 @@ struct _GtkInspectorVisualPrivate
   GtkWidget *fallback_switch;
   GtkWidget *baselines_switch;
   GtkWidget *layout_switch;
-  GtkWidget *resize_switch;
   GtkWidget *focus_switch;
 
   GtkWidget *misc_box;
@@ -99,7 +100,12 @@ struct _GtkInspectorVisualPrivate
   GdkDisplay *display;
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorVisual, gtk_inspector_visual, GTK_TYPE_WIDGET)
+typedef struct _GtkInspectorVisualClass
+{
+  GtkWidgetClass parent_class;
+} GtkInspectorVisualClass;
+
+G_DEFINE_TYPE (GtkInspectorVisual, gtk_inspector_visual, GTK_TYPE_WIDGET)
 
 static void
 fix_direction_recurse (GtkWidget        *widget,
@@ -151,9 +157,9 @@ init_direction (GtkInspectorVisual *vis)
 {
   initial_direction = gtk_widget_get_default_direction ();
   if (initial_direction == GTK_TEXT_DIR_LTR)
-    gtk_drop_down_set_selected (GTK_DROP_DOWN (vis->priv->direction_combo), 0);
+    gtk_drop_down_set_selected (GTK_DROP_DOWN (vis->direction_combo), 0);
   else
-    gtk_drop_down_set_selected (GTK_DROP_DOWN (vis->priv->direction_combo), 1);
+    gtk_drop_down_set_selected (GTK_DROP_DOWN (vis->direction_combo), 1);
 }
 
 static void
@@ -169,11 +175,11 @@ static double
 get_font_scale (GtkInspectorVisual *vis)
 {
 #ifdef GDK_WINDOWING_X11
-  if (GDK_IS_X11_DISPLAY (vis->priv->display))
+  if (GDK_IS_X11_DISPLAY (vis->display))
     {
       int dpi_int;
 
-      g_object_get (gtk_settings_get_for_display (vis->priv->display),
+      g_object_get (gtk_settings_get_for_display (vis->display),
                     "gtk-xft-dpi", &dpi_int,
                     NULL);
 
@@ -181,11 +187,11 @@ get_font_scale (GtkInspectorVisual *vis)
     }
 #endif
 #ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (vis->priv->display))
+  if (GDK_IS_WAYLAND_DISPLAY (vis->display))
     {
       int dpi_int;
 
-      g_object_get (gtk_settings_get_for_display (vis->priv->display),
+      g_object_get (gtk_settings_get_for_display (vis->display),
                     "gtk-xft-dpi", &dpi_int,
                     NULL);
 
@@ -202,18 +208,18 @@ update_font_scale (GtkInspectorVisual *vis,
                    gboolean            update_adjustment,
                    gboolean            update_entry)
 {
-  g_object_set (gtk_settings_get_for_display (vis->priv->display),
+  g_object_set (gtk_settings_get_for_display (vis->display),
                 "gtk-xft-dpi", (gint)(factor * 96 * 1024),
                 NULL);
 
   if (update_adjustment)
-    gtk_adjustment_set_value (vis->priv->font_scale_adjustment, factor);
+    gtk_adjustment_set_value (vis->font_scale_adjustment, factor);
 
   if (update_entry)
     {
       gchar *str = g_strdup_printf ("%0.2f", factor);
 
-      gtk_editable_set_text (GTK_EDITABLE (vis->priv->font_scale_entry), str);
+      gtk_editable_set_text (GTK_EDITABLE (vis->font_scale_entry), str);
       g_free (str);
     }
 }
@@ -245,7 +251,6 @@ fps_activate (GtkSwitch          *sw,
               GParamSpec         *pspec,
               GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean fps;
 
@@ -256,19 +261,19 @@ fps_activate (GtkSwitch          *sw,
 
   if (fps)
     {
-      if (priv->fps_overlay == NULL)
+      if (vis->fps_overlay == NULL)
         {
-          priv->fps_overlay = gtk_fps_overlay_new ();
-          gtk_inspector_window_add_overlay (iw, priv->fps_overlay);
-          g_object_unref (priv->fps_overlay);
+          vis->fps_overlay = gtk_fps_overlay_new ();
+          gtk_inspector_window_add_overlay (iw, vis->fps_overlay);
+          g_object_unref (vis->fps_overlay);
         }
     }
   else
     {
-      if (priv->fps_overlay != NULL)
+      if (vis->fps_overlay != NULL)
         {
-          gtk_inspector_window_remove_overlay (iw, priv->fps_overlay);
-          priv->fps_overlay = NULL;
+          gtk_inspector_window_remove_overlay (iw, vis->fps_overlay);
+          vis->fps_overlay = NULL;
         }
     }
 
@@ -280,7 +285,6 @@ updates_activate (GtkSwitch          *sw,
                   GParamSpec         *pspec,
                   GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean updates;
 
@@ -291,19 +295,19 @@ updates_activate (GtkSwitch          *sw,
 
   if (updates)
     {
-      if (priv->updates_overlay == NULL)
+      if (vis->updates_overlay == NULL)
         {
-          priv->updates_overlay = gtk_updates_overlay_new ();
-          gtk_inspector_window_add_overlay (iw, priv->updates_overlay);
-          g_object_unref (priv->updates_overlay);
+          vis->updates_overlay = gtk_updates_overlay_new ();
+          gtk_inspector_window_add_overlay (iw, vis->updates_overlay);
+          g_object_unref (vis->updates_overlay);
         }
     }
   else
     {
-      if (priv->updates_overlay != NULL)
+      if (vis->updates_overlay != NULL)
         {
-          gtk_inspector_window_remove_overlay (iw, priv->updates_overlay);
-          priv->updates_overlay = NULL;
+          gtk_inspector_window_remove_overlay (iw, vis->updates_overlay);
+          vis->updates_overlay = NULL;
         }
     }
 
@@ -357,7 +361,6 @@ baselines_activate (GtkSwitch          *sw,
                     GParamSpec         *pspec,
                     GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean baselines;
 
@@ -368,19 +371,19 @@ baselines_activate (GtkSwitch          *sw,
 
   if (baselines)
     {
-      if (priv->baseline_overlay == NULL)
+      if (vis->baseline_overlay == NULL)
         {
-          priv->baseline_overlay = gtk_baseline_overlay_new ();
-          gtk_inspector_window_add_overlay (iw, priv->baseline_overlay);
-          g_object_unref (priv->baseline_overlay);
+          vis->baseline_overlay = gtk_baseline_overlay_new ();
+          gtk_inspector_window_add_overlay (iw, vis->baseline_overlay);
+          g_object_unref (vis->baseline_overlay);
         }
     }
   else
     {
-      if (priv->baseline_overlay != NULL)
+      if (vis->baseline_overlay != NULL)
         {
-          gtk_inspector_window_remove_overlay (iw, priv->baseline_overlay);
-          priv->baseline_overlay = NULL;
+          gtk_inspector_window_remove_overlay (iw, vis->baseline_overlay);
+          vis->baseline_overlay = NULL;
         }
     }
 
@@ -392,7 +395,6 @@ layout_activate (GtkSwitch          *sw,
                  GParamSpec         *pspec,
                  GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean draw_layout;
 
@@ -403,44 +405,30 @@ layout_activate (GtkSwitch          *sw,
 
   if (draw_layout)
     {
-      if (priv->layout_overlay == NULL)
+      if (vis->layout_overlay == NULL)
         {
-          priv->layout_overlay = gtk_layout_overlay_new ();
-          gtk_inspector_window_add_overlay (iw, priv->layout_overlay);
-          g_object_unref (priv->layout_overlay);
+          vis->layout_overlay = gtk_layout_overlay_new ();
+          gtk_inspector_window_add_overlay (iw, vis->layout_overlay);
+          g_object_unref (vis->layout_overlay);
         }
     }
   else
     {
-      if (priv->layout_overlay != NULL)
+      if (vis->layout_overlay != NULL)
         {
-          gtk_inspector_window_remove_overlay (iw, priv->layout_overlay);
-          priv->layout_overlay = NULL;
+          gtk_inspector_window_remove_overlay (iw, vis->layout_overlay);
+          vis->layout_overlay = NULL;
         }
     }
 
   redraw_everything ();
 }
 
-static void
-widget_resize_activate (GtkSwitch *sw)
-{
-  guint flags = gtk_get_debug_flags ();
-
-  if (gtk_switch_get_active (sw))
-    flags |= GTK_DEBUG_RESIZE;
-  else
-    flags &= ~GTK_DEBUG_RESIZE;
-
-  gtk_set_debug_flags (flags);
-}
-
 static void
 focus_activate (GtkSwitch          *sw,
                 GParamSpec         *pspec,
                 GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean focus;
 
@@ -451,19 +439,19 @@ focus_activate (GtkSwitch          *sw,
 
   if (focus)
     {
-      if (priv->focus_overlay == NULL)
+      if (vis->focus_overlay == NULL)
         {
-          priv->focus_overlay = gtk_focus_overlay_new ();
-          gtk_inspector_window_add_overlay (iw, priv->focus_overlay);
-          g_object_unref (priv->focus_overlay);
+          vis->focus_overlay = gtk_focus_overlay_new ();
+          gtk_inspector_window_add_overlay (iw, vis->focus_overlay);
+          g_object_unref (vis->focus_overlay);
         }
     }
   else
     {
-      if (priv->focus_overlay != NULL)
+      if (vis->focus_overlay != NULL)
         {
-          gtk_inspector_window_remove_overlay (iw, priv->focus_overlay);
-          priv->focus_overlay = NULL;
+          gtk_inspector_window_remove_overlay (iw, vis->focus_overlay);
+          vis->focus_overlay = NULL;
         }
     }
 
@@ -596,10 +584,10 @@ init_theme (GtkInspectorVisual *vis)
   g_list_free (list);
   g_hash_table_destroy (t);
 
-  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->priv->theme_combo), (const char **)names);
+  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->theme_combo), (const char **)names);
 
-  g_object_bind_property_full (gtk_settings_get_for_display (vis->priv->display), "gtk-theme-name",
-                               vis->priv->theme_combo, "selected",
+  g_object_bind_property_full (gtk_settings_get_for_display (vis->display), "gtk-theme-name",
+                               vis->theme_combo, "selected",
                                G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE,
                                theme_to_pos, pos_to_theme, names, (GDestroyNotify)g_strfreev);
 
@@ -608,8 +596,8 @@ init_theme (GtkInspectorVisual *vis)
       GtkWidget *row;
 
       /* theme is hardcoded, nothing we can do */
-      gtk_widget_set_sensitive (vis->priv->theme_combo, FALSE);
-      row = gtk_widget_get_ancestor (vis->priv->theme_combo, GTK_TYPE_LIST_BOX_ROW);
+      gtk_widget_set_sensitive (vis->theme_combo, FALSE);
+      row = gtk_widget_get_ancestor (vis->theme_combo, GTK_TYPE_LIST_BOX_ROW);
       gtk_widget_set_tooltip_text (row, _("Theme is hardcoded by GTK_THEME"));
     }
 }
@@ -617,9 +605,9 @@ init_theme (GtkInspectorVisual *vis)
 static void
 init_dark (GtkInspectorVisual *vis)
 {
-  g_object_bind_property (gtk_settings_get_for_display (vis->priv->display),
+  g_object_bind_property (gtk_settings_get_for_display (vis->display),
                           "gtk-application-prefer-dark-theme",
-                          vis->priv->dark_switch, "active",
+                          vis->dark_switch, "active",
                           G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
 
   if (g_getenv ("GTK_THEME") != NULL)
@@ -627,8 +615,8 @@ init_dark (GtkInspectorVisual *vis)
       GtkWidget *row;
 
       /* theme is hardcoded, nothing we can do */
-      gtk_widget_set_sensitive (vis->priv->dark_switch, FALSE);
-      row = gtk_widget_get_ancestor (vis->priv->theme_combo, GTK_TYPE_LIST_BOX_ROW);
+      gtk_widget_set_sensitive (vis->dark_switch, FALSE);
+      row = gtk_widget_get_ancestor (vis->theme_combo, GTK_TYPE_LIST_BOX_ROW);
       gtk_widget_set_tooltip_text (row, _("Theme is hardcoded by GTK_THEME"));
     }
 }
@@ -692,10 +680,10 @@ init_icons (GtkInspectorVisual *vis)
   g_hash_table_destroy (t);
   g_list_free (list);
 
-  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->priv->icon_combo), (const char **)names);
+  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->icon_combo), (const char **)names);
 
-  g_object_bind_property_full (gtk_settings_get_for_display (vis->priv->display), "gtk-icon-theme-name",
-                               vis->priv->icon_combo, "selected",
+  g_object_bind_property_full (gtk_settings_get_for_display (vis->display), "gtk-icon-theme-name",
+                               vis->icon_combo, "selected",
                                G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE,
                                theme_to_pos, pos_to_theme, names, (GDestroyNotify)g_strfreev);
 }
@@ -758,10 +746,10 @@ init_cursors (GtkInspectorVisual *vis)
   g_hash_table_destroy (t);
   g_list_free (list);
 
-  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->priv->cursor_combo), (const char **)names);
+  gtk_drop_down_set_from_strings (GTK_DROP_DOWN (vis->cursor_combo), (const char **)names);
 
-  g_object_bind_property_full (gtk_settings_get_for_display (vis->priv->display), "gtk-cursor-theme-name",
-                               vis->priv->cursor_combo, "selected",
+  g_object_bind_property_full (gtk_settings_get_for_display (vis->display), "gtk-cursor-theme-name",
+                               vis->cursor_combo, "selected",
                                G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE,
                                theme_to_pos, pos_to_theme, names, (GDestroyNotify)g_strfreev);
 }
@@ -772,7 +760,7 @@ cursor_size_changed (GtkAdjustment *adjustment, GtkInspectorVisual *vis)
   gint size;
 
   size = gtk_adjustment_get_value (adjustment);
-  g_object_set (gtk_settings_get_for_display (vis->priv->display), "gtk-cursor-theme-size", size, NULL);
+  g_object_set (gtk_settings_get_for_display (vis->display), "gtk-cursor-theme-size", size, NULL);
 }
 
 static void
@@ -780,21 +768,21 @@ init_cursor_size (GtkInspectorVisual *vis)
 {
   gint size;
 
-  g_object_get (gtk_settings_get_for_display (vis->priv->display), "gtk-cursor-theme-size", &size, NULL);
+  g_object_get (gtk_settings_get_for_display (vis->display), "gtk-cursor-theme-size", &size, NULL);
   if (size == 0)
     size = 32;
 
-  gtk_adjustment_set_value (vis->priv->scale_adjustment, (gdouble)size);
-  g_signal_connect (vis->priv->cursor_size_adjustment, "value-changed",
+  gtk_adjustment_set_value (vis->scale_adjustment, (gdouble)size);
+  g_signal_connect (vis->cursor_size_adjustment, "value-changed",
                     G_CALLBACK (cursor_size_changed), vis);
 }
 
 static void
 init_font (GtkInspectorVisual *vis)
 {
-  g_object_bind_property (gtk_settings_get_for_display (vis->priv->display),
+  g_object_bind_property (gtk_settings_get_for_display (vis->display),
                           "gtk-font-name",
-                          vis->priv->font_button, "font",
+                          vis->font_button, "font",
                           G_BINDING_BIDIRECTIONAL|G_BINDING_SYNC_CREATE);
 }
 
@@ -805,9 +793,9 @@ init_font_scale (GtkInspectorVisual *vis)
 
   scale = get_font_scale (vis);
   update_font_scale (vis, scale, TRUE, TRUE);
-  g_signal_connect (vis->priv->font_scale_adjustment, "value-changed",
+  g_signal_connect (vis->font_scale_adjustment, "value-changed",
                     G_CALLBACK (font_scale_adjustment_changed), vis);
-  g_signal_connect (vis->priv->font_scale_entry, "activate",
+  g_signal_connect (vis->font_scale_entry, "activate",
                     G_CALLBACK (font_scale_entry_activated), vis);
 }
 
@@ -818,7 +806,7 @@ scale_changed (GtkAdjustment *adjustment, GtkInspectorVisual *vis)
   gint scale;
 
   scale = gtk_adjustment_get_value (adjustment);
-  gdk_x11_display_set_surface_scale (vis->priv->display, scale);
+  gdk_x11_display_set_surface_scale (vis->display, scale);
 }
 #endif
 
@@ -826,13 +814,13 @@ static void
 init_scale (GtkInspectorVisual *vis)
 {
 #if defined (GDK_WINDOWING_X11)
-  if (GDK_IS_X11_DISPLAY (vis->priv->display))
+  if (GDK_IS_X11_DISPLAY (vis->display))
     {
       gdouble scale;
 
-      scale = gdk_monitor_get_scale_factor (gdk_x11_display_get_primary_monitor (vis->priv->display));
-      gtk_adjustment_set_value (vis->priv->scale_adjustment, scale);
-      g_signal_connect (vis->priv->scale_adjustment, "value-changed",
+      scale = gdk_monitor_get_scale_factor (gdk_x11_display_get_primary_monitor (vis->display));
+      gtk_adjustment_set_value (vis->scale_adjustment, scale);
+      g_signal_connect (vis->scale_adjustment, "value-changed",
                         G_CALLBACK (scale_changed), vis);
     }
   else
@@ -840,9 +828,9 @@ init_scale (GtkInspectorVisual *vis)
     {
       GtkWidget *row;
 
-      gtk_adjustment_set_value (vis->priv->scale_adjustment, 1);
-      gtk_widget_set_sensitive (vis->priv->hidpi_spin, FALSE);
-      row = gtk_widget_get_ancestor (vis->priv->hidpi_spin, GTK_TYPE_LIST_BOX_ROW);
+      gtk_adjustment_set_value (vis->scale_adjustment, 1);
+      gtk_widget_set_sensitive (vis->hidpi_spin, FALSE);
+      row = gtk_widget_get_ancestor (vis->hidpi_spin, GTK_TYPE_LIST_BOX_ROW);
       gtk_widget_set_tooltip_text (row, _("Backend does not support window scaling"));
     }
 }
@@ -850,8 +838,8 @@ init_scale (GtkInspectorVisual *vis)
 static void
 init_animation (GtkInspectorVisual *vis)
 {
-  g_object_bind_property (gtk_settings_get_for_display (vis->priv->display), "gtk-enable-animations",
-                          vis->priv->animation_switch, "active",
+  g_object_bind_property (gtk_settings_get_for_display (vis->display), "gtk-enable-animations",
+                          vis->animation_switch, "active",
                           G_BINDING_BIDIRECTIONAL|G_BINDING_SYNC_CREATE);
 }
 
@@ -864,14 +852,14 @@ update_slowdown (GtkInspectorVisual *vis,
   _gtk_set_slowdown (slowdown);
 
   if (update_adjustment)
-    gtk_adjustment_set_value (vis->priv->slowdown_adjustment,
+    gtk_adjustment_set_value (vis->slowdown_adjustment,
                               log2 (slowdown));
 
   if (update_entry)
     {
       gchar *str = g_strdup_printf ("%0.*f", 2, slowdown);
 
-      gtk_editable_set_text (GTK_EDITABLE (vis->priv->slowdown_entry), str);
+      gtk_editable_set_text (GTK_EDITABLE (vis->slowdown_entry), str);
       g_free (str);
     }
 }
@@ -905,9 +893,9 @@ static void
 init_slowdown (GtkInspectorVisual *vis)
 {
   update_slowdown (vis, _gtk_get_slowdown (), TRUE, TRUE);
-  g_signal_connect (vis->priv->slowdown_adjustment, "value-changed",
+  g_signal_connect (vis->slowdown_adjustment, "value-changed",
                     G_CALLBACK (slowdown_adjustment_changed), vis);
-  g_signal_connect (vis->priv->slowdown_entry, "activate",
+  g_signal_connect (vis->slowdown_entry, "activate",
                     G_CALLBACK (slowdown_entry_activated), vis);
 }
 
@@ -929,8 +917,8 @@ update_touchscreen (GtkSwitch *sw)
 static void
 init_touchscreen (GtkInspectorVisual *vis)
 {
-  gtk_switch_set_active (GTK_SWITCH (vis->priv->touchscreen_switch), (gtk_get_debug_flags () & GTK_DEBUG_TOUCHSCREEN) != 0);
-  g_signal_connect (vis->priv->touchscreen_switch, "notify::active",
+  gtk_switch_set_active (GTK_SWITCH (vis->touchscreen_switch), (gtk_get_debug_flags () & GTK_DEBUG_TOUCHSCREEN) != 0);
+  g_signal_connect (vis->touchscreen_switch, "notify::active",
                     G_CALLBACK (update_touchscreen), NULL);
 
   if (g_getenv ("GTK_TEST_TOUCHSCREEN") != 0)
@@ -938,9 +926,9 @@ init_touchscreen (GtkInspectorVisual *vis)
       GtkWidget *row;
 
       /* hardcoded, nothing we can do */
-      gtk_switch_set_active (GTK_SWITCH (vis->priv->touchscreen_switch), TRUE);
-      gtk_widget_set_sensitive (vis->priv->touchscreen_switch, FALSE);
-      row = gtk_widget_get_ancestor (vis->priv->touchscreen_switch, GTK_TYPE_LIST_BOX_ROW);
+      gtk_switch_set_active (GTK_SWITCH (vis->touchscreen_switch), TRUE);
+      gtk_widget_set_sensitive (vis->touchscreen_switch, FALSE);
+      row = gtk_widget_get_ancestor (vis->touchscreen_switch, GTK_TYPE_LIST_BOX_ROW);
       gtk_widget_set_tooltip_text (row, _("Setting is hardcoded by GTK_TEST_TOUCHSCREEN"));
     }
 }
@@ -951,17 +939,17 @@ keynav_failed (GtkWidget *widget, GtkDirectionType direction, GtkInspectorVisual
   GtkWidget *next;
 
   if (direction == GTK_DIR_DOWN &&
-      widget == vis->priv->visual_box)
-    next = vis->priv->debug_box;
+      widget == vis->visual_box)
+    next = vis->debug_box;
   else if (direction == GTK_DIR_DOWN &&
-      widget == vis->priv->debug_box)
-    next = vis->priv->misc_box;
+      widget == vis->debug_box)
+    next = vis->misc_box;
   else if (direction == GTK_DIR_UP &&
-           widget == vis->priv->debug_box)
-    next = vis->priv->visual_box;
+           widget == vis->debug_box)
+    next = vis->visual_box;
   else if (direction == GTK_DIR_UP &&
-           widget == vis->priv->misc_box)
-    next = vis->priv->debug_box;
+           widget == vis->misc_box)
+    next = vis->debug_box;
   else
     next = NULL;
 
@@ -979,59 +967,54 @@ row_activated (GtkListBox         *box,
                GtkListBoxRow      *row,
                GtkInspectorVisual *vis)
 {
-  if (gtk_widget_is_ancestor (vis->priv->dark_switch, GTK_WIDGET (row)))
+  if (gtk_widget_is_ancestor (vis->dark_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->dark_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->dark_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->animation_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->animation_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->animation_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->animation_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->fps_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->fps_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->fps_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->fps_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->updates_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->updates_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->updates_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->updates_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->fallback_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->fallback_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->fallback_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->fallback_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->baselines_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->baselines_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->baselines_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->baselines_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->layout_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->layout_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->layout_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->layout_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->resize_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->focus_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->resize_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->focus_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->focus_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->touchscreen_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->focus_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->touchscreen_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
-  else if (gtk_widget_is_ancestor (vis->priv->touchscreen_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->software_gl_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->touchscreen_switch);
-      gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
-    }
-  else if (gtk_widget_is_ancestor (vis->priv->software_gl_switch, GTK_WIDGET (row)))
-    {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->software_gl_switch);
+      GtkSwitch *sw = GTK_SWITCH (vis->software_gl_switch);
       gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
     }
 }
@@ -1039,16 +1022,16 @@ row_activated (GtkListBox         *box,
 static void
 init_gl (GtkInspectorVisual *vis)
 {
-  GdkDebugFlags flags = gdk_display_get_debug_flags (vis->priv->display);
+  GdkDebugFlags flags = gdk_display_get_debug_flags (vis->display);
 
-  gtk_switch_set_active (GTK_SWITCH (vis->priv->software_gl_switch), flags & GDK_DEBUG_GL_SOFTWARE);
+  gtk_switch_set_active (GTK_SWITCH (vis->software_gl_switch), flags & GDK_DEBUG_GL_SOFTWARE);
 
   if (flags & GDK_DEBUG_GL_DISABLE)
     {
       GtkWidget *row;
 
-      gtk_widget_set_sensitive (vis->priv->software_gl_switch, FALSE);
-      row = gtk_widget_get_ancestor (vis->priv->software_gl_switch, GTK_TYPE_LIST_BOX_ROW);
+      gtk_widget_set_sensitive (vis->software_gl_switch, FALSE);
+      row = gtk_widget_get_ancestor (vis->software_gl_switch, GTK_TYPE_LIST_BOX_ROW);
       gtk_widget_set_tooltip_text (row, _("GL rendering is disabled"));
     }
 }
@@ -1058,14 +1041,14 @@ update_gl_flag (GtkSwitch     *sw,
                 GdkDebugFlags  flag,
                 GtkInspectorVisual *vis)
 {
-  GdkDebugFlags flags = gdk_display_get_debug_flags (vis->priv->display);
+  GdkDebugFlags flags = gdk_display_get_debug_flags (vis->display);
 
   if (gtk_switch_get_active (sw))
     flags |= flag;
   else
     flags &= ~flag;
 
-  gdk_display_set_debug_flags (vis->priv->display, flags);
+  gdk_display_set_debug_flags (vis->display, flags);
 }
 
 static void
@@ -1079,7 +1062,6 @@ software_gl_activate (GtkSwitch *sw,
 static void
 gtk_inspector_visual_init (GtkInspectorVisual *vis)
 {
-  vis->priv = gtk_inspector_visual_get_instance_private (vis);
   gtk_widget_init_template (GTK_WIDGET (vis));
 }
 
@@ -1090,40 +1072,44 @@ gtk_inspector_visual_constructed (GObject *object)
 
   G_OBJECT_CLASS (gtk_inspector_visual_parent_class)->constructed (object);
 
-   g_signal_connect (vis->priv->visual_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
-   g_signal_connect (vis->priv->debug_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
-   g_signal_connect (vis->priv->misc_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
-   g_signal_connect (vis->priv->visual_box, "row-activated", G_CALLBACK (row_activated), vis);
-   g_signal_connect (vis->priv->debug_box, "row-activated", G_CALLBACK (row_activated), vis);
-   g_signal_connect (vis->priv->misc_box, "row-activated", G_CALLBACK (row_activated), vis);
+   g_signal_connect (vis->visual_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
+   g_signal_connect (vis->debug_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
+   g_signal_connect (vis->misc_box, "keynav-failed", G_CALLBACK (keynav_failed), vis);
+   g_signal_connect (vis->visual_box, "row-activated", G_CALLBACK (row_activated), vis);
+   g_signal_connect (vis->debug_box, "row-activated", G_CALLBACK (row_activated), vis);
+   g_signal_connect (vis->misc_box, "row-activated", G_CALLBACK (row_activated), vis);
 }
 
 static void
 gtk_inspector_visual_dispose (GObject *object)
-{
-  GtkInspectorVisual *vis = GTK_INSPECTOR_VISUAL (object);
-
-  g_clear_pointer (&vis->priv->swin, gtk_widget_unparent);
-
-  G_OBJECT_CLASS (gtk_inspector_visual_parent_class)->dispose (object);
-}
-
-static void
-gtk_inspector_visual_finalize (GObject *object)
 {
   GtkInspectorVisual *vis = GTK_INSPECTOR_VISUAL (object);
   GtkInspectorWindow *iw = GTK_INSPECTOR_WINDOW (gtk_widget_get_root (GTK_WIDGET (vis)));
 
-  if (vis->priv->layout_overlay)
-    gtk_inspector_window_remove_overlay (iw, vis->priv->layout_overlay);
-  if (vis->priv->updates_overlay)
-    gtk_inspector_window_remove_overlay (iw, vis->priv->updates_overlay);
-  if (vis->priv->fps_overlay)
-    gtk_inspector_window_remove_overlay (iw, vis->priv->fps_overlay);
-  if (vis->priv->focus_overlay)
-    gtk_inspector_window_remove_overlay (iw, vis->priv->focus_overlay);
+  g_clear_pointer (&vis->swin, gtk_widget_unparent);
 
-  G_OBJECT_CLASS (gtk_inspector_visual_parent_class)->finalize (object);
+  if (vis->layout_overlay)
+    {
+      gtk_inspector_window_remove_overlay (iw, vis->layout_overlay);
+      vis->layout_overlay = NULL;
+    }
+  if (vis->updates_overlay)
+    {
+      gtk_inspector_window_remove_overlay (iw, vis->updates_overlay);
+      vis->updates_overlay = NULL;
+    }
+  if (vis->fps_overlay)
+    {
+      gtk_inspector_window_remove_overlay (iw, vis->fps_overlay);
+      vis->fps_overlay = NULL;
+    }
+  if (vis->focus_overlay)
+    {
+      gtk_inspector_window_remove_overlay (iw, vis->focus_overlay);
+      vis->focus_overlay = NULL;
+    }
+
+  G_OBJECT_CLASS (gtk_inspector_visual_parent_class)->dispose (object);
 }
 
 static void
@@ -1134,38 +1120,36 @@ gtk_inspector_visual_class_init (GtkInspectorVisualClass *klass)
 
   object_class->constructed = gtk_inspector_visual_constructed;
   object_class->dispose = gtk_inspector_visual_dispose;
-  object_class->finalize = gtk_inspector_visual_finalize;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/visual.ui");
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, swin);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, direction_combo);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, theme_combo);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, dark_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, cursor_combo);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, cursor_size_spin);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, cursor_size_adjustment);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, icon_combo);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, hidpi_spin);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, scale_adjustment);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, animation_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, slowdown_adjustment);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, slowdown_entry);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, touchscreen_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, visual_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, debug_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, font_button);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, misc_box);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, software_gl_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, font_scale_entry);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, font_scale_adjustment);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, fps_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, updates_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, fallback_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, baselines_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, layout_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, resize_switch);
-  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorVisual, focus_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, swin);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, direction_combo);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, theme_combo);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, dark_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, cursor_combo);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, cursor_size_spin);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, cursor_size_adjustment);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, icon_combo);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, hidpi_spin);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, scale_adjustment);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, animation_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, slowdown_adjustment);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, slowdown_entry);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, touchscreen_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, visual_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, debug_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, font_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, misc_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, software_gl_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, font_scale_entry);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, font_scale_adjustment);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, fps_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, updates_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, fallback_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, baselines_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, layout_switch);
+  gtk_widget_class_bind_template_child (widget_class, GtkInspectorVisual, focus_switch);
 
   gtk_widget_class_bind_template_callback (widget_class, fps_activate);
   gtk_widget_class_bind_template_callback (widget_class, updates_activate);
@@ -1173,7 +1157,6 @@ gtk_inspector_visual_class_init (GtkInspectorVisualClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, direction_changed);
   gtk_widget_class_bind_template_callback (widget_class, baselines_activate);
   gtk_widget_class_bind_template_callback (widget_class, layout_activate);
-  gtk_widget_class_bind_template_callback (widget_class, widget_resize_activate);
   gtk_widget_class_bind_template_callback (widget_class, focus_activate);
   gtk_widget_class_bind_template_callback (widget_class, software_gl_activate);
 
@@ -1184,7 +1167,7 @@ void
 gtk_inspector_visual_set_display  (GtkInspectorVisual *vis,
                                    GdkDisplay *display)
 {
-  vis->priv->display = display;
+  vis->display = display;
 
   init_direction (vis);
   init_theme (vis);

gtk/inspector/visual.h

@@ -18,28 +18,13 @@
 #ifndef _GTK_INSPECTOR_VISUAL_H_
 #define _GTK_INSPECTOR_VISUAL_H_
 
-#include <gtk/gtkscrolledwindow.h>
+#include <gtk/gtkwidget.h>
 
 #define GTK_TYPE_INSPECTOR_VISUAL            (gtk_inspector_visual_get_type())
 #define GTK_INSPECTOR_VISUAL(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisual))
-#define GTK_INSPECTOR_VISUAL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisualClass))
 #define GTK_INSPECTOR_IS_VISUAL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_VISUAL))
-#define GTK_INSPECTOR_IS_VISUAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_VISUAL))
-#define GTK_INSPECTOR_VISUAL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisualClass))
 
-
-typedef struct _GtkInspectorVisualPrivate GtkInspectorVisualPrivate;
-
-typedef struct _GtkInspectorVisual
-{
-  GtkWidget parent;
-  GtkInspectorVisualPrivate *priv;
-} GtkInspectorVisual;
-
-typedef struct _GtkInspectorVisualClass
-{
-  GtkWidgetClass parent_class;
-} GtkInspectorVisualClass;
+typedef struct _GtkInspectorVisual GtkInspectorVisual;
 
 G_BEGIN_DECLS
 

gtk/inspector/visual.ui

@@ -560,35 +560,6 @@
                             </child>
                           </object>
                         </child>
-                        <child>
-                          <object class="GtkListBoxRow">
-                            <child>
-                              <object class="GtkBox">
-                                <property name="margin-start">10</property>
-                                <property name="margin-end">10</property>
-                                <property name="margin-top">10</property>
-                                <property name="margin-bottom">10</property>
-                                <property name="spacing">40</property>
-                                <child>
-                                  <object class="GtkLabel" id="resize_label">
-                                    <property name="label" translatable="yes">Show Widget Resizes</property>
-                                    <property name="halign">start</property>
-                                    <property name="valign">baseline</property>
-                                    <property name="xalign">0.0</property>
-                                  </object>
-                                </child>
-                                <child>
-                                  <object class="GtkSwitch" id="resize_switch">
-                                    <property name="halign">end</property>
-                                    <property name="valign">baseline</property>
-                                    <property name="hexpand">1</property>
-                                    <signal name="notify::active" handler="widget_resize_activate"/>
-                                  </object>
-                                </child>
-                              </object>
-                            </child>
-                          </object>
-                        </child>
                         <child>
                           <object class="GtkListBoxRow">
                             <child>
@@ -712,7 +683,6 @@
       <widget name="fallback_label"/>
       <widget name="baselines_label"/>
       <widget name="layout_label"/>
-      <widget name="resize_label"/>
       <widget name="focus_label"/>
       <widget name="touchscreen_label"/>
       <widget name="software_gl_label"/>

gtk/inspector/window.c

@@ -226,8 +226,6 @@ gtk_inspector_window_init (GtkInspectorWindow *iw)
                                iw,
                                NULL);
 
-  gtk_window_set_hide_on_close (GTK_WINDOW (iw), TRUE);
-
   gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw));
 
   extension_point = g_io_extension_point_lookup ("gtk-inspector-page");
@@ -302,6 +300,7 @@ gtk_inspector_window_dispose (GObject *object)
 
   g_object_set_data (G_OBJECT (iw->inspected_display), "-gtk-inspector", NULL);
 
+  g_clear_pointer (&iw->top_stack, gtk_widget_unparent);
   g_clear_object (&iw->flash_overlay);
   g_clear_pointer (&iw->objects, g_array_unref);
 

gtk/theme/Adwaita/_common.scss

@@ -1465,30 +1465,6 @@ headerbar {
   }
 }
 
-.background:not(.tiled):not(.maximized):not(.solid-csd) .titlebar,
-.background:not(.tiled-top):not(.maximized):not(.solid-csd) .titlebar,
-.background:not(.tiled-left):not(.maximized):not(.solid-csd) .titlebar,
-.background:not(.tiled-right):not(.maximized):not(.solid-csd) .titlebar,
-.background:not(.tiled-bottom):not(.maximized):not(.solid-csd) .titlebar {
-  &:backdrop, & {
-    border-top-left-radius: 7px;
-    border-top-right-radius: 7px;
-  }
-}
-
-headerbar { // headerbar border rounding
-  window:not(.tiled):not(.maximized):not(.fullscreen):not(.solid-csd) separator:first-child + &, // tackles the paned container case
-  window:not(.tiled):not(.maximized):not(.fullscreen):not(.solid-csd) &:first-child { &:backdrop, & { border-top-left-radius: 7px; }}
-  window:not(.tiled):not(.maximized):not(.fullscreen):not(.solid-csd) &:last-child { &:backdrop, & { border-top-right-radius: 7px; }}
-  window:not(.tiled):not(.maximized):not(.fullscreen):not(.solid-csd) stack & { // tackles the stacked headerbars case
-    &:first-child, &:last-child {
-      &:backdrop, & {
-        border-top-left-radius: 7px;
-        border-top-right-radius: 7px;
-      }
-    }
-  }
-}
 
 .titlebar:not(headerbar) {
   window.csd > & {

tests/meson.build

@@ -1,5 +1,6 @@
 gtk_tests = [
   # testname, optional extra sources
+  ['testrange'],
   ['testdropdown'],
   ['rendernode'],
   ['rendernode-create-tests'],

tests/testrange.c

@@ -0,0 +1,658 @@
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE (DemoSlider, demo_slider, DEMO, SLIDER, GtkWidget)
+
+struct _DemoSlider
+{
+  GtkWidget parent_instance;
+};
+
+struct _DemoSliderClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DECLARE_FINAL_TYPE (DemoHighlight, demo_highlight, DEMO, HIGHLIGHT, GtkWidget)
+
+struct _DemoHighlight
+{
+  GtkWidget parent_instance;
+};
+
+struct _DemoHighlightClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DECLARE_FINAL_TYPE (DemoTrough, demo_trough, DEMO, TROUGH, GtkWidget)
+
+struct _DemoTrough
+{
+  GtkWidget parent_instance;
+};
+
+struct _DemoTroughClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DECLARE_FINAL_TYPE (DemoWidget, demo_widget, DEMO, WIDGET, GtkWidget)
+
+struct _DemoWidget
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *trough;
+  GtkWidget *highlight;
+  GtkWidget *min_slider;
+  GtkWidget *max_slider;
+
+  GtkWidget *grab_location;
+
+  double range_min;
+  double range_max;
+  double min_value;
+  double max_value;
+
+  gboolean shift;
+};
+
+enum
+{
+  PROP_RANGE_MIN = 1,
+  PROP_RANGE_MAX,
+  PROP_MIN_VALUE,
+  PROP_MAX_VALUE,
+  NUM_PROPERTIES
+};
+
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL };
+
+struct _DemoWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (DemoSlider, demo_slider, GTK_TYPE_WIDGET)
+
+static void
+demo_slider_init (DemoSlider *slider)
+{
+}
+
+static void
+demo_slider_class_init (DemoSliderClass *class)
+{
+  gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (class), "slider");
+}
+
+static GtkWidget *
+demo_slider_new (void)
+{
+  return g_object_new (demo_slider_get_type (), NULL);
+}
+
+G_DEFINE_TYPE (DemoHighlight, demo_highlight, GTK_TYPE_WIDGET)
+
+static void
+demo_highlight_init (DemoHighlight *highlight)
+{
+}
+
+static void
+demo_highlight_class_init (DemoHighlightClass *class)
+{
+  gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (class), "highlight");
+}
+
+static GtkWidget *
+demo_highlight_new (void)
+{
+  return g_object_new (demo_highlight_get_type (), NULL);
+}
+
+G_DEFINE_TYPE (DemoTrough, demo_trough, GTK_TYPE_WIDGET)
+
+static void
+demo_trough_init (DemoTrough *trough)
+{
+}
+
+static void
+demo_trough_measure (GtkWidget      *widget,
+                     GtkOrientation  orientation,
+                     int             for_size,
+                     int            *minimum,
+                     int            *natural,
+                     int            *minimum_baseline,
+                     int            *natural_baseline)
+{
+  DemoWidget *demo = DEMO_WIDGET (gtk_widget_get_parent (widget));
+  int min1, nat1;
+  int min2, nat2;
+  int min3, nat3;
+
+  gtk_widget_measure (demo->min_slider,
+                      orientation, -1,
+                      &min1, &nat1,
+                      NULL, NULL);
+
+  gtk_widget_measure (demo->max_slider,
+                      orientation, -1,
+                      &min2, &nat2,
+                      NULL, NULL);
+
+  gtk_widget_measure (demo->highlight,
+                      orientation, for_size,
+                      &min3, &nat3,
+                      NULL, NULL);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      *minimum = MAX (min1 + min2, min3);
+      *natural = MAX (nat1 + nat2, nat3);
+    }
+  else
+    {
+      *minimum = MAX (MAX (min1, min2), min3);
+      *natural = MAX (MAX (nat1, nat2), min3);
+    }
+}
+
+static void
+allocate_slider (DemoWidget *demo,
+                 GtkWidget  *slider,
+                 int         x)
+{
+  int trough_height;
+  int width, height;
+  int y;
+
+  gtk_widget_measure (slider,
+                      GTK_ORIENTATION_HORIZONTAL, -1,
+                      &width, NULL,
+                      NULL, NULL);
+  gtk_widget_measure (slider,
+                      GTK_ORIENTATION_VERTICAL, -1,
+                      &height, NULL,
+                      NULL, NULL);
+
+  trough_height = gtk_widget_get_height (demo->trough);
+
+  y = floor ((trough_height - height) / 2);
+
+  gtk_widget_size_allocate (slider,
+                            &(GtkAllocation) { x, y, width, height},
+                            -1);
+}
+
+static void
+demo_trough_size_allocate (GtkWidget *widget,
+                           int        width,
+                           int        height,
+                           int        baseline)
+{
+  DemoWidget *demo = DEMO_WIDGET (gtk_widget_get_parent (widget));
+  int min, max;
+
+  min = floor (width * (demo->min_value - demo->range_min) / (demo->range_max - demo->range_min));
+  max = floor (width * (demo->max_value - demo->range_min) / (demo->range_max - demo->range_min));
+
+  allocate_slider (demo, demo->min_slider, min);
+  allocate_slider (demo, demo->max_slider, max);
+
+  gtk_widget_size_allocate (demo->highlight,
+                            &(GtkAllocation) { min, 0, max - min, height},
+                            -1);
+}
+
+static void
+demo_trough_class_init (DemoTroughClass *class)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  widget_class->measure = demo_trough_measure;
+  widget_class->size_allocate = demo_trough_size_allocate;
+
+  gtk_widget_class_set_css_name (widget_class, "trough");
+}
+
+static GtkWidget *
+demo_trough_new (void)
+{
+  return g_object_new (demo_trough_get_type (), NULL);
+}
+
+G_DEFINE_TYPE (DemoWidget, demo_widget, GTK_TYPE_WIDGET)
+
+static void
+click_gesture_pressed (GtkGestureClick *gesture,
+                       guint            n_press,
+                       double           x,
+                       double           y,
+                       DemoWidget      *demo)
+{
+  guint button;
+  GdkModifierType state;
+
+  demo->grab_location = gtk_widget_pick (GTK_WIDGET (demo), x, y, 0);
+
+  button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
+  state = gtk_event_controller_get_current_event_state (GTK_EVENT_CONTROLLER (gesture));
+
+  demo->shift = (button == GDK_BUTTON_PRIMARY && ((state & GDK_SHIFT_MASK) != 0)) ||
+                 button == GDK_BUTTON_SECONDARY;
+}
+
+static void
+click_gesture_released (GtkGestureClick *gesture,
+                        guint            n_press,
+                        double           x,
+                        double           y,
+                        DemoWidget      *demo)
+{
+  demo->grab_location = NULL;
+}
+
+static void
+drag_gesture_begin (GtkGestureDrag *gesture,
+                    double          offset_x,
+                    double          offset_y,
+                    DemoWidget     *demo)
+{
+  if (demo->grab_location == demo->min_slider ||
+      demo->grab_location == demo->max_slider)
+    gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
+}
+
+static void
+drag_gesture_update (GtkGestureDrag *gesture,
+                     double          offset_x,
+                     double          offset_y,
+                     DemoWidget     *demo)
+{
+  double start_x, start_y;
+  int width;
+  double value;
+  double size;
+
+  gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
+
+  width = gtk_widget_get_width (GTK_WIDGET (demo));
+
+  value = ((start_x + offset_x) / width) * (demo->range_max - demo->range_min) + demo->range_min;
+  value = CLAMP (value, demo->range_min, demo->range_max);
+  size = demo->max_value - demo->min_value;
+
+  if (demo->shift)
+    {
+      if (demo->grab_location == demo->min_slider)
+        {
+          demo->max_value = MIN (demo->range_max, value + size);
+          demo->min_value = demo->max_value - size;
+        }
+      else if (demo->grab_location == demo->max_slider)
+        {
+          demo->min_value = MAX (demo->range_min, value - size);
+          demo->max_value = demo->min_value + size;
+        }
+    }
+  else
+    {
+      if (demo->grab_location == demo->min_slider)
+        {
+          demo->min_value = value;
+          demo->max_value = MAX (demo->max_value, value);
+        }
+      else if (demo->grab_location == demo->max_slider)
+        {
+          demo->min_value = MIN (demo->min_value, value);
+          demo->max_value = value;
+        }
+    }
+
+  g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MIN_VALUE]);
+  g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MAX_VALUE]);
+
+  gtk_widget_queue_allocate (GTK_WIDGET (demo));
+}
+
+static void
+demo_widget_init (DemoWidget *demo)
+{
+  GtkGesture *click_gesture, *drag_gesture;
+
+  demo->range_min = 0;
+  demo->range_max = 0;
+  demo->min_value = 0;
+  demo->max_value = 0;
+
+  demo->trough = demo_trough_new ();
+  gtk_widget_set_parent (demo->trough, GTK_WIDGET (demo));
+  demo->highlight = demo_highlight_new ();
+  gtk_widget_set_parent (demo->highlight, demo->trough);
+  demo->min_slider = demo_slider_new ();
+  gtk_widget_set_parent (demo->min_slider, demo->trough);
+  demo->max_slider = demo_slider_new ();
+  gtk_widget_set_parent (demo->max_slider, demo->trough);
+
+  drag_gesture = gtk_gesture_drag_new ();
+  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (drag_gesture), 0);
+  g_signal_connect (drag_gesture, "drag-begin", G_CALLBACK (drag_gesture_begin), demo);
+  g_signal_connect (drag_gesture, "drag-update", G_CALLBACK (drag_gesture_update), demo);
+  gtk_widget_add_controller (GTK_WIDGET (demo), GTK_EVENT_CONTROLLER (drag_gesture));
+
+  click_gesture = gtk_gesture_click_new ();
+  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (click_gesture), 0);
+  g_signal_connect (click_gesture, "pressed", G_CALLBACK (click_gesture_pressed), demo);
+  g_signal_connect (click_gesture, "released", G_CALLBACK (click_gesture_released), demo);
+  gtk_widget_add_controller (GTK_WIDGET (demo), GTK_EVENT_CONTROLLER (click_gesture));
+
+  gtk_gesture_group (click_gesture, drag_gesture);
+}
+
+static void
+demo_widget_measure (GtkWidget      *widget,
+                     GtkOrientation  orientation,
+                     int             for_size,
+                     int            *minimum,
+                     int            *natural,
+                     int            *minimum_baseline,
+                     int            *natural_baseline)
+{
+  DemoWidget *demo = DEMO_WIDGET (widget);
+
+  gtk_widget_measure (demo->trough,
+                      orientation, -1,
+                      minimum, natural,
+                      NULL, NULL);
+}
+
+static void
+demo_widget_size_allocate (GtkWidget *widget,
+                           int        width,
+                           int        height,
+                           int        baseline)
+{
+  DemoWidget *demo = DEMO_WIDGET (widget);
+  int min_height;
+
+  gtk_widget_measure (demo->trough,
+                      GTK_ORIENTATION_VERTICAL, -1,
+                      &min_height, NULL,
+                      NULL, NULL);
+
+  gtk_widget_size_allocate (demo->trough,
+                            &(GtkAllocation) { 0, 0, width, min_height},
+                            -1);
+}
+
+static void
+demo_widget_dispose (GObject *object)
+{
+  DemoWidget *demo = DEMO_WIDGET (object);
+
+  g_clear_pointer (&demo->trough, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (demo_widget_parent_class)->dispose (object);
+}
+
+static void
+demo_widget_set_range (DemoWidget *demo,
+                       double      range_min,
+                       double      range_max)
+{
+  double value;
+
+  g_return_if_fail (range_min <= range_max);
+
+  g_object_freeze_notify (G_OBJECT (demo));
+
+  if (demo->range_min != range_min)
+    {
+      demo->range_min = range_min;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_RANGE_MIN]);
+    }
+
+  if (demo->range_max != range_max)
+    {
+      demo->range_max = range_max;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_RANGE_MAX]);
+    }
+
+  value = CLAMP (demo->min_value, range_min, range_max);
+  if (demo->min_value != value)
+    {
+      demo->min_value = value;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MIN_VALUE]);
+    }
+
+  value = CLAMP (demo->max_value, range_min, range_max);
+  if (demo->max_value != value)
+    {
+      demo->max_value = value;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MAX_VALUE]);
+    }
+
+  g_object_thaw_notify (G_OBJECT (demo));
+}
+
+static void
+demo_widget_set_values (DemoWidget *demo,
+                        double      min_value,
+                        double      max_value)
+{
+  double value;
+
+  g_return_if_fail (min_value <= max_value);
+
+  g_object_freeze_notify (G_OBJECT (demo));
+
+  value = CLAMP (min_value, demo->range_min, demo->range_max);
+  if (demo->min_value != value)
+    {
+      demo->min_value = value;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MIN_VALUE]);
+    }
+
+  value = CLAMP (max_value, demo->range_min, demo->range_max);
+  if (demo->max_value != value)
+    {
+      demo->max_value = value;
+      g_object_notify_by_pspec (G_OBJECT (demo), properties[PROP_MAX_VALUE]);
+    }
+
+  g_object_thaw_notify (G_OBJECT (demo));
+}
+
+static void
+demo_widget_set_property (GObject      *object,
+                          guint         prop_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
+{
+  DemoWidget *demo = DEMO_WIDGET (object);
+  double v;
+
+  switch (prop_id)
+    {
+    case PROP_RANGE_MIN:
+      v = g_value_get_double (value);
+      demo_widget_set_range (demo, v, MAX (v, demo->range_max));
+      break;
+
+    case PROP_RANGE_MAX:
+      v = g_value_get_double (value);
+      demo_widget_set_range (demo, MIN (v, demo->range_min), v);
+      break;
+
+    case PROP_MIN_VALUE:
+      v = g_value_get_double (value);
+      demo_widget_set_values (demo, v, MAX (v, demo->max_value));
+      break;
+
+    case PROP_MAX_VALUE:
+      v = g_value_get_double (value);
+      demo_widget_set_values (demo, MIN (v, demo->min_value), v);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+demo_widget_get_property (GObject    *object,
+                          guint       prop_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
+{
+  DemoWidget *demo = DEMO_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_RANGE_MIN:
+      g_value_set_double (value, demo->range_min);
+      break;
+
+    case PROP_RANGE_MAX:
+      g_value_set_double (value, demo->range_max);
+      break;
+
+    case PROP_MIN_VALUE:
+      g_value_set_double (value, demo->min_value);
+      break;
+
+    case PROP_MAX_VALUE:
+      g_value_set_double (value, demo->max_value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+demo_widget_class_init (DemoWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = demo_widget_dispose;
+  object_class->set_property = demo_widget_set_property;
+  object_class->get_property = demo_widget_get_property;
+
+  widget_class->measure = demo_widget_measure;
+  widget_class->size_allocate = demo_widget_size_allocate;
+
+  properties[PROP_RANGE_MIN] = g_param_spec_double ("range-min",
+                                                    "Range Min",
+                                                    "Range Min",
+                                                    -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+                                                    G_PARAM_READWRITE);
+  properties[PROP_RANGE_MAX] = g_param_spec_double ("range-max",
+                                                    "Range Max",
+                                                    "Range Max",
+                                                    -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+                                                    G_PARAM_READWRITE);
+  properties[PROP_MIN_VALUE] = g_param_spec_double ("min-value",
+                                                    "Min Value",
+                                                    "Min Value",
+                                                    -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+                                                    G_PARAM_READWRITE);
+  properties[PROP_MAX_VALUE] = g_param_spec_double ("max-value",
+                                                    "Max Value",
+                                                    "Max Value",
+                                                    -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+                                                    G_PARAM_READWRITE);
+
+  gtk_widget_class_set_css_name (widget_class, "scale");
+}
+
+static GtkWidget *
+demo_widget_new (void)
+{
+  return g_object_new (demo_widget_get_type (), NULL);
+}
+
+static void
+update_range_label (GObject    *object,
+                    GParamSpec *pspec,
+                    gpointer    data)
+{
+  DemoWidget *demo = DEMO_WIDGET (object);
+
+  if (pspec->name == g_intern_static_string ("range-min") ||
+      pspec->name == g_intern_static_string ("range-max"))
+    {
+      char *text;
+
+      text = g_strdup_printf ("Allowed values: [%.1f, %.1f]\n", demo->range_min, demo->range_max);
+      gtk_label_set_label (GTK_LABEL (data), text);
+      g_free (text);
+    }
+}
+
+static void
+update_values_label (GObject    *object,
+                     GParamSpec *pspec,
+                     gpointer    data)
+{
+  DemoWidget *demo = DEMO_WIDGET (object);
+
+  if (pspec->name == g_intern_static_string ("min-value") ||
+      pspec->name == g_intern_static_string ("max-value"))
+    {
+      char *text;
+
+      text = g_strdup_printf ("Selected range: [%.1f, %.1f]\n", demo->min_value, demo->max_value);
+      gtk_label_set_label (GTK_LABEL (data), text);
+      g_free (text);
+    }
+}
+
+int
+main (int argc, char *argv[])
+{
+  GtkWindow *window;
+  GtkWidget *box;
+  GtkWidget *demo;
+  GtkWidget *label;
+
+  gtk_init ();
+
+  window = GTK_WINDOW (gtk_window_new ());
+  gtk_window_set_title (window, "Pick a range");
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
+  gtk_window_set_child (window, box);
+
+  demo = demo_widget_new ();
+  gtk_widget_set_halign (demo, GTK_ALIGN_FILL);
+  gtk_widget_set_valign (demo, GTK_ALIGN_CENTER);
+  gtk_widget_set_hexpand (demo, TRUE);
+
+  gtk_box_append (GTK_BOX (box), demo);
+
+  label = gtk_label_new ("");
+  gtk_label_set_xalign (GTK_LABEL (label), 0);
+  g_signal_connect (demo, "notify", G_CALLBACK (update_range_label), label);
+  gtk_box_append (GTK_BOX (box), label);
+
+  label = gtk_label_new ("");
+  gtk_label_set_xalign (GTK_LABEL (label), 0);
+  g_signal_connect (demo, "notify", G_CALLBACK (update_values_label), label);
+  gtk_box_append (GTK_BOX (box), label);
+
+  demo_widget_set_range (DEMO_WIDGET (demo), 0, 1000);
+  demo_widget_set_values (DEMO_WIDGET (demo), 100, 500);
+
+  gtk_window_present (window);
+
+  while (g_list_model_get_n_items (gtk_window_get_toplevels ()) > 0)
+    g_main_context_iteration (NULL, TRUE);
+
+  return 0;
+}

tests/testwidgettransforms.c

@@ -320,7 +320,7 @@ main (int argc, char **argv)
   gtk_button_set_label (GTK_BUTTON (toggle_button), "Picking");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_button), do_picking);
   g_signal_connect (toggle_button, "toggled", G_CALLBACK (toggled_cb), NULL);
-  gtk_box_append (GTK_BOX (titlebar), toggle_button);
+  gtk_header_bar_pack_start (GTK_HEADER_BAR (titlebar), toggle_button);
 
   test_widget = gtk_button_new ();
   gtk_widget_set_size_request (test_widget, TEST_WIDGET_MIN_SIZE, TEST_WIDGET_MIN_SIZE);
@@ -332,7 +332,7 @@ main (int argc, char **argv)
   gtk_widget_set_halign (test_child, GTK_ALIGN_CENTER);
   gtk_widget_set_valign (test_child, GTK_ALIGN_CENTER);
   gtk_widget_set_size_request (test_child, TEST_WIDGET_MIN_SIZE / 2, TEST_WIDGET_MIN_SIZE / 2);
-  gtk_box_append (GTK_BOX (test_widget), test_child);
+  gtk_button_set_child (GTK_BUTTON (test_widget), test_child);
 
 
   gtk_transform_tester_set_test_widget (GTK_TRANSFORM_TESTER (transform_tester), test_widget);

testsuite/gsk/compare/clip-nested1.node

@@ -1,48 +1,48 @@
 transform {
-transform: scale(8);
-child:container {
+  transform: scale(8);
+  child:container {
 
-rounded-clip {
-  clip: 0 0 50 50 / 30 0 0 0;
-  child: rounded-clip {
-    clip: 0 0 100 100 / 0;
-    child: color {
-      bounds: 0 0 50 50;
-      color: teal;
+    rounded-clip {
+      clip: 0 0 50 50 / 30 0 0 0;
+      child: rounded-clip {
+        clip: 0 0 100 100 / 0;
+        child: color {
+          bounds: 0 0 50 50;
+          color: teal;
+        }
+      }
     }
+
+    debug {
+      message: "Clipped-out area";
+      child: container {
+         color {
+           color: black;
+           bounds: 0 16 5 14;
+         }
+         color {
+           color: black;
+           bounds: 3 12 5 5;
+         }
+         color {
+           color: black;
+           bounds: 6 7 5 5;
+         }
+         color {
+           color: black;
+           bounds: 10 3 5 5;
+         }
+         color {
+           color: black;
+           bounds: 15 0 5 5;
+         }
+         color {
+           color: black;
+           bounds: 19 0 14 2;
+         }
+      }
+    }
+
+
   }
 }
-
-debug {
-  message: "Clipped-out area";
-  child: container {
-     color {
-       color: black;
-       bounds: 0 16 5 14;
-     }
-     color {
-       color: black;
-       bounds: 3 12 5 5;
-     }
-     color {
-       color: black;
-       bounds: 6 7 5 5;
-     }
-     color {
-       color: black;
-       bounds: 10 3 5 5;
-     }
-     color {
-       color: black;
-       bounds: 15 0 5 5;
-     }
-     color {
-       color: black;
-       bounds: 19 0 14 2;
-     }
-  }
-}
-
-
-}
-}