From c05b418512ea535b5bb71735aed0dd0a3adb8865 Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Thu, 21 Jan 2021 00:03:16 -0500 Subject: [PATCH] inspector: Split out variant editor --- gtk/inspector/action-editor.c | 147 ++------------------ gtk/inspector/meson.build | 7 +- gtk/inspector/variant-editor.c | 238 +++++++++++++++++++++++++++++++++ gtk/inspector/variant-editor.h | 54 ++++++++ 4 files changed, 304 insertions(+), 142 deletions(-) create mode 100644 gtk/inspector/variant-editor.c create mode 100644 gtk/inspector/variant-editor.h diff --git a/gtk/inspector/action-editor.c b/gtk/inspector/action-editor.c index b4c04fdd0e..d3b08e6092 100644 --- a/gtk/inspector/action-editor.c +++ b/gtk/inspector/action-editor.c @@ -19,6 +19,7 @@ #include #include "action-editor.h" +#include "variant-editor.h" #include "gtksizegroup.h" #include "gtktogglebutton.h" @@ -69,138 +70,6 @@ gtk_inspector_action_editor_init (GtkInspectorActionEditor *editor) gtk_box_layout_set_spacing (layout, 10); } -typedef void (*VariantEditorChanged) (GtkWidget *editor, gpointer data); - -typedef struct -{ - GtkWidget *editor; - VariantEditorChanged callback; - gpointer data; -} VariantEditorData; - -static void -variant_editor_changed_cb (GObject *obj, - GParamSpec *pspec, - VariantEditorData *data) -{ - data->callback (data->editor, data->data); -} - -static GtkWidget * -variant_editor_new (const GVariantType *type, - VariantEditorChanged callback, - gpointer data) -{ - GtkWidget *editor; - GtkWidget *label; - GtkWidget *entry; - VariantEditorData *d; - - d = g_new (VariantEditorData, 1); - d->callback = callback; - d->data = data; - - if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) - { - 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 (); - gtk_editable_set_width_chars (GTK_EDITABLE (editor), 10); - g_signal_connect (editor, "notify::text", G_CALLBACK (variant_editor_changed_cb), d); - } - else - { - editor = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); - entry = gtk_entry_new (); - gtk_editable_set_width_chars (GTK_EDITABLE (entry), 10); - gtk_box_append (GTK_BOX (editor), entry); - label = gtk_label_new (g_variant_type_peek_string (type)); - gtk_box_append (GTK_BOX (editor), label); - g_signal_connect (entry, "notify::text", G_CALLBACK (variant_editor_changed_cb), d); - } - - g_object_set_data (G_OBJECT (editor), "type", (gpointer)type); - d->editor = editor; - g_object_set_data_full (G_OBJECT (editor), "callback", d, g_free); - - return editor; -} - -static void -variant_editor_set_value (GtkWidget *editor, - GVariant *value) -{ - const GVariantType *type; - gpointer data; - - data = g_object_get_data (G_OBJECT (editor), "callback"); - g_signal_handlers_block_by_func (editor, variant_editor_changed_cb, data); - - type = g_variant_get_type (value); - if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) - { - GtkToggleButton *tb = GTK_TOGGLE_BUTTON (editor); - GtkWidget *child; - - gtk_toggle_button_set_active (tb, g_variant_get_boolean (value)); - child = gtk_button_get_child (GTK_BUTTON (tb)); - gtk_label_set_text (GTK_LABEL (child), - g_variant_get_boolean (value) ? "TRUE" : "FALSE"); - } - else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) - { - GtkEntry *entry = GTK_ENTRY (editor); - gtk_editable_set_text (GTK_EDITABLE (entry), g_variant_get_string (value, NULL)); - } - else - { - GtkWidget *entry; - char *text; - - entry = gtk_widget_get_first_child (editor); - - text = g_variant_print (value, FALSE); - gtk_editable_set_text (GTK_EDITABLE (entry), text); - g_free (text); - } - - g_signal_handlers_unblock_by_func (editor, variant_editor_changed_cb, data); -} - -static GVariant * -variant_editor_get_value (GtkWidget *editor) -{ - const GVariantType *type; - GVariant *value; - - type = (const GVariantType *) g_object_get_data (G_OBJECT (editor), "type"); - if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) - { - GtkToggleButton *tb = GTK_TOGGLE_BUTTON (editor); - value = g_variant_new_boolean (gtk_toggle_button_get_active (tb)); - } - else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) - { - GtkEntry *entry = GTK_ENTRY (editor); - value = g_variant_new_string (gtk_editable_get_text (GTK_EDITABLE (entry))); - } - else - { - GtkWidget *entry; - const char *text; - - entry = gtk_widget_get_first_child (editor); - text = gtk_editable_get_text (GTK_EDITABLE (entry)); - - value = g_variant_parse (type, text, NULL, NULL, NULL); - } - - return value; -} - static void activate_action (GtkWidget *button, GtkInspectorActionEditor *r) @@ -208,7 +77,7 @@ activate_action (GtkWidget *button, GVariant *parameter = NULL; if (r->parameter_entry) - parameter = variant_editor_get_value (r->parameter_entry); + parameter = gtk_inspector_variant_editor_get_value (r->parameter_entry); if (G_IS_ACTION_GROUP (r->owner)) g_action_group_activate_action (G_ACTION_GROUP (r->owner), r->name, parameter); else if (GTK_IS_ACTION_MUXER (r->owner)) @@ -222,7 +91,7 @@ parameter_changed (GtkWidget *editor, GtkInspectorActionEditor *r = data; GVariant *value; - value = variant_editor_get_value (editor); + value = gtk_inspector_variant_editor_get_value (editor); gtk_widget_set_sensitive (r->activate_button, r->enabled && value != NULL); if (value) g_variant_unref (value); @@ -235,7 +104,7 @@ state_changed (GtkWidget *editor, GtkInspectorActionEditor *r = data; GVariant *value; - value = variant_editor_get_value (editor); + value = gtk_inspector_variant_editor_get_value (editor); if (value) { if (G_IS_ACTION_GROUP (r->owner)) @@ -274,7 +143,7 @@ update_state (GtkInspectorActionEditor *r, GVariant *state) { if (r->state_entry) - variant_editor_set_value (r->state_entry, state); + gtk_inspector_variant_editor_set_value (r->state_entry, state); } static void @@ -321,7 +190,7 @@ constructed (GObject *object) if (r->parameter_type) { - r->parameter_entry = variant_editor_new (r->parameter_type, parameter_changed, r); + r->parameter_entry = gtk_inspector_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); } @@ -336,8 +205,8 @@ constructed (GObject *object) if (r->sg) gtk_size_group_add_widget (r->sg, label); gtk_box_append (GTK_BOX (row), label); - r->state_entry = variant_editor_new (r->state_type, state_changed, r); - variant_editor_set_value (r->state_entry, state); + r->state_entry = gtk_inspector_variant_editor_new (r->state_type, state_changed, r); + gtk_inspector_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)); } diff --git a/gtk/inspector/meson.build b/gtk/inspector/meson.build index 8ccc41340b..0ae9927011 100644 --- a/gtk/inspector/meson.build +++ b/gtk/inspector/meson.build @@ -1,6 +1,7 @@ inspector_sources = files( 'a11y.c', 'action-editor.c', + 'action-holder.c', 'actions.c', 'baselineoverlay.c', 'cellrenderergraph.c', @@ -24,10 +25,12 @@ inspector_sources = files( 'misc-info.c', 'object-tree.c', 'prop-editor.c', + 'prop-holder.c', 'prop-list.c', 'recorder.c', 'recording.c', 'renderrecording.c', + 'resource-holder.c', 'resource-list.c', 'shortcuts.c', 'size-groups.c', @@ -38,9 +41,7 @@ inspector_sources = files( 'treewalk.c', 'type-info.c', 'updatesoverlay.c', + 'variant-editor.c', 'visual.c', 'window.c', - 'prop-holder.c', - 'resource-holder.c', - 'action-holder.c' ) diff --git a/gtk/inspector/variant-editor.c b/gtk/inspector/variant-editor.c new file mode 100644 index 0000000000..cf8a16a3fc --- /dev/null +++ b/gtk/inspector/variant-editor.c @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2014 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#include "config.h" +#include + +#include "variant-editor.h" + +#include "gtksizegroup.h" +#include "gtktogglebutton.h" +#include "gtkentry.h" +#include "gtklabel.h" +#include "gtkbox.h" +#include "gtkbinlayout.h" + + +struct _GtkInspectorVariantEditor +{ + GtkWidget parent; + + const GVariantType *type; + + GtkWidget *editor; + GtkInspectorVariantEditorChanged callback; + gpointer data; +}; + +typedef struct +{ + GtkWidgetClass parent; +} GtkInspectorVariantEditorClass; + +static void +variant_editor_changed_cb (GObject *obj, + GParamSpec *pspec, + GtkInspectorVariantEditor *self) +{ + self->callback (GTK_WIDGET (self), self->data); +} + +G_DEFINE_TYPE (GtkInspectorVariantEditor, gtk_inspector_variant_editor, GTK_TYPE_WIDGET) + +static void +gtk_inspector_variant_editor_init (GtkInspectorVariantEditor *editor) +{ +} + + +static void +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); + } + + G_OBJECT_CLASS (gtk_inspector_variant_editor_parent_class)->dispose (object); +} + +static void +gtk_inspector_variant_editor_class_init (GtkInspectorVariantEditorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->dispose = dispose; + + gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT); +} + +static void +ensure_editor (GtkInspectorVariantEditor *self, + const GVariantType *type) +{ + if (self->type && + g_variant_type_equal (self->type, type)) + return; + + 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"); + g_signal_connect (self->editor, "notify::active", + G_CALLBACK (variant_editor_changed_cb), self); + } + else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) + { + if (self->editor) + gtk_widget_unparent (self->editor); + + self->editor = gtk_entry_new (); + gtk_editable_set_width_chars (GTK_EDITABLE (self->editor), 10); + g_signal_connect (self->editor, "notify::text", + G_CALLBACK (variant_editor_changed_cb), self); + } + else if (!GTK_IS_BOX (self->editor)) + { + GtkWidget *entry, *label; + + if (self->editor) + gtk_widget_unparent (self->editor); + + self->editor = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); + entry = gtk_entry_new (); + gtk_editable_set_width_chars (GTK_EDITABLE (entry), 10); + gtk_box_append (GTK_BOX (self->editor), entry); + label = gtk_label_new (g_variant_type_peek_string (type)); + 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)); +} + +GtkWidget * +gtk_inspector_variant_editor_new (const GVariantType *type, + GtkInspectorVariantEditorChanged callback, + gpointer data) +{ + GtkInspectorVariantEditor *self; + + self = g_object_new (GTK_TYPE_INSPECTOR_VARIANT_EDITOR, NULL); + + self->callback = callback; + self->data = data; + + if (type) + ensure_editor (self, type); + + return GTK_WIDGET (self); +} + +void +gtk_inspector_variant_editor_set_type (GtkWidget *editor, + const GVariantType *type) +{ + GtkInspectorVariantEditor *self = GTK_INSPECTOR_VARIANT_EDITOR (editor); + + ensure_editor (self, type); +} + +void +gtk_inspector_variant_editor_set_value (GtkWidget *editor, + GVariant *value) +{ + GtkInspectorVariantEditor *self = GTK_INSPECTOR_VARIANT_EDITOR (editor); + + ensure_editor (self, g_variant_get_type (value)); + + g_signal_handlers_block_by_func (self->editor, variant_editor_changed_cb, self->data); + + 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"); + } + } + else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_STRING)) + { + GtkEntry *entry = GTK_ENTRY (self->editor); + + gtk_editable_set_text (GTK_EDITABLE (entry), + g_variant_get_string (value, NULL)); + } + else + { + GtkWidget *entry; + char *text; + + entry = gtk_widget_get_first_child (self->editor); + + text = g_variant_print (value, FALSE); + gtk_editable_set_text (GTK_EDITABLE (entry), text); + g_free (text); + } + + g_signal_handlers_unblock_by_func (self->editor, variant_editor_changed_cb, self->data); +} + +GVariant * +gtk_inspector_variant_editor_get_value (GtkWidget *editor) +{ + GtkInspectorVariantEditor *self = GTK_INSPECTOR_VARIANT_EDITOR (editor); + GVariant *value; + + if (self->type == NULL) + return NULL; + + 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)); + } + else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_STRING)) + { + GtkEntry *entry = GTK_ENTRY (self->editor); + value = g_variant_new_string (gtk_editable_get_text (GTK_EDITABLE (entry))); + } + else + { + GtkWidget *entry; + const char *text; + + entry = gtk_widget_get_first_child (self->editor); + text = gtk_editable_get_text (GTK_EDITABLE (entry)); + + value = g_variant_parse (self->type, text, NULL, NULL, NULL); + } + + return value; +} diff --git a/gtk/inspector/variant-editor.h b/gtk/inspector/variant-editor.h new file mode 100644 index 0000000000..88a9ae2e2e --- /dev/null +++ b/gtk/inspector/variant-editor.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2014 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#ifndef _GTK_INSPECTOR_VARIANT_EDITOR_H_ +#define _GTK_INSPECTOR_VARIANT_EDITOR_H_ + + +#include +#include + + +#define GTK_TYPE_INSPECTOR_VARIANT_EDITOR (gtk_inspector_variant_editor_get_type()) +#define GTK_INSPECTOR_VARIANT_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_VARIANT_EDITOR, GtkInspectorVariantEditor)) +#define GTK_INSPECTOR_IS_VARIANT_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_VARIANT_EDITOR)) + + +typedef struct _GtkInspectorVariantEditor GtkInspectorVariantEditor; + +G_BEGIN_DECLS + +typedef void (* GtkInspectorVariantEditorChanged) (GtkWidget *editor, + gpointer data); + +GType gtk_inspector_variant_editor_get_type (void); +GtkWidget *gtk_inspector_variant_editor_new (const GVariantType *type, + GtkInspectorVariantEditorChanged callback, + gpointer data); +void gtk_inspector_variant_editor_set_type (GtkWidget *editor, + const GVariantType *type); +void gtk_inspector_variant_editor_set_value (GtkWidget *editor, + GVariant *value); +GVariant * gtk_inspector_variant_editor_get_value (GtkWidget *editor); + + +G_END_DECLS + + +#endif // _GTK_INSPECTOR_VARIANT_EDITOR_H_ + +// vim: set et: