Merge branch 'inspector-action-fixes' into 'main'

actionmuxer: Make the compiler warn

See merge request GNOME/gtk!5800

10 files changed, 345 insertions, 149 deletions

diff --git a/gtk/gtkactionmuxer.c b/gtk/gtkactionmuxer.c
index 5fe2916dfd..33e8c0542d 100644
--- a/gtk/gtkactionmuxer.c
+++ b/gtk/gtkactionmuxer.c
@@ -232,6 +232,8 @@ gtk_action_muxer_list_actions (GtkActionMuxer *muxer,
   GHashTable *actions;
   char **keys;
 
+  g_return_val_if_fail (GTK_IS_ACTION_MUXER (muxer), NULL);
+
   actions = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
   for ( ; muxer != NULL; muxer = muxer->parent)
diff --git a/gtk/gtkactionmuxerprivate.h b/gtk/gtkactionmuxerprivate.h
index a7e03f0078..a725a8295c 100644
--- a/gtk/gtkactionmuxerprivate.h
+++ b/gtk/gtkactionmuxerprivate.h
@@ -73,7 +73,7 @@ gboolean                gtk_action_muxer_query_action                   (GtkActi
                                                                          const GVariantType **parameter_type,
                                                                          const GVariantType **state_type,
                                                                          GVariant           **state_hint,
-                                                                         GVariant           **state);
+                                                                         GVariant           **state) G_GNUC_WARN_UNUSED_RESULT;
 void                    gtk_action_muxer_activate_action                (GtkActionMuxer      *muxer,
                                                                          const char          *action_name,
                                                                          GVariant            *parameter);
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 1861264be2..de42ea674a 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -9233,7 +9233,8 @@ append_bubble_item (GtkTextView *text_view,
   muxer = _gtk_widget_get_action_muxer (GTK_WIDGET (text_view), FALSE);
   if (muxer)
     {
-      gtk_action_muxer_query_action (muxer, action_name, &enabled, &param_type, &state_type, NULL, NULL);
+      if (!gtk_action_muxer_query_action (muxer, action_name, &enabled, &param_type, &state_type, NULL, NULL))
+        return;
 
       if (!enabled)
         return;
diff --git a/gtk/inspector/action-editor.c b/gtk/inspector/action-editor.c
index 616a592096..ba838fbaf7 100644
--- a/gtk/inspector/action-editor.c
+++ b/gtk/inspector/action-editor.c
@@ -53,8 +53,7 @@ enum
 {
   PROP_0,
   PROP_OWNER,
-  PROP_NAME,
-  PROP_SIZEGROUP
+  PROP_NAME
 };
 
 G_DEFINE_TYPE (GtkInspectorActionEditor, gtk_inspector_action_editor, GTK_TYPE_WIDGET)
@@ -73,6 +72,7 @@ activate_action (GtkWidget                *button,
     g_action_group_activate_action (G_ACTION_GROUP (r->owner), r->name, parameter);
   else if (GTK_IS_ACTION_MUXER (r->owner))
     gtk_action_muxer_activate_action (GTK_ACTION_MUXER (r->owner), r->name, parameter);
+
   update_widgets (r);
 }
 
@@ -97,13 +97,17 @@ state_changed (GtkWidget *editor,
   GVariant *value;
 
   value = gtk_inspector_variant_editor_get_value (editor);
-  if (value)
-    {
-      if (G_IS_ACTION_GROUP (r->owner))
-        g_action_group_change_action_state (G_ACTION_GROUP (r->owner), r->name, value);
-      else if (GTK_IS_ACTION_MUXER (r->owner))
-        gtk_action_muxer_change_action_state (GTK_ACTION_MUXER (r->owner), r->name, value);
-    }
+  if (!value)
+    return;
+
+  g_variant_ref_sink (value);
+
+  if (G_IS_ACTION_GROUP (r->owner))
+    g_action_group_change_action_state (G_ACTION_GROUP (r->owner), r->name, value);
+  else if (GTK_IS_ACTION_MUXER (r->owner))
+    gtk_action_muxer_change_action_state (GTK_ACTION_MUXER (r->owner), r->name, value);
+
+  g_variant_unref (value);
 }
 
 static void
@@ -141,62 +145,38 @@ gtk_inspector_action_editor_init (GtkInspectorActionEditor *r)
 }
 
 static void
-update_enabled (GtkInspectorActionEditor *r,
-                gboolean                  enabled)
-{
-  r->enabled = enabled;
-  if (r->parameter_entry)
-    {
-      gtk_widget_set_sensitive (r->parameter_entry, enabled);
-      parameter_changed (r->parameter_entry, r);
-    }
-  if (r->activate_button)
-    gtk_widget_set_sensitive (r->activate_button, enabled);
-}
-
-static void
-action_enabled_changed_cb (GActionGroup             *group,
-                           const char               *action_name,
-                           gboolean                  enabled,
-                           GtkInspectorActionEditor *r)
-{
-  if (g_str_equal (action_name, r->name))
-    update_enabled (r, enabled);
-}
-
-static void
-update_state (GtkInspectorActionEditor *r,
-              GVariant                 *state)
-{
-  if (r->state_entry)
-    gtk_inspector_variant_editor_set_value (r->state_entry, state);
-}
-
-static void
-action_state_changed_cb (GActionGroup             *group,
-                         const char               *action_name,
-                         GVariant                 *state,
-                         GtkInspectorActionEditor *r)
-{
-  if (g_str_equal (action_name, r->name))
-    update_state (r, state);
-}
-
-static void
 update_widgets (GtkInspectorActionEditor *r)
 {
-  GVariant *state = NULL;
+  GVariant *state;
 
   if (G_IS_ACTION_GROUP (r->owner))
-    g_action_group_query_action (G_ACTION_GROUP (r->owner), r->name,
-                                 &r->enabled, &r->parameter_type, NULL, NULL,
-                                 &state);
+    {
+      if (!g_action_group_query_action (G_ACTION_GROUP (r->owner), r->name,
+                                        &r->enabled, &r->parameter_type, NULL, NULL,
+                                        &state))
+        {
+          r->enabled = FALSE;
+          r->parameter_type = NULL;
+          state = NULL;
+        }
+    }
   else if (GTK_IS_ACTION_MUXER (r->owner))
-    gtk_action_muxer_query_action (GTK_ACTION_MUXER (r->owner), r->name,
-                                   &r->enabled, &r->parameter_type, NULL, NULL,
-                                   &state);
+    {
+      if (!gtk_action_muxer_query_action (GTK_ACTION_MUXER (r->owner), r->name,
+                                          &r->enabled, &r->parameter_type, NULL, NULL,
+                                          &state))
+        {
+          r->enabled = FALSE;
+          r->parameter_type = NULL;
+          state = NULL;
+        }
+    }
   else
-    state = NULL;
+    {
+      r->enabled = FALSE;
+      r->parameter_type = NULL;
+      state = NULL;
+    }
 
   gtk_widget_set_sensitive (r->activate_button, r->enabled);
   gtk_widget_set_sensitive (r->parameter_entry, r->enabled);
@@ -211,14 +191,8 @@ update_widgets (GtkInspectorActionEditor *r)
         g_variant_type_free (r->state_type);
       r->state_type = g_variant_type_copy (g_variant_get_type (state));
       gtk_inspector_variant_editor_set_value (r->state_entry, state);
-    }
 
-  if (G_IS_ACTION_GROUP (r->owner))
-    {
-      g_signal_connect (r->owner, "action-enabled-changed",
-                        G_CALLBACK (action_enabled_changed_cb), r);
-      g_signal_connect (r->owner, "action-state-changed",
-                        G_CALLBACK (action_state_changed_cb), r);
+      g_variant_unref (state);
     }
 }
 
@@ -228,18 +202,12 @@ dispose (GObject *object)
   GtkInspectorActionEditor *r = GTK_INSPECTOR_ACTION_EDITOR (object);
   GtkWidget *child;
 
-  g_free (r->name);
-  if (r->state_type)
-    g_variant_type_free (r->state_type);
-  if (r->owner)
-    {
-      g_signal_handlers_disconnect_by_func (r->owner, action_enabled_changed_cb, r);
-      g_signal_handlers_disconnect_by_func (r->owner, action_state_changed_cb, r);
-    }
-
   while ((child = gtk_widget_get_first_child (GTK_WIDGET (r))))
     gtk_widget_unparent (child);
 
+  g_clear_pointer (&r->name, g_free);
+  g_clear_pointer (&r->state_type, g_variant_type_free);
+
   G_OBJECT_CLASS (gtk_inspector_action_editor_parent_class)->dispose (object);
 }
 
@@ -278,12 +246,10 @@ set_property (GObject      *object,
   switch (param_id)
     {
     case PROP_OWNER:
-      if (r->owner)
-        {
-          g_signal_handlers_disconnect_by_func (r->owner, action_enabled_changed_cb, r);
-          g_signal_handlers_disconnect_by_func (r->owner, action_state_changed_cb, r);
-        }
       r->owner = g_value_get_object (value);
+      g_assert (r->owner == NULL ||
+                G_IS_ACTION_GROUP (r->owner) ||
+                GTK_IS_ACTION_MUXER (r->owner));
       break;
 
     case PROP_NAME:
@@ -334,10 +300,7 @@ gtk_inspector_action_editor_set (GtkInspectorActionEditor *self,
 }
 
 void
-gtk_inspector_action_editor_update (GtkInspectorActionEditor *r,
-                                    gboolean                  enabled,
-                                    GVariant                 *state)
+gtk_inspector_action_editor_update (GtkInspectorActionEditor *self)
 {
-  update_enabled (r, enabled);
-  update_state (r, state);
+  update_widgets (self);
 }
diff --git a/gtk/inspector/action-editor.h b/gtk/inspector/action-editor.h
index 39f6690233..12b7f485b0 100644
--- a/gtk/inspector/action-editor.h
+++ b/gtk/inspector/action-editor.h
@@ -36,9 +36,7 @@ GtkWidget *gtk_inspector_action_editor_new      (void);
 void       gtk_inspector_action_editor_set      (GtkInspectorActionEditor *self,
                                                  GObject                  *owner,
                                                  const char               *name);
-void       gtk_inspector_action_editor_update   (GtkInspectorActionEditor *self,
-                                                 gboolean                  enabled,
-                                                 GVariant                 *state);
+void       gtk_inspector_action_editor_update   (GtkInspectorActionEditor *self);
 
 G_END_DECLS
 
diff --git a/gtk/inspector/action-holder.c b/gtk/inspector/action-holder.c
index 199741e3d2..4c3c43b9e5 100644
--- a/gtk/inspector/action-holder.c
+++ b/gtk/inspector/action-holder.c
@@ -8,6 +8,8 @@ struct _ActionHolder {
   char *name;
 };
 
+static guint changed_signal;
+
 G_DEFINE_TYPE (ActionHolder, action_holder, G_TYPE_OBJECT)
 
 static void
@@ -32,6 +34,15 @@ action_holder_class_init (ActionHolderClass *class)
   GObjectClass *object_class = G_OBJECT_CLASS (class);
 
   object_class->finalize = action_holder_finalize;
+
+  changed_signal =
+    g_signal_new ("changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_FIRST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE, 0);
 }
 
 ActionHolder *
@@ -59,3 +70,9 @@ action_holder_get_name (ActionHolder *holder)
 {
   return holder->name;
 }
+
+void
+action_holder_changed (ActionHolder *holder)
+{
+  g_signal_emit (holder, changed_signal, 0);
+}
diff --git a/gtk/inspector/action-holder.h b/gtk/inspector/action-holder.h
index fe30248784..593074225f 100644
--- a/gtk/inspector/action-holder.h
+++ b/gtk/inspector/action-holder.h
@@ -12,4 +12,4 @@ ActionHolder * action_holder_new     (GObject    *owner,
 
 GObject      *action_holder_get_owner (ActionHolder *holder);
 const char   *action_holder_get_name  (ActionHolder *holder);
-
+void          action_holder_changed   (ActionHolder *holder);
diff --git a/gtk/inspector/actions.c b/gtk/inspector/actions.c
index eb979bfd0c..3f2a2183a2 100644
--- a/gtk/inspector/actions.c
+++ b/gtk/inspector/actions.c
@@ -26,6 +26,8 @@
 #include "gtkapplicationwindow.h"
 #include "gtkwidgetprivate.h"
 #include "gtkactionmuxerprivate.h"
+#include "gtkactionobserverprivate.h"
+#include "gtkactionobservableprivate.h"
 #include "gtkpopover.h"
 #include "gtklabel.h"
 #include "gtkstack.h"
@@ -59,7 +61,10 @@ enum {
   PROP_BUTTON
 };
 
-G_DEFINE_TYPE (GtkInspectorActions, gtk_inspector_actions, GTK_TYPE_WIDGET)
+static void gtk_inspector_actions_observer_iface_init (GtkActionObserverInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GtkInspectorActions, gtk_inspector_actions, GTK_TYPE_WIDGET,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVER, gtk_inspector_actions_observer_iface_init))
 
 static void
 gtk_inspector_actions_init (GtkInspectorActions *sl)
@@ -120,27 +125,43 @@ setup_enabled_cb (GtkSignalListItemFactory *factory,
 }
 
 static void
-bind_enabled_cb (GtkSignalListItemFactory *factory,
-                 GtkListItem              *list_item)
+update_enabled (ActionHolder *holder,
+                GtkLabel     *label)
 {
-  gpointer item;
-  GtkWidget *label;
-  GObject *owner;
-  const char *name;
+  GObject *owner = action_holder_get_owner (holder);
+  const char *name = action_holder_get_name (holder);
   gboolean enabled = FALSE;
 
-  item = gtk_list_item_get_item (list_item);
-  label = gtk_list_item_get_child (list_item);
-
-  owner = action_holder_get_owner (ACTION_HOLDER (item));
-  name = action_holder_get_name (ACTION_HOLDER (item));
   if (G_IS_ACTION_GROUP (owner))
     enabled = g_action_group_get_action_enabled (G_ACTION_GROUP (owner), name);
-  else if (GTK_IS_ACTION_MUXER (owner))
-    gtk_action_muxer_query_action (GTK_ACTION_MUXER (owner), name,
-                                   &enabled, NULL, NULL, NULL, NULL);
+  else if (!GTK_IS_ACTION_MUXER (owner) ||
+           !gtk_action_muxer_query_action (GTK_ACTION_MUXER (owner), name,
+                                           &enabled, NULL, NULL, NULL, NULL))
+    enabled = FALSE;
 
-  gtk_label_set_label (GTK_LABEL (label), enabled ? "+" : "-");
+  gtk_label_set_label (label, enabled ? "+" : "-");
+}
+
+static void
+bind_enabled_cb (GtkSignalListItemFactory *factory,
+                 GtkListItem              *list_item)
+{
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *label = gtk_list_item_get_child (list_item);
+
+  g_signal_connect (item, "changed", G_CALLBACK (update_enabled), label);
+
+  update_enabled (ACTION_HOLDER (item), GTK_LABEL (label));
+}
+
+static void
+unbind_enabled_cb (GtkSignalListItemFactory *factory,
+                   GtkListItem              *list_item)
+{
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *label = gtk_list_item_get_child (list_item);
+
+  g_signal_handlers_disconnect_by_func (item, update_enabled, label);
 }
 
 static void
@@ -195,20 +216,13 @@ setup_state_cb (GtkSignalListItemFactory *factory,
 }
 
 static void
-bind_state_cb (GtkSignalListItemFactory *factory,
-               GtkListItem              *list_item)
+update_state (ActionHolder *h,
+              GtkLabel     *label)
 {
-  gpointer item;
-  GtkWidget *label;
-  GObject *owner;
-  const char *name;
+  GObject *owner = action_holder_get_owner (h);
+  const char *name = action_holder_get_name (h);
   GVariant *state;
 
-  item = gtk_list_item_get_item (list_item);
-  label = gtk_list_item_get_child (list_item);
-
-  owner = action_holder_get_owner (ACTION_HOLDER (item));
-  name = action_holder_get_name (ACTION_HOLDER (item));
   if (G_IS_ACTION_GROUP (owner))
     state = g_action_group_get_action_state (G_ACTION_GROUP (owner), name);
   else if (!GTK_IS_ACTION_MUXER (owner) ||
@@ -221,12 +235,34 @@ bind_state_cb (GtkSignalListItemFactory *factory,
       char *state_string;
 
       state_string = g_variant_print (state, FALSE);
-      gtk_label_set_label (GTK_LABEL (label), state_string);
+      gtk_label_set_label (label, state_string);
       g_free (state_string);
       g_variant_unref (state);
     }
   else
-    gtk_label_set_label (GTK_LABEL (label), "");
+    gtk_label_set_label (label, "");
+}
+
+static void
+bind_state_cb (GtkSignalListItemFactory *factory,
+               GtkListItem              *list_item)
+{
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *label = gtk_list_item_get_child (list_item);
+
+  g_signal_connect (item, "changed", G_CALLBACK (update_state), label);
+
+  update_state (ACTION_HOLDER (item), GTK_LABEL (label));
+}
+
+static void
+unbind_state_cb (GtkSignalListItemFactory *factory,
+                 GtkListItem              *list_item)
+{
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *label = gtk_list_item_get_child (list_item);
+
+  g_signal_handlers_disconnect_by_func (item, update_state, label);
 }
 
 static void
@@ -241,23 +277,34 @@ setup_changes_cb (GtkSignalListItemFactory *factory,
 }
 
 static void
+update_changes (ActionHolder             *h,
+                GtkInspectorActionEditor *editor)
+{
+  gtk_inspector_action_editor_update (editor);
+}
+
+static void
 bind_changes_cb (GtkSignalListItemFactory *factory,
                  GtkListItem              *list_item)
 {
-  gpointer item;
-  GObject *owner;
-  const char *name;
-  GtkWidget *editor;
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *editor = gtk_list_item_get_child (list_item);
+  GObject *owner = action_holder_get_owner (ACTION_HOLDER (item));
+  const char *name = action_holder_get_name (ACTION_HOLDER (item));
 
-  item = gtk_list_item_get_item (list_item);
-  editor = gtk_list_item_get_child (list_item);
+  gtk_inspector_action_editor_set (GTK_INSPECTOR_ACTION_EDITOR (editor), owner, name);
 
-  owner = action_holder_get_owner (ACTION_HOLDER (item));
-  name = action_holder_get_name (ACTION_HOLDER (item));
+  g_signal_connect (item, "changed", G_CALLBACK (update_changes), editor);
+}
 
-  gtk_inspector_action_editor_set (GTK_INSPECTOR_ACTION_EDITOR (editor),
-                                   owner,
-                                   name);
+static void
+unbind_changes_cb (GtkSignalListItemFactory *factory,
+                   GtkListItem              *list_item)
+{
+  gpointer item = gtk_list_item_get_item (list_item);
+  GtkWidget *editor = gtk_list_item_get_child (list_item);
+
+  g_signal_handlers_disconnect_by_func (item, update_changes, editor);
 }
 
 static void
@@ -322,6 +369,157 @@ refresh_all (GtkInspectorActions *sl)
   reload (sl);
 }
 
+static void
+action_changed (GtkInspectorActions *sl,
+                const char          *name)
+{
+  unsigned int n_actions;
+
+  n_actions = g_list_model_get_n_items (G_LIST_MODEL (sl->actions));
+  for (unsigned int i = 0; i < n_actions; i++)
+    {
+      ActionHolder *h = ACTION_HOLDER (g_list_model_get_item (G_LIST_MODEL (sl->actions), i));
+
+      if (g_str_equal (action_holder_get_name (h), name))
+        {
+          action_holder_changed (h);
+          g_object_unref (h);
+          break;
+        }
+
+      g_object_unref (h);
+    }
+}
+
+static void
+action_enabled_changed (GActionGroup        *group,
+                        const char          *action_name,
+                        gboolean             enabled,
+                        GtkInspectorActions *sl)
+{
+  action_changed (sl, action_name);
+}
+
+static void
+action_state_changed (GActionGroup        *group,
+                      const char          *action_name,
+                      GVariant            *state,
+                      GtkInspectorActions *sl)
+{
+  action_changed (sl, action_name);
+}
+
+static void
+observer_action_added (GtkActionObserver    *observer,
+                       GtkActionObservable  *observable,
+                       const char           *action_name,
+                       const GVariantType   *parameter_type,
+                       gboolean              enabled,
+                       GVariant             *state)
+{
+}
+
+static void
+observer_action_removed (GtkActionObserver   *observer,
+                         GtkActionObservable *observable,
+                         const char          *action_name)
+{
+}
+
+static void
+observer_action_enabled_changed (GtkActionObserver   *observer,
+                                 GtkActionObservable *observable,
+                                 const char          *action_name,
+                                 gboolean             enabled)
+{
+  action_changed (GTK_INSPECTOR_ACTIONS (observer), action_name);
+}
+
+static void
+observer_action_state_changed (GtkActionObserver   *observer,
+                               GtkActionObservable *observable,
+                               const char          *action_name,
+                               GVariant            *state)
+{
+  action_changed (GTK_INSPECTOR_ACTIONS (observer), action_name);
+}
+
+static void
+observer_primary_accel_changed (GtkActionObserver   *observer,
+                                GtkActionObservable *observable,
+                                const char          *action_name,
+                                const char          *action_and_target)
+{
+}
+
+static void
+gtk_inspector_actions_observer_iface_init (GtkActionObserverInterface *iface)
+{
+  iface->action_added = observer_action_added;
+  iface->action_removed = observer_action_removed;
+  iface->action_enabled_changed = observer_action_enabled_changed;
+  iface->action_state_changed = observer_action_state_changed;
+  iface->primary_accel_changed = observer_primary_accel_changed;
+}
+
+static void
+connect (GtkInspectorActions *sl)
+{
+  if (G_IS_ACTION_GROUP (sl->object))
+    {
+      g_signal_connect (sl->object, "action-enabled-changed",
+                        G_CALLBACK (action_enabled_changed), sl);
+      g_signal_connect (sl->object, "action-state-changed",
+                        G_CALLBACK (action_state_changed), sl);
+    }
+  else if (GTK_IS_WIDGET (sl->object))
+    {
+      GtkActionMuxer *muxer;
+
+      muxer = _gtk_widget_get_action_muxer (GTK_WIDGET (sl->object), FALSE);
+
+      if (muxer)
+        {
+          int i;
+          char **names;
+  
+          names = gtk_action_muxer_list_actions (muxer, FALSE);
+          for (i = 0; names[i]; i++)
+            {
+              gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer), names[i], GTK_ACTION_OBSERVER (sl));
+            }
+          g_strfreev (names);
+        }
+    }
+}
+
+static void
+disconnect (GtkInspectorActions *sl)
+{
+  if (G_IS_ACTION_GROUP (sl->object))
+    {
+      g_signal_handlers_disconnect_by_func (sl->object, action_enabled_changed, sl);
+      g_signal_handlers_disconnect_by_func (sl->object, action_state_changed, sl);
+    }
+  else if (GTK_IS_WIDGET (sl->object))
+    {
+      GtkActionMuxer *muxer;
+
+      muxer = _gtk_widget_get_action_muxer (GTK_WIDGET (sl->object), FALSE);
+
+      if (muxer)
+        {
+          int i;
+          char **names;
+
+          names = gtk_action_muxer_list_actions (muxer, FALSE);
+          for (i = 0; names[i]; i++)
+            gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (muxer), names[i], GTK_ACTION_OBSERVER (sl));
+          g_strfreev (names);
+        }
+    }
+}
+
 void
 gtk_inspector_actions_set_object (GtkInspectorActions *sl,
                                   GObject             *object)
@@ -334,11 +532,17 @@ gtk_inspector_actions_set_object (GtkInspectorActions *sl,
   page = gtk_stack_get_page (GTK_STACK (stack), GTK_WIDGET (sl));
   gtk_stack_page_set_visible (page, FALSE);
 
+  if (sl->object)
+    disconnect (sl);
+
   g_set_object (&sl->object, object);
 
   gtk_column_view_sort_by_column (GTK_COLUMN_VIEW (sl->list), sl->name, GTK_SORT_ASCENDING);
   loaded = reload (sl);
   gtk_stack_page_set_visible (page, loaded);
+
+  if (sl->object)
+    connect (sl);
 }
 
 static void
@@ -418,6 +622,9 @@ dispose (GObject *object)
 {
   GtkInspectorActions *sl = GTK_INSPECTOR_ACTIONS (object);
 
+  if (sl->object)
+    disconnect (sl);
+
   g_clear_object (&sl->sorted);
   g_clear_object (&sl->actions);
   g_clear_object (&sl->object);
@@ -450,12 +657,15 @@ gtk_inspector_actions_class_init (GtkInspectorActionsClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, bind_name_cb);
   gtk_widget_class_bind_template_callback (widget_class, setup_enabled_cb);
   gtk_widget_class_bind_template_callback (widget_class, bind_enabled_cb);
+  gtk_widget_class_bind_template_callback (widget_class, unbind_enabled_cb);
   gtk_widget_class_bind_template_callback (widget_class, setup_parameter_cb);
   gtk_widget_class_bind_template_callback (widget_class, bind_parameter_cb);
   gtk_widget_class_bind_template_callback (widget_class, setup_state_cb);
   gtk_widget_class_bind_template_callback (widget_class, bind_state_cb);
+  gtk_widget_class_bind_template_callback (widget_class, unbind_state_cb);
   gtk_widget_class_bind_template_callback (widget_class, setup_changes_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);
 }
