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"));

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/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/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/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;
@@ -98,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,
@@ -150,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
@@ -168,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);
 
@@ -180,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);
 
@@ -201,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);
     }
 }
@@ -244,7 +251,6 @@ fps_activate (GtkSwitch          *sw,
               GParamSpec         *pspec,
               GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean fps;
 
@@ -255,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;
         }
     }
 
@@ -279,7 +285,6 @@ updates_activate (GtkSwitch          *sw,
                   GParamSpec         *pspec,
                   GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean updates;
 
@@ -290,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;
         }
     }
 
@@ -356,7 +361,6 @@ baselines_activate (GtkSwitch          *sw,
                     GParamSpec         *pspec,
                     GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean baselines;
 
@@ -367,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;
         }
     }
 
@@ -391,7 +395,6 @@ layout_activate (GtkSwitch          *sw,
                  GParamSpec         *pspec,
                  GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean draw_layout;
 
@@ -402,19 +405,19 @@ 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;
         }
     }
 
@@ -426,7 +429,6 @@ focus_activate (GtkSwitch          *sw,
                 GParamSpec         *pspec,
                 GtkInspectorVisual *vis)
 {
-  GtkInspectorVisualPrivate *priv = vis->priv;
   GtkInspectorWindow *iw;
   gboolean focus;
 
@@ -437,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;
         }
     }
 
@@ -582,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);
 
@@ -594,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"));
     }
 }
@@ -603,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)
@@ -613,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"));
     }
 }
@@ -678,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);
 }
@@ -744,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);
 }
@@ -758,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
@@ -766,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);
 }
 
@@ -791,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);
 }
 
@@ -804,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
 
@@ -812,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
@@ -826,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"));
     }
 }
@@ -836,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);
 }
 
@@ -850,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);
     }
 }
@@ -891,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);
 }
 
@@ -915,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)
@@ -924,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"));
     }
 }
@@ -937,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;
 
@@ -965,54 +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->focus_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->focus_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->focus_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->touchscreen_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->touchscreen_switch, GTK_WIDGET (row)))
     {
-      GtkSwitch *sw = GTK_SWITCH (vis->priv->touchscreen_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->software_gl_switch, GTK_WIDGET (row)))
+  else if (gtk_widget_is_ancestor (vis->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));
     }
 }
@@ -1020,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"));
     }
 }
@@ -1039,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
@@ -1060,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));
 }
 
@@ -1071,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
@@ -1115,37 +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, 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);
@@ -1163,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/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);
 

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;
+}