2014-05-03 01:48:33 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2008-2009 Christian Hammond
|
|
|
|
* Copyright (c) 2008-2009 David Trowbridge
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included
|
|
|
|
* in all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2014-05-05 03:47:11 +00:00
|
|
|
|
2014-07-12 03:14:04 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include <glib/gi18n-lib.h>
|
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
#include "prop-list.h"
|
2014-07-12 03:14:04 +00:00
|
|
|
|
2014-05-18 05:03:24 +00:00
|
|
|
#include "prop-editor.h"
|
2014-10-11 01:40:53 +00:00
|
|
|
#include "object-tree.h"
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2014-07-12 03:14:04 +00:00
|
|
|
#include "gtkcelllayout.h"
|
2014-10-11 00:51:54 +00:00
|
|
|
#include "gtktreeview.h"
|
2014-10-31 00:54:04 +00:00
|
|
|
#include "gtktreeselection.h"
|
2014-07-12 03:14:04 +00:00
|
|
|
#include "gtkpopover.h"
|
2014-11-22 16:41:24 +00:00
|
|
|
#include "gtksearchentry.h"
|
|
|
|
#include "gtklabel.h"
|
2018-02-04 08:29:44 +00:00
|
|
|
#include "gtkmain.h"
|
2014-11-22 16:41:24 +00:00
|
|
|
#include "gtkstack.h"
|
2018-02-04 08:29:44 +00:00
|
|
|
#include "gtkeventcontrollerkey.h"
|
2019-04-05 19:15:16 +00:00
|
|
|
#include "gtklayoutmanager.h"
|
2019-04-12 03:42:31 +00:00
|
|
|
#include "gtklistbox.h"
|
|
|
|
#include "gtksizegroup.h"
|
2019-04-12 23:48:23 +00:00
|
|
|
#include "gtkroot.h"
|
2019-05-29 17:10:46 +00:00
|
|
|
#include "gtkgestureclick.h"
|
2019-05-07 22:04:41 +00:00
|
|
|
#include "gtkstylecontext.h"
|
2014-05-03 01:48:33 +00:00
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0,
|
2014-10-11 01:40:53 +00:00
|
|
|
PROP_OBJECT_TREE,
|
2016-03-07 01:41:28 +00:00
|
|
|
PROP_SEARCH_ENTRY
|
2014-05-03 01:48:33 +00:00
|
|
|
};
|
|
|
|
|
2019-04-28 21:56:10 +00:00
|
|
|
typedef enum {
|
|
|
|
COLUMN_NAME,
|
|
|
|
COLUMN_ORIGIN
|
|
|
|
} SortColumn;
|
|
|
|
|
2014-05-07 03:24:20 +00:00
|
|
|
struct _GtkInspectorPropListPrivate
|
2014-05-03 01:48:33 +00:00
|
|
|
{
|
|
|
|
GObject *object;
|
2014-05-08 22:36:38 +00:00
|
|
|
gulong notify_handler_id;
|
2014-10-11 01:40:53 +00:00
|
|
|
GtkInspectorObjectTree *object_tree;
|
2014-10-31 00:54:04 +00:00
|
|
|
GtkWidget *search_entry;
|
2014-11-22 16:41:24 +00:00
|
|
|
GtkWidget *search_stack;
|
2019-04-12 03:42:31 +00:00
|
|
|
GtkWidget *list2;
|
2019-04-28 21:56:10 +00:00
|
|
|
GtkWidget *name_sort_indicator;
|
|
|
|
GtkWidget *origin_sort_indicator;
|
|
|
|
GtkWidget *name_heading;
|
|
|
|
GtkWidget *origin_heading;
|
|
|
|
SortColumn sort_column;
|
|
|
|
GtkSortType sort_direction;
|
2019-04-12 03:42:31 +00:00
|
|
|
GtkSizeGroup *names;
|
|
|
|
GtkSizeGroup *types;
|
|
|
|
GtkSizeGroup *values;
|
|
|
|
GtkSizeGroup *origins;
|
2014-05-03 01:48:33 +00:00
|
|
|
};
|
|
|
|
|
2014-05-10 03:15:34 +00:00
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorPropList, gtk_inspector_prop_list, GTK_TYPE_BOX)
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2014-11-22 16:41:24 +00:00
|
|
|
static void
|
|
|
|
search_close_clicked (GtkWidget *button,
|
|
|
|
GtkInspectorPropList *pl)
|
|
|
|
{
|
2019-02-17 04:58:54 +00:00
|
|
|
gtk_editable_set_text (GTK_EDITABLE (pl->priv->search_entry), "");
|
2014-11-22 16:41:24 +00:00
|
|
|
gtk_stack_set_visible_child_name (GTK_STACK (pl->priv->search_stack), "title");
|
|
|
|
}
|
|
|
|
|
2018-05-14 17:03:17 +00:00
|
|
|
static void
|
2019-04-03 11:11:44 +00:00
|
|
|
show_search_entry (GtkInspectorPropList *pl)
|
2018-05-14 17:03:17 +00:00
|
|
|
{
|
2019-04-03 11:11:44 +00:00
|
|
|
gtk_stack_set_visible_child (GTK_STACK (pl->priv->search_stack),
|
|
|
|
pl->priv->search_entry);
|
2019-02-23 05:29:52 +00:00
|
|
|
}
|
|
|
|
|
2019-04-28 21:56:10 +00:00
|
|
|
static void
|
|
|
|
apply_sort (GtkInspectorPropList *pl,
|
|
|
|
SortColumn column,
|
|
|
|
GtkSortType direction)
|
|
|
|
{
|
|
|
|
const char *icon_name;
|
|
|
|
|
|
|
|
icon_name = direction == GTK_SORT_ASCENDING ? "pan-down-symbolic"
|
|
|
|
: "pan-up-symbolic";
|
|
|
|
|
|
|
|
if (column == COLUMN_NAME)
|
|
|
|
{
|
2019-05-07 22:04:41 +00:00
|
|
|
gtk_image_clear (GTK_IMAGE (pl->priv->origin_sort_indicator));
|
2019-04-28 21:56:10 +00:00
|
|
|
gtk_image_set_from_icon_name (GTK_IMAGE (pl->priv->name_sort_indicator),
|
|
|
|
icon_name);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-05-07 22:04:41 +00:00
|
|
|
gtk_image_clear (GTK_IMAGE (pl->priv->name_sort_indicator));
|
2019-04-28 21:56:10 +00:00
|
|
|
gtk_image_set_from_icon_name (GTK_IMAGE (pl->priv->origin_sort_indicator),
|
|
|
|
icon_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
pl->priv->sort_column = column;
|
|
|
|
pl->priv->sort_direction = direction;
|
|
|
|
|
|
|
|
gtk_list_box_invalidate_sort (GTK_LIST_BOX (pl->priv->list2));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2019-05-29 17:10:46 +00:00
|
|
|
sort_changed (GtkGestureClick *gesture,
|
2019-04-28 21:56:10 +00:00
|
|
|
int n_press,
|
|
|
|
double x,
|
|
|
|
double y,
|
|
|
|
GtkInspectorPropList *pl)
|
|
|
|
{
|
|
|
|
SortColumn column;
|
|
|
|
GtkSortType direction;
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
|
|
|
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
|
|
|
|
if (widget == pl->priv->name_heading)
|
|
|
|
column = COLUMN_NAME;
|
|
|
|
else
|
|
|
|
column = COLUMN_ORIGIN;
|
|
|
|
|
|
|
|
if (pl->priv->sort_column == column &&
|
|
|
|
pl->priv->sort_direction == GTK_SORT_ASCENDING)
|
|
|
|
direction = GTK_SORT_DESCENDING;
|
|
|
|
else
|
|
|
|
direction = GTK_SORT_ASCENDING;
|
|
|
|
|
|
|
|
apply_sort (pl, column, direction);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
row_get_column (GtkListBoxRow *row,
|
|
|
|
SortColumn column)
|
|
|
|
{
|
|
|
|
GParamSpec *prop = g_object_get_data (G_OBJECT (row), "pspec");
|
|
|
|
|
|
|
|
if (column == COLUMN_NAME)
|
|
|
|
return prop->name;
|
|
|
|
else
|
|
|
|
return g_type_name (prop->owner_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sort_func (GtkListBoxRow *row1,
|
|
|
|
GtkListBoxRow *row2,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
GtkInspectorPropList *pl = user_data;
|
|
|
|
const char *s1 = row_get_column (row1, pl->priv->sort_column);
|
|
|
|
const char *s2 = row_get_column (row2, pl->priv->sort_column);
|
|
|
|
int ret = strcmp (s1, s2);
|
|
|
|
|
|
|
|
return pl->priv->sort_direction == GTK_SORT_ASCENDING ? ret : -ret;
|
|
|
|
}
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
static gboolean
|
|
|
|
filter_func (GtkListBoxRow *row,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
GtkInspectorPropList *pl = data;
|
|
|
|
GParamSpec *pspec = (GParamSpec *)g_object_get_data (G_OBJECT (row), "pspec");
|
|
|
|
const char *text = gtk_editable_get_text (GTK_EDITABLE (pl->priv->search_entry));
|
|
|
|
|
|
|
|
return g_str_has_prefix (pspec->name, text);
|
|
|
|
}
|
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
static void
|
2014-05-07 03:24:20 +00:00
|
|
|
gtk_inspector_prop_list_init (GtkInspectorPropList *pl)
|
2014-05-03 01:48:33 +00:00
|
|
|
{
|
2014-05-07 03:24:20 +00:00
|
|
|
pl->priv = gtk_inspector_prop_list_get_instance_private (pl);
|
2014-05-05 01:08:36 +00:00
|
|
|
gtk_widget_init_template (GTK_WIDGET (pl));
|
2019-04-28 21:56:10 +00:00
|
|
|
apply_sort (pl, COLUMN_NAME, GTK_SORT_ASCENDING);
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
get_property (GObject *object,
|
2014-05-05 01:08:36 +00:00
|
|
|
guint param_id,
|
2014-05-03 01:48:33 +00:00
|
|
|
GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
2014-05-07 03:24:20 +00:00
|
|
|
GtkInspectorPropList *pl = GTK_INSPECTOR_PROP_LIST (object);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
|
|
|
switch (param_id)
|
|
|
|
{
|
2014-10-11 01:40:53 +00:00
|
|
|
case PROP_OBJECT_TREE:
|
|
|
|
g_value_take_object (value, pl->priv->object_tree);
|
2014-05-03 01:48:33 +00:00
|
|
|
break;
|
|
|
|
|
2016-03-07 01:41:28 +00:00
|
|
|
case PROP_SEARCH_ENTRY:
|
|
|
|
g_value_take_object (value, pl->priv->search_entry);
|
|
|
|
break;
|
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_property (GObject *object,
|
2014-05-05 01:08:36 +00:00
|
|
|
guint param_id,
|
2014-05-03 01:48:33 +00:00
|
|
|
const GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
2014-05-07 03:24:20 +00:00
|
|
|
GtkInspectorPropList *pl = GTK_INSPECTOR_PROP_LIST (object);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
|
|
|
switch (param_id)
|
|
|
|
{
|
2014-10-11 01:40:53 +00:00
|
|
|
case PROP_OBJECT_TREE:
|
|
|
|
pl->priv->object_tree = g_value_get_object (value);
|
2014-05-03 01:48:33 +00:00
|
|
|
break;
|
|
|
|
|
2016-03-07 01:41:28 +00:00
|
|
|
case PROP_SEARCH_ENTRY:
|
|
|
|
pl->priv->search_entry = g_value_get_object (value);
|
|
|
|
break;
|
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-18 05:03:24 +00:00
|
|
|
static void
|
|
|
|
show_object (GtkInspectorPropEditor *editor,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *name,
|
2014-05-31 03:21:13 +00:00
|
|
|
const gchar *tab,
|
2014-05-18 05:03:24 +00:00
|
|
|
GtkInspectorPropList *pl)
|
|
|
|
{
|
2019-02-13 18:04:00 +00:00
|
|
|
g_object_set_data_full (G_OBJECT (pl->priv->object_tree), "next-tab", g_strdup (tab), g_free);
|
2018-08-29 14:19:37 +00:00
|
|
|
gtk_inspector_object_tree_select_object (pl->priv->object_tree, object);
|
2019-02-13 18:41:15 +00:00
|
|
|
gtk_inspector_object_tree_activate_object (pl->priv->object_tree, object);
|
2014-05-18 05:03:24 +00:00
|
|
|
}
|
|
|
|
|
2014-05-21 10:39:11 +00:00
|
|
|
static void cleanup_object (GtkInspectorPropList *pl);
|
|
|
|
|
|
|
|
static void
|
|
|
|
finalize (GObject *object)
|
|
|
|
{
|
|
|
|
GtkInspectorPropList *pl = GTK_INSPECTOR_PROP_LIST (object);
|
|
|
|
|
|
|
|
cleanup_object (pl);
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2014-05-21 10:39:11 +00:00
|
|
|
G_OBJECT_CLASS (gtk_inspector_prop_list_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
2016-03-07 01:41:28 +00:00
|
|
|
static void
|
|
|
|
constructed (GObject *object)
|
|
|
|
{
|
|
|
|
GtkInspectorPropList *pl = GTK_INSPECTOR_PROP_LIST (object);
|
|
|
|
|
|
|
|
pl->priv->search_stack = gtk_widget_get_parent (pl->priv->search_entry);
|
|
|
|
|
|
|
|
g_signal_connect (pl->priv->search_entry, "stop-search",
|
|
|
|
G_CALLBACK (search_close_clicked), pl);
|
2019-04-03 11:11:44 +00:00
|
|
|
|
|
|
|
g_signal_connect_swapped (pl->priv->search_entry, "search-started",
|
|
|
|
G_CALLBACK (show_search_entry), pl);
|
2019-04-12 03:42:31 +00:00
|
|
|
g_signal_connect_swapped (pl->priv->search_entry, "search-changed",
|
|
|
|
G_CALLBACK (gtk_list_box_invalidate_filter), pl->priv->list2);
|
|
|
|
|
|
|
|
gtk_list_box_set_filter_func (GTK_LIST_BOX (pl->priv->list2), filter_func, pl, NULL);
|
2019-04-28 21:56:10 +00:00
|
|
|
gtk_list_box_set_sort_func (GTK_LIST_BOX (pl->priv->list2), sort_func, pl, NULL);
|
2016-03-07 01:41:28 +00:00
|
|
|
}
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
static void
|
2019-04-12 23:48:23 +00:00
|
|
|
update_key_capture (GtkInspectorPropList *pl)
|
2019-04-12 03:42:31 +00:00
|
|
|
{
|
2019-04-12 23:48:23 +00:00
|
|
|
GtkWidget *capture_widget;
|
|
|
|
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (pl)))
|
|
|
|
{
|
|
|
|
GtkWidget *toplevel;
|
|
|
|
GtkWidget *focus;
|
|
|
|
|
2019-05-20 04:47:50 +00:00
|
|
|
toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (pl)));
|
2019-04-12 23:48:23 +00:00
|
|
|
focus = gtk_root_get_focus (GTK_ROOT (toplevel));
|
|
|
|
|
|
|
|
if (GTK_IS_EDITABLE (focus) &&
|
|
|
|
gtk_widget_is_ancestor (focus, pl->priv->list2))
|
|
|
|
capture_widget = NULL;
|
|
|
|
else
|
|
|
|
capture_widget = toplevel;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
capture_widget = NULL;
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2019-04-12 23:48:23 +00:00
|
|
|
gtk_search_entry_set_key_capture_widget (GTK_SEARCH_ENTRY (pl->priv->search_entry),
|
|
|
|
capture_widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
map (GtkWidget *widget)
|
|
|
|
{
|
2019-04-12 03:42:31 +00:00
|
|
|
GTK_WIDGET_CLASS (gtk_inspector_prop_list_parent_class)->map (widget);
|
|
|
|
|
2019-04-12 23:48:23 +00:00
|
|
|
update_key_capture (GTK_INSPECTOR_PROP_LIST (widget));
|
2019-04-12 03:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
unmap (GtkWidget *widget)
|
|
|
|
{
|
2019-04-12 23:48:23 +00:00
|
|
|
GTK_WIDGET_CLASS (gtk_inspector_prop_list_parent_class)->unmap (widget);
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2019-04-12 23:48:23 +00:00
|
|
|
update_key_capture (GTK_INSPECTOR_PROP_LIST (widget));
|
|
|
|
}
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2019-04-12 23:48:23 +00:00
|
|
|
static void
|
|
|
|
root (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GTK_WIDGET_CLASS (gtk_inspector_prop_list_parent_class)->root (widget);
|
|
|
|
|
|
|
|
g_signal_connect_swapped (gtk_widget_get_root (widget), "notify::focus-widget",
|
|
|
|
G_CALLBACK (update_key_capture), widget);
|
2019-04-12 03:42:31 +00:00
|
|
|
}
|
|
|
|
|
2019-04-12 23:48:23 +00:00
|
|
|
static void
|
|
|
|
unroot (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_signal_handlers_disconnect_by_func (gtk_widget_get_root (widget),
|
|
|
|
update_key_capture, widget);
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_inspector_prop_list_parent_class)->unroot (widget);
|
|
|
|
}
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
static void
|
2014-05-07 03:24:20 +00:00
|
|
|
gtk_inspector_prop_list_class_init (GtkInspectorPropListClass *klass)
|
2014-05-03 01:48:33 +00:00
|
|
|
{
|
2014-05-05 01:08:36 +00:00
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2014-05-21 10:39:11 +00:00
|
|
|
object_class->finalize = finalize;
|
2014-05-03 01:48:33 +00:00
|
|
|
object_class->get_property = get_property;
|
|
|
|
object_class->set_property = set_property;
|
2016-03-07 01:41:28 +00:00
|
|
|
object_class->constructed = constructed;
|
2014-05-05 01:08:36 +00:00
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
widget_class->map = map;
|
|
|
|
widget_class->unmap = unmap;
|
2019-04-12 23:48:23 +00:00
|
|
|
widget_class->root = root;
|
|
|
|
widget_class->unroot = unroot;
|
2019-04-12 03:42:31 +00:00
|
|
|
|
2014-10-11 01:40:53 +00:00
|
|
|
g_object_class_install_property (object_class, PROP_OBJECT_TREE,
|
|
|
|
g_param_spec_object ("object-tree", "Object Tree", "Object tree",
|
2014-05-05 01:08:36 +00:00
|
|
|
GTK_TYPE_WIDGET, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
|
2016-03-07 01:41:28 +00:00
|
|
|
g_object_class_install_property (object_class, PROP_SEARCH_ENTRY,
|
|
|
|
g_param_spec_object ("search-entry", "Search Entry", "Search Entry",
|
|
|
|
GTK_TYPE_WIDGET, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
|
2014-11-30 20:59:53 +00:00
|
|
|
gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/prop-list.ui");
|
2019-04-12 03:42:31 +00:00
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, list2);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, names);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, types);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, values);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, origins);
|
2019-04-28 21:56:10 +00:00
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, name_heading);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, name_sort_indicator);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, origin_heading);
|
|
|
|
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorPropList, origin_sort_indicator);
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, sort_changed);
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 01:55:46 +00:00
|
|
|
/* Like g_strdup_value_contents, but keeps the type name separate */
|
2019-04-12 19:07:01 +00:00
|
|
|
void
|
2016-03-10 01:55:46 +00:00
|
|
|
strdup_value_contents (const GValue *value,
|
|
|
|
gchar **contents,
|
|
|
|
gchar **type)
|
|
|
|
{
|
|
|
|
const gchar *src;
|
|
|
|
|
|
|
|
if (G_VALUE_HOLDS_STRING (value))
|
|
|
|
{
|
|
|
|
src = g_value_get_string (value);
|
|
|
|
|
|
|
|
*type = g_strdup ("char*");
|
|
|
|
|
|
|
|
if (!src)
|
|
|
|
{
|
|
|
|
*contents = g_strdup ("NULL");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gchar *s = g_strescape (src, NULL);
|
|
|
|
*contents = g_strdup_printf ("\"%s\"", s);
|
|
|
|
g_free (s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
|
|
|
|
{
|
|
|
|
GValue tmp_value = G_VALUE_INIT;
|
|
|
|
|
|
|
|
*type = g_strdup (g_type_name (G_VALUE_TYPE (value)));
|
|
|
|
|
|
|
|
g_value_init (&tmp_value, G_TYPE_STRING);
|
|
|
|
g_value_transform (value, &tmp_value);
|
|
|
|
src = g_value_get_string (&tmp_value);
|
|
|
|
if (!src)
|
|
|
|
*contents = g_strdup ("NULL");
|
|
|
|
else
|
|
|
|
*contents = g_strescape (src, NULL);
|
|
|
|
g_value_unset (&tmp_value);
|
|
|
|
}
|
|
|
|
else if (g_value_fits_pointer (value))
|
|
|
|
{
|
|
|
|
gpointer p = g_value_peek_pointer (value);
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
{
|
|
|
|
*type = g_strdup (g_type_name (G_VALUE_TYPE (value)));
|
|
|
|
*contents = g_strdup ("NULL");
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS_OBJECT (value))
|
|
|
|
{
|
|
|
|
*type = g_strdup (G_OBJECT_TYPE_NAME (p));
|
|
|
|
*contents = g_strdup_printf ("%p", p);
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS_PARAM (value))
|
|
|
|
{
|
|
|
|
*type = g_strdup (G_PARAM_SPEC_TYPE_NAME (p));
|
|
|
|
*contents = g_strdup_printf ("%p", p);
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
|
|
|
|
{
|
|
|
|
GStrv strv = g_value_get_boxed (value);
|
|
|
|
GString *tmp = g_string_new ("[");
|
|
|
|
|
|
|
|
while (*strv != NULL)
|
|
|
|
{
|
|
|
|
gchar *escaped = g_strescape (*strv, NULL);
|
|
|
|
|
|
|
|
g_string_append_printf (tmp, "\"%s\"", escaped);
|
|
|
|
g_free (escaped);
|
|
|
|
|
|
|
|
if (*++strv != NULL)
|
|
|
|
g_string_append (tmp, ", ");
|
|
|
|
}
|
|
|
|
|
|
|
|
g_string_append (tmp, "]");
|
|
|
|
*type = g_strdup ("char**");
|
|
|
|
*contents = g_string_free (tmp, FALSE);
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS_BOXED (value))
|
|
|
|
{
|
|
|
|
*type = g_strdup (g_type_name (G_VALUE_TYPE (value)));
|
|
|
|
*contents = g_strdup_printf ("%p", p);
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS_POINTER (value))
|
|
|
|
{
|
|
|
|
*type = g_strdup ("gpointer");
|
|
|
|
*contents = g_strdup_printf ("%p", p);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*type = g_strdup ("???");
|
|
|
|
*contents = g_strdup ("???");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*type = g_strdup ("???");
|
|
|
|
*contents = g_strdup ("???");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
static GtkWidget *
|
|
|
|
gtk_inspector_prop_list_create_row (GtkInspectorPropList *pl,
|
|
|
|
GParamSpec *prop)
|
2014-05-03 01:48:33 +00:00
|
|
|
{
|
|
|
|
GValue gvalue = {0};
|
2016-03-10 01:55:46 +00:00
|
|
|
gchar *value;
|
|
|
|
gchar *type;
|
2014-05-08 14:16:58 +00:00
|
|
|
gchar *attribute = NULL;
|
2016-03-10 02:42:08 +00:00
|
|
|
gboolean writable;
|
2019-04-12 03:42:31 +00:00
|
|
|
GtkWidget *row;
|
|
|
|
GtkWidget *box;
|
|
|
|
GtkWidget *label;
|
|
|
|
GtkWidget *widget;
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2014-05-08 14:16:58 +00:00
|
|
|
g_value_init (&gvalue, prop->value_type);
|
2019-04-02 21:56:26 +00:00
|
|
|
g_object_get_property (pl->priv->object, prop->name, &gvalue);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2016-03-10 01:55:46 +00:00
|
|
|
strdup_value_contents (&gvalue, &value, &type);
|
2014-05-08 14:16:58 +00:00
|
|
|
|
|
|
|
if (GTK_IS_CELL_RENDERER (pl->priv->object))
|
|
|
|
{
|
2014-05-19 04:13:30 +00:00
|
|
|
gpointer *layout;
|
2014-05-20 13:45:50 +00:00
|
|
|
GtkCellArea *area;
|
2014-05-08 14:16:58 +00:00
|
|
|
gint column = -1;
|
|
|
|
|
2014-05-19 04:13:30 +00:00
|
|
|
area = NULL;
|
|
|
|
layout = g_object_get_data (pl->priv->object, "gtk-inspector-cell-layout");
|
|
|
|
if (layout)
|
|
|
|
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
|
2014-05-08 14:16:58 +00:00
|
|
|
if (area)
|
2014-05-20 13:45:50 +00:00
|
|
|
column = gtk_cell_area_attribute_get_column (area,
|
2014-05-08 14:16:58 +00:00
|
|
|
GTK_CELL_RENDERER (pl->priv->object),
|
|
|
|
prop->name);
|
|
|
|
|
|
|
|
if (column != -1)
|
|
|
|
attribute = g_strdup_printf ("%d", column);
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 02:42:08 +00:00
|
|
|
writable = ((prop->flags & G_PARAM_WRITABLE) != 0) &&
|
|
|
|
((prop->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
row = gtk_list_box_row_new ();
|
|
|
|
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
|
|
|
|
g_object_set_data (G_OBJECT (row), "pspec", prop);
|
|
|
|
|
|
|
|
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
|
2020-05-03 04:09:18 +00:00
|
|
|
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
|
2019-04-12 03:42:31 +00:00
|
|
|
|
|
|
|
label = gtk_label_new (prop->name);
|
2020-04-10 16:08:16 +00:00
|
|
|
gtk_widget_add_css_class (label, "cell");
|
2019-04-12 03:42:31 +00:00
|
|
|
gtk_widget_set_sensitive (label, writable);
|
|
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0);
|
|
|
|
gtk_size_group_add_widget (pl->priv->names, label);
|
|
|
|
gtk_container_add (GTK_CONTAINER (box), label);
|
|
|
|
|
|
|
|
label = gtk_label_new (type ? type : "");
|
2020-04-10 16:08:16 +00:00
|
|
|
gtk_widget_add_css_class (label, "cell");
|
2019-04-12 03:42:31 +00:00
|
|
|
gtk_widget_set_sensitive (label, writable);
|
|
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0);
|
|
|
|
gtk_size_group_add_widget (pl->priv->types, label);
|
|
|
|
gtk_container_add (GTK_CONTAINER (box), label);
|
|
|
|
|
|
|
|
label = gtk_label_new (g_type_name (prop->owner_type));
|
2020-04-10 16:08:16 +00:00
|
|
|
gtk_widget_add_css_class (label, "cell");
|
2019-04-12 03:42:31 +00:00
|
|
|
gtk_widget_set_sensitive (label, writable);
|
|
|
|
gtk_label_set_xalign (GTK_LABEL (label), 0);
|
|
|
|
gtk_size_group_add_widget (pl->priv->origins, label);
|
|
|
|
gtk_container_add (GTK_CONTAINER (box), label);
|
|
|
|
|
2019-04-12 18:34:11 +00:00
|
|
|
widget = gtk_inspector_prop_editor_new (pl->priv->object, prop->name, pl->priv->values);
|
2020-04-10 16:08:16 +00:00
|
|
|
gtk_widget_add_css_class (widget, "cell");
|
2019-04-12 03:42:31 +00:00
|
|
|
gtk_container_add (GTK_CONTAINER (box), widget);
|
|
|
|
g_signal_connect (widget, "show-object", G_CALLBACK (show_object), pl);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
|
|
|
g_free (value);
|
2016-03-10 01:55:46 +00:00
|
|
|
g_free (type);
|
2014-05-08 14:16:58 +00:00
|
|
|
g_free (attribute);
|
2014-05-03 01:48:33 +00:00
|
|
|
g_value_unset (&gvalue);
|
2019-04-12 03:42:31 +00:00
|
|
|
|
|
|
|
return row;
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
|
|
|
|
2014-05-09 02:58:43 +00:00
|
|
|
static void
|
|
|
|
cleanup_object (GtkInspectorPropList *pl)
|
|
|
|
{
|
2014-05-21 10:39:11 +00:00
|
|
|
if (pl->priv->object &&
|
|
|
|
g_signal_handler_is_connected (pl->priv->object, pl->priv->notify_handler_id))
|
|
|
|
g_signal_handler_disconnect (pl->priv->object, pl->priv->notify_handler_id);
|
2014-05-09 02:58:43 +00:00
|
|
|
|
|
|
|
pl->priv->object = NULL;
|
2014-05-21 10:39:11 +00:00
|
|
|
pl->priv->notify_handler_id = 0;
|
2014-05-09 02:58:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-03 20:43:04 +00:00
|
|
|
gboolean
|
2014-05-07 03:24:20 +00:00
|
|
|
gtk_inspector_prop_list_set_object (GtkInspectorPropList *pl,
|
|
|
|
GObject *object)
|
2014-05-03 01:48:33 +00:00
|
|
|
{
|
|
|
|
GParamSpec **props;
|
|
|
|
guint num_properties;
|
|
|
|
guint i;
|
2019-04-12 03:42:31 +00:00
|
|
|
GtkWidget *w;
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2014-10-25 01:14:16 +00:00
|
|
|
if (!object)
|
2014-05-03 20:43:04 +00:00
|
|
|
return FALSE;
|
|
|
|
|
2014-10-25 01:14:16 +00:00
|
|
|
if (pl->priv->object == object)
|
|
|
|
return TRUE;
|
|
|
|
|
2014-05-09 02:58:43 +00:00
|
|
|
cleanup_object (pl);
|
2014-05-03 01:48:33 +00:00
|
|
|
|
2019-02-17 04:58:54 +00:00
|
|
|
gtk_editable_set_text (GTK_EDITABLE (pl->priv->search_entry), "");
|
2014-11-22 16:41:24 +00:00
|
|
|
gtk_stack_set_visible_child_name (GTK_STACK (pl->priv->search_stack), "title");
|
2016-03-07 01:41:28 +00:00
|
|
|
|
2019-04-02 21:56:26 +00:00
|
|
|
props = g_object_class_list_properties (G_OBJECT_GET_CLASS (object), &num_properties);
|
2014-05-03 19:57:16 +00:00
|
|
|
|
2014-05-21 10:39:11 +00:00
|
|
|
pl->priv->object = object;
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
while ((w = gtk_widget_get_first_child (pl->priv->list2)) != NULL)
|
|
|
|
gtk_widget_destroy (w);
|
|
|
|
|
2014-05-03 01:48:33 +00:00
|
|
|
for (i = 0; i < num_properties; i++)
|
|
|
|
{
|
|
|
|
GParamSpec *prop = props[i];
|
2019-04-12 03:42:31 +00:00
|
|
|
GtkWidget *row;
|
2014-05-03 01:48:33 +00:00
|
|
|
|
|
|
|
if (! (prop->flags & G_PARAM_READABLE))
|
|
|
|
continue;
|
|
|
|
|
2019-04-12 03:42:31 +00:00
|
|
|
row = gtk_inspector_prop_list_create_row (pl, prop);
|
2019-04-28 21:56:10 +00:00
|
|
|
gtk_container_add (GTK_CONTAINER (pl->priv->list2), row);
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
2014-05-03 20:43:04 +00:00
|
|
|
|
2014-05-21 10:39:11 +00:00
|
|
|
g_free (props);
|
|
|
|
|
|
|
|
if (GTK_IS_WIDGET (object))
|
2014-09-26 03:05:15 +00:00
|
|
|
g_signal_connect_object (object, "destroy", G_CALLBACK (cleanup_object), pl, G_CONNECT_SWAPPED);
|
2014-05-21 10:39:11 +00:00
|
|
|
|
2014-05-10 03:57:57 +00:00
|
|
|
gtk_widget_show (GTK_WIDGET (pl));
|
2014-05-21 10:39:11 +00:00
|
|
|
|
2014-05-03 20:43:04 +00:00
|
|
|
return TRUE;
|
2014-05-03 01:48:33 +00:00
|
|
|
}
|
|
|
|
|
2019-04-05 19:15:16 +00:00
|
|
|
void
|
|
|
|
gtk_inspector_prop_list_set_layout_child (GtkInspectorPropList *pl,
|
|
|
|
GObject *object)
|
|
|
|
{
|
|
|
|
GtkWidget *stack;
|
|
|
|
GtkStackPage *page;
|
|
|
|
GtkWidget *parent;
|
|
|
|
GtkLayoutManager *layout_manager;
|
|
|
|
GtkLayoutChild *layout_child;
|
|
|
|
|
|
|
|
stack = gtk_widget_get_parent (GTK_WIDGET (pl));
|
|
|
|
page = gtk_stack_get_page (GTK_STACK (stack), GTK_WIDGET (pl));
|
|
|
|
g_object_set (page, "visible", FALSE, NULL);
|
|
|
|
|
|
|
|
if (!GTK_IS_WIDGET (object))
|
|
|
|
return;
|
|
|
|
|
|
|
|
parent = gtk_widget_get_parent (GTK_WIDGET (object));
|
|
|
|
if (!parent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
layout_manager = gtk_widget_get_layout_manager (parent);
|
|
|
|
if (!layout_manager)
|
|
|
|
return;
|
|
|
|
|
2019-04-05 19:44:16 +00:00
|
|
|
if (GTK_LAYOUT_MANAGER_GET_CLASS (layout_manager)->layout_child_type == G_TYPE_INVALID)
|
|
|
|
return;
|
|
|
|
|
2019-04-05 19:15:16 +00:00
|
|
|
layout_child = gtk_layout_manager_get_layout_child (layout_manager, GTK_WIDGET (object));
|
|
|
|
if (!layout_child)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!gtk_inspector_prop_list_set_object (pl, G_OBJECT (layout_child)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
g_object_set (page, "visible", TRUE, NULL);
|
|
|
|
}
|
|
|
|
|
2014-05-05 01:08:36 +00:00
|
|
|
// vim: set et sw=2 ts=2:
|