diff --git a/gtk/inspector/actions.ui b/gtk/inspector/actions.ui
index a48b0ba638..55c3007f36 100644
--- a/gtk/inspector/actions.ui
+++ b/gtk/inspector/actions.ui
@@ -32,6 +32,7 @@
                   <object class="GtkSignalListItemFactory">
                     <signal name="setup" handler="setup_enabled_cb"/>
                     <signal name="bind" handler="bind_enabled_cb"/>
+                    <signal name="unbind" handler="unbind_enabled_cb"/>
                   </object>
                 </property>
               </object>
@@ -54,6 +55,7 @@
                   <object class="GtkSignalListItemFactory">
                     <signal name="setup" handler="setup_state_cb"/>
                     <signal name="bind" handler="bind_state_cb"/>
+                    <signal name="unbind" handler="unbind_state_cb"/>
                   </object>
                 </property>
               </object>
@@ -66,6 +68,7 @@
                   <object class="GtkSignalListItemFactory">
                     <signal name="setup" handler="setup_changes_cb"/>
                     <signal name="bind" handler="bind_changes_cb"/>
+                    <signal name="unbind" handler="unbind_changes_cb"/>
                   </object>
                 </property>
               </object>
diff --git a/gtk/inspector/variant-editor.c b/gtk/inspector/variant-editor.c
index cf8a16a3fc..52c99f05ce 100644
--- a/gtk/inspector/variant-editor.c
+++ b/gtk/inspector/variant-editor.c
@@ -21,7 +21,7 @@
 #include "variant-editor.h"
 
 #include "gtksizegroup.h"
-#include "gtktogglebutton.h"
+#include "gtkcheckbutton.h"
 #include "gtkentry.h"
 #include "gtklabel.h"
 #include "gtkbox.h"
@@ -66,10 +66,11 @@ dispose (GObject *object)
   GtkInspectorVariantEditor *self = GTK_INSPECTOR_VARIANT_EDITOR (object);
 
   if (self->editor)
-    {
+   {
       g_signal_handlers_disconnect_by_func (self->editor, variant_editor_changed_cb, self->data);
 
       gtk_widget_unparent (self->editor);
+      self->editor = NULL;
     }
 
   G_OBJECT_CLASS (gtk_inspector_variant_editor_parent_class)->dispose (object);
@@ -94,14 +95,18 @@ ensure_editor (GtkInspectorVariantEditor *self,
       g_variant_type_equal (self->type, type))
     return;
 
+  self->type = type;
+
   if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
     {
       if (self->editor)
         gtk_widget_unparent (self->editor);
 
-      self->editor = gtk_toggle_button_new_with_label ("FALSE");
+      self->editor = gtk_check_button_new ();
       g_signal_connect (self->editor, "notify::active",
                         G_CALLBACK (variant_editor_changed_cb), self);
+
+      gtk_widget_set_parent (self->editor, GTK_WIDGET (self));
     }
   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
     {
@@ -112,6 +117,8 @@ ensure_editor (GtkInspectorVariantEditor *self,
       gtk_editable_set_width_chars (GTK_EDITABLE (self->editor), 10);
       g_signal_connect (self->editor, "notify::text",
                         G_CALLBACK (variant_editor_changed_cb), self);
+
+      gtk_widget_set_parent (self->editor, GTK_WIDGET (self));
     }
   else if (!GTK_IS_BOX (self->editor))
     {
@@ -128,10 +135,9 @@ ensure_editor (GtkInspectorVariantEditor *self,
       gtk_box_append (GTK_BOX (self->editor), label);
       g_signal_connect (entry, "notify::text",
                         G_CALLBACK (variant_editor_changed_cb), self);
-    }
 
-  self->type = type;
-  gtk_widget_set_parent (self->editor, GTK_WIDGET (self));
+      gtk_widget_set_parent (self->editor, GTK_WIDGET (self));
+    }
 }
 
 GtkWidget *
@@ -169,18 +175,14 @@ gtk_inspector_variant_editor_set_value (GtkWidget *editor,
 
   ensure_editor (self, g_variant_get_type (value));
 
-  g_signal_handlers_block_by_func (self->editor, variant_editor_changed_cb, self->data);
+  g_signal_handlers_block_by_func (self->editor, variant_editor_changed_cb, self);
 
   if (g_variant_type_equal (self->type, G_VARIANT_TYPE_BOOLEAN))
     {
-      GtkToggleButton *tb = GTK_TOGGLE_BUTTON (self->editor);
-
-      if (gtk_toggle_button_get_active (tb) != g_variant_get_boolean (value))
-        {
-          gtk_toggle_button_set_active (tb, g_variant_get_boolean (value));
-          gtk_button_set_label (GTK_BUTTON (tb),
-                                g_variant_get_boolean (value) ? "TRUE" : "FALSE");
-        }
+      GtkCheckButton *b = GTK_CHECK_BUTTON (self->editor);
+
+      if (gtk_check_button_get_active (b) != g_variant_get_boolean (value))
+        gtk_check_button_set_active (b, g_variant_get_boolean (value));
     }
   else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_STRING))
     {
@@ -201,7 +203,7 @@ gtk_inspector_variant_editor_set_value (GtkWidget *editor,
       g_free (text);
     }
 
-  g_signal_handlers_unblock_by_func (self->editor, variant_editor_changed_cb, self->data);
+  g_signal_handlers_unblock_by_func (self->editor, variant_editor_changed_cb, self);
 }
 
 GVariant *
@@ -215,8 +217,8 @@ gtk_inspector_variant_editor_get_value (GtkWidget *editor)
 
   if (g_variant_type_equal (self->type, G_VARIANT_TYPE_BOOLEAN))
     {
-      GtkToggleButton *tb = GTK_TOGGLE_BUTTON (self->editor);
-      value = g_variant_new_boolean (gtk_toggle_button_get_active (tb));
+      GtkCheckButton *b = GTK_CHECK_BUTTON (self->editor);
+      value = g_variant_new_boolean (gtk_check_button_get_active (b));
     }
   else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_STRING))
     {