AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
641f2f72cd
gtk2/gtk/inspector/object-tree.c
Matthias Clasen 2a24b8c653 Replace most remaining uses of container api 
These are all on GtkBox or enumerating children.
2020-05-11 22:38:21 -04:00

1274 lines
36 KiB
C
Raw Blame History

/*
* Copyright (c) 2008-2009 Christian Hammond
* Copyright (c) 2008-2009 David Trowbridge
* Copyright (c) 2013 Intel Corporation
*
* 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.
*/
#include "config.h"
#include <glib/gi18n-lib.h>
#include <string.h>
#include "object-tree.h"
#include "prop-list.h"
#include "window.h"
#include "gtkbuildable.h"
#include "gtkbutton.h"
#include "gtkcelllayout.h"
#include "gtkcomboboxprivate.h"
#include "gtkfilterlistmodel.h"
#include "gtkflattenlistmodel.h"
#include "gtkbuiltiniconprivate.h"
#include "gtkiconview.h"
#include "gtklabel.h"
#include "gtklistbox.h"
#include "gtkpopover.h"
#include "gtksettings.h"
#include "gtksizegroup.h"
#include "gtktextview.h"
#include "gtktogglebutton.h"
#include "gtktreelistmodel.h"
#include "gtktreeview.h"
#include "gtktreeselection.h"
#include "gtktreestore.h"
#include "gtktreemodelsort.h"
#include "gtktreemodelfilter.h"
#include "gtkwidgetprivate.h"
#include "gtkstylecontext.h"
#include "gtksearchbar.h"
#include "gtksearchentry.h"
#include "gtkeventcontrollerkey.h"
enum
{
OBJECT_SELECTED,
OBJECT_ACTIVATED,
LAST_SIGNAL
};
struct _GtkInspectorObjectTreePrivate
{
GtkListBox *list;
GtkTreeListModel *tree_model;
GtkWidget *search_bar;
GtkWidget *search_entry;
GtkSizeGroup *type_size_group;
GtkSizeGroup *name_size_group;
GtkSizeGroup *label_size_group;
};
typedef struct _ObjectTreeClassFuncs ObjectTreeClassFuncs;
typedef void (* ObjectTreeForallFunc) (GObject *object,
const char *name,
gpointer data);
struct _ObjectTreeClassFuncs {
GType (* get_type) (void);
GObject * (* get_parent) (GObject *object);
GListModel * (* get_children) (GObject *object);
};
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorObjectTree, gtk_inspector_object_tree, GTK_TYPE_BOX)
static GObject *
object_tree_get_parent_default (GObject *object)
{
return g_object_get_data (object, "inspector-object-tree-parent");
}
static GListModel *
object_tree_get_children_default (GObject *object)
{
return NULL;
}
static GObject *
object_tree_widget_get_parent (GObject *object)
{
return G_OBJECT (gtk_widget_get_parent (GTK_WIDGET (object)));
}
static GListModel *
object_tree_widget_get_children (GObject *object)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkFlattenListModel *flatten;
GListStore *list;
GListModel *sublist;
list = g_list_store_new (G_TYPE_LIST_MODEL);
sublist = gtk_widget_observe_children (widget);
g_list_store_append (list, sublist);
g_object_unref (sublist);
sublist = gtk_widget_observe_controllers (widget);
g_list_store_append (list, sublist);
g_object_unref (sublist);
flatten = gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (list));
g_object_unref (list);
return G_LIST_MODEL (flatten);
}
static GListModel *
object_tree_tree_model_sort_get_children (GObject *object)
{
GListStore *store;
store = g_list_store_new (G_TYPE_OBJECT);
g_list_store_append (store, gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (object)));
return G_LIST_MODEL (store);
}
static GListModel *
object_tree_tree_model_filter_get_children (GObject *object)
{
GListStore *store;
store = g_list_store_new (G_TYPE_OBJECT);
g_list_store_append (store, gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (object)));
return G_LIST_MODEL (store);
}
static void
update_list_store (GListStore *store,
GObject *object,
const char *property)
{
gpointer value;
g_object_get (object, property, &value, NULL);
if (value)
{
g_list_store_splice (store,
0,
g_list_model_get_n_items (G_LIST_MODEL (store)),
&value,
1);
g_object_unref (value);
}
else
{
g_list_store_remove_all (store);
}
}
static void
list_model_for_property_notify_cb (GObject *object,
GParamSpec *pspec,
GListStore *store)
{
update_list_store (store, object, pspec->name);
}
static GListModel *
list_model_for_property (GObject *object,
const char *property)
{
GListStore *store = g_list_store_new (G_TYPE_OBJECT);
/* g_signal_connect_object ("notify::property") */
g_signal_connect_closure_by_id (object,
g_signal_lookup ("notify", G_OBJECT_TYPE (object)),
g_quark_from_static_string (property),
g_cclosure_new_object (G_CALLBACK (list_model_for_property_notify_cb), G_OBJECT (store)),
FALSE);
update_list_store (store, object, property);
return G_LIST_MODEL (store);
}
static GListModel *
list_model_for_properties (GObject *object,
const char **props)
{
GListStore *concat;
GListModel *result;
guint i;
if (props[1] == NULL)
return list_model_for_property (object, props[0]);
concat = g_list_store_new (G_TYPE_LIST_MODEL);
for (i = 0; props[i]; i++)
{
GListModel *tmp = list_model_for_property (object, props[i]);
g_list_store_append (concat, tmp);
g_object_unref (tmp);
}
result = G_LIST_MODEL (gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (concat)));
g_object_unref (concat);
return result;
}
static GListModel *
object_tree_combo_box_get_children (GObject *object)
{
return list_model_for_properties (object, (const char *[2]) { "model", NULL });
}
static void
treeview_columns_changed (GtkTreeView *treeview,
GListModel *store)
{
GtkTreeViewColumn *column, *item;
guint i, n_columns, n_items;
n_columns = gtk_tree_view_get_n_columns (treeview);
n_items = g_list_model_get_n_items (store);
for (i = 0; i < MAX (n_columns, n_items); i++)
{
column = gtk_tree_view_get_column (treeview, i);
item = g_list_model_get_item (store, i);
g_object_unref (item);
if (column == item)
continue;
if (n_columns < n_items)
{
/* column removed */
g_assert (n_columns + 1 == n_items);
g_list_store_remove (G_LIST_STORE (store), i);
return;
}
else if (n_columns > n_items)
{
/* column added */
g_assert (n_columns - 1 == n_items);
g_list_store_insert (G_LIST_STORE (store), i, column);
return;
}
else
{
guint j;
/* column reordered */
for (j = n_columns - 1; j > i; j--)
{
column = gtk_tree_view_get_column (treeview, j);
item = g_list_model_get_item (store, j);
g_object_unref (item);
if (column != item)
break;
}
g_assert (j > i);
column = gtk_tree_view_get_column (treeview, i);
item = g_list_model_get_item (store, j);
g_object_unref (item);
if (item == column)
{
/* column was removed from position j and put into position i */
g_list_store_remove (G_LIST_STORE (store), j);
g_list_store_insert (G_LIST_STORE (store), i, column);
}
else
{
/* column was removed from position i and put into position j */
column = gtk_tree_view_get_column (treeview, j);
g_list_store_remove (G_LIST_STORE (store), i);
g_list_store_insert (G_LIST_STORE (store), j, column);
}
}
}
}
static GListModel *
object_tree_tree_view_get_children (GObject *object)
{
GtkTreeView *treeview = GTK_TREE_VIEW (object);
GListStore *columns, *selection, *result_list;
GListModel *props;
GtkFlattenListModel *result;
guint i;
props = list_model_for_properties (object, (const char *[2]) { "model", NULL });
columns = g_list_store_new (GTK_TYPE_TREE_VIEW_COLUMN);
g_signal_connect_object (treeview, "columns-changed", G_CALLBACK (treeview_columns_changed), columns, 0);
for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
g_list_store_append (columns, gtk_tree_view_get_column (treeview, i));
selection = g_list_store_new (GTK_TYPE_TREE_SELECTION);
g_list_store_append (selection, gtk_tree_view_get_selection (treeview));
result_list = g_list_store_new (G_TYPE_LIST_MODEL);
g_list_store_append (result_list, props);
g_object_unref (props);
g_list_store_append (result_list, selection);
g_object_unref (selection);
g_list_store_append (result_list, columns);
g_object_unref (columns);
result = gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (result_list));
g_object_unref (result_list);
return G_LIST_MODEL (result);
}
static GListModel *
object_tree_icon_view_get_children (GObject *object)
{
return list_model_for_properties (object, (const char *[2]) { "model", NULL });
}
static gboolean
object_tree_cell_area_add_child (GtkCellRenderer *renderer,
gpointer store)
{
gpointer cell_layout;
cell_layout = g_object_get_data (store, "gtk-inspector-cell-layout");
g_object_set_data (G_OBJECT (renderer), "gtk-inspector-cell-layout", cell_layout);
g_list_store_append (store, renderer);
return FALSE;
}
static GListModel *
object_tree_cell_area_get_children (GObject *object)
{
GListStore *store;
gpointer cell_layout;
cell_layout = g_object_get_data (object, "gtk-inspector-cell-layout");
store = g_list_store_new (GTK_TYPE_CELL_RENDERER);
g_object_set_data (G_OBJECT (store), "gtk-inspector-cell-layout", cell_layout);
/* XXX: no change notification for cell areas */
gtk_cell_area_foreach (GTK_CELL_AREA (object), object_tree_cell_area_add_child, store);
return G_LIST_MODEL (store);
}
static GListModel *
object_tree_cell_layout_get_children (GObject *object)
{
GListStore *store;
GtkCellArea *area;
/* cell areas handle their own stuff */
if (GTK_IS_CELL_AREA (object))
return NULL;
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (object));
if (!area)
return NULL;
g_object_set_data (G_OBJECT (area), "gtk-inspector-cell-layout", object);
/* XXX: are cell areas immutable? */
store = g_list_store_new (G_TYPE_OBJECT);
g_list_store_append (store, area);
return G_LIST_MODEL (store);
}
static GListModel *
object_tree_text_view_get_children (GObject *object)
{
return list_model_for_properties (object, (const char *[2]) { "buffer", NULL });
}
static GListModel *
object_tree_text_buffer_get_children (GObject *object)
{
return list_model_for_properties (object, (const char *[2]) { "tag-table", NULL });
}
static void
text_tag_added (GtkTextTagTable *table,
GtkTextTag *tag,
GListStore *store)
{
g_list_store_append (store, tag);
}
static void
text_tag_removed (GtkTextTagTable *table,
GtkTextTag *tag,
GListStore *store)
{
guint i;
for (i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (store)); i++)
{
gpointer item = g_list_model_get_item (G_LIST_MODEL (store), i);
g_object_unref (item);
if (tag == item)
{
g_list_store_remove (store, i);
return;
}
}
}
static void
text_tag_foreach (GtkTextTag *tag,
gpointer store)
{
g_list_store_append (store, tag);
}
static GListModel *
object_tree_text_tag_table_get_children (GObject *object)
{
GListStore *store = g_list_store_new (GTK_TYPE_TEXT_TAG);
g_signal_connect_object (object, "tag-added", G_CALLBACK (text_tag_added), store, 0);
g_signal_connect_object (object, "tag-removed", G_CALLBACK (text_tag_removed), store, 0);
gtk_text_tag_table_foreach (GTK_TEXT_TAG_TABLE (object), text_tag_foreach, store);
return NULL;
}
static GListModel *
object_tree_application_get_children (GObject *object)
{
return list_model_for_properties (object, (const char *[3]) { "app-menu", "menubar", NULL });
}
static GObject *
object_tree_event_controller_get_parent (GObject *object)
{
return G_OBJECT (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (object)));
}
/* Note:
* This tree must be sorted with the most specific types first.
* We iterate over it top to bottom and return the first match
* using g_type_is_a ()
*/
static const ObjectTreeClassFuncs object_tree_class_funcs[] = {
{
gtk_application_get_type,
object_tree_get_parent_default,
object_tree_application_get_children
},
{
gtk_text_tag_table_get_type,
object_tree_get_parent_default,
object_tree_text_tag_table_get_children
},
{
gtk_text_buffer_get_type,
object_tree_get_parent_default,
object_tree_text_buffer_get_children
},
{
gtk_text_view_get_type,
object_tree_widget_get_parent,
object_tree_text_view_get_children
},
{
gtk_icon_view_get_type,
object_tree_widget_get_parent,
object_tree_icon_view_get_children
},
{
gtk_tree_view_get_type,
object_tree_widget_get_parent,
object_tree_tree_view_get_children
},
{
gtk_combo_box_get_type,
object_tree_widget_get_parent,
object_tree_combo_box_get_children
},
{
gtk_widget_get_type,
object_tree_widget_get_parent,
object_tree_widget_get_children
},
{
gtk_tree_model_filter_get_type,
object_tree_get_parent_default,
object_tree_tree_model_filter_get_children
},
{
gtk_tree_model_sort_get_type,
object_tree_get_parent_default,
object_tree_tree_model_sort_get_children
},
{
gtk_cell_area_get_type,
object_tree_get_parent_default,
object_tree_cell_area_get_children
},
{
gtk_cell_layout_get_type,
object_tree_get_parent_default,
object_tree_cell_layout_get_children
},
{
gtk_event_controller_get_type,
object_tree_event_controller_get_parent,
object_tree_get_children_default
},
{
g_object_get_type,
object_tree_get_parent_default,
object_tree_get_children_default
},
};
static const ObjectTreeClassFuncs *
find_class_funcs (GObject *object)
{
GType object_type;
guint i;
object_type = G_OBJECT_TYPE (object);
for (i = 0; i < G_N_ELEMENTS (object_tree_class_funcs); i++)
{
if (g_type_is_a (object_type, object_tree_class_funcs[i].get_type ()))
return &object_tree_class_funcs[i];
}
g_assert_not_reached ();
return NULL;
}
static GObject *
object_get_parent (GObject *object)
{
const ObjectTreeClassFuncs *funcs;
funcs = find_class_funcs (object);
return funcs->get_parent (object);
}
static GListModel *
object_get_children (GObject *object)
{
GType object_type;
GListModel *result, *children;
GListStore *result_list;
guint i;
object_type = G_OBJECT_TYPE (object);
result = NULL;
result_list = NULL;
for (i = 0; i < G_N_ELEMENTS (object_tree_class_funcs); i++)
{
if (!g_type_is_a (object_type, object_tree_class_funcs[i].get_type ()))
continue;
children = object_tree_class_funcs[i].get_children (object);
if (children == NULL)
continue;
if (result_list)
{
g_list_store_append (result_list, children);
g_object_unref (children);
}
else if (result == NULL)
{
result = children;
}
else
{
result_list = g_list_store_new (G_TYPE_LIST_MODEL);
g_list_store_append (result_list, result);
g_object_unref (result);
g_list_store_append (result_list, children);
g_object_unref (children);
}
}
if (result_list)
{
result = G_LIST_MODEL (gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (result_list)));
g_object_unref (result_list);
}
return result;
}
static const char *
gtk_inspector_get_object_name (GObject *object)
{
if (GTK_IS_WIDGET (object))
{
const gchar *id;
id = gtk_widget_get_name (GTK_WIDGET (object));
if (id != NULL && g_strcmp0 (id, G_OBJECT_TYPE_NAME (object)) != 0)
return id;
}
if (GTK_IS_BUILDABLE (object))
{
const gchar *id;
id = gtk_buildable_get_name (GTK_BUILDABLE (object));
if (id != NULL && !g_str_has_prefix (id, "___object_"))
return id;
}
if (GTK_IS_EVENT_CONTROLLER (object))
{
return gtk_event_controller_get_name (GTK_EVENT_CONTROLLER (object));
}
return NULL;
}
char *
gtk_inspector_get_object_title (GObject *object)
{
const char *name = gtk_inspector_get_object_name (object);
if (name == NULL)
return g_strdup (G_OBJECT_TYPE_NAME (object));
else
return g_strconcat (G_OBJECT_TYPE_NAME (object), " — ", name, NULL);
}
void
gtk_inspector_object_tree_activate_object (GtkInspectorObjectTree *wt,
GObject *object)
{
gtk_inspector_object_tree_select_object (wt, object);
g_signal_emit (wt, signals[OBJECT_ACTIVATED], 0, object);
}
static void
on_row_activated (GtkListBox *box,
GtkListBoxRow *row,
GtkInspectorObjectTree *wt)
{
guint pos;
GtkTreeListRow *item;
GObject *object;
pos = gtk_list_box_row_get_index (row);
item = g_list_model_get_item (G_LIST_MODEL (wt->priv->tree_model), pos);
object = gtk_tree_list_row_get_item (item);
gtk_inspector_object_tree_activate_object (wt, object);
g_object_unref (item);
g_object_unref (object);
}
GObject *
gtk_inspector_object_tree_get_selected (GtkInspectorObjectTree *wt)
{
GtkListBoxRow *selected_row;
guint selected_pos;
GtkTreeListRow *selected_row_item;
GObject *object;
selected_row = gtk_list_box_get_selected_row (wt->priv->list);
if (selected_row == NULL)
return NULL;
selected_pos = gtk_list_box_row_get_index (selected_row);
selected_row_item = g_list_model_get_item (G_LIST_MODEL (wt->priv->tree_model), selected_pos);
object = gtk_tree_list_row_get_item (selected_row_item);
g_object_unref (selected_row_item);
g_object_unref (object); /* ahem */
return object;
}
static void
widget_mapped (GtkWidget *widget,
GtkListBoxRow *row)
{
gtk_widget_remove_css_class (GTK_WIDGET (row), "dim-label");
}
static void
widget_unmapped (GtkWidget *widget,
GtkListBoxRow *row)
{
gtk_widget_add_css_class (GTK_WIDGET (row), "dim-label");
}
static gboolean
search (GtkInspectorObjectTree *wt,
gboolean forward,
gboolean force_progress);
static gboolean
key_pressed (GtkEventController *controller,
guint keyval,
guint keycode,
GdkModifierType state,
GtkInspectorObjectTree *wt)
{
if (gtk_widget_get_mapped (GTK_WIDGET (wt)))
{
GdkModifierType default_accel;
gboolean search_started;
search_started = gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar));
default_accel = GDK_CONTROL_MASK;
if (search_started &&
(keyval == GDK_KEY_Return ||
keyval == GDK_KEY_ISO_Enter ||
keyval == GDK_KEY_KP_Enter))
{
gtk_widget_activate (GTK_WIDGET (wt->priv->list));
return GDK_EVENT_PROPAGATE;
}
else if (search_started &&
(keyval == GDK_KEY_Escape))
{
gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar), FALSE);
return GDK_EVENT_STOP;
}
else if (search_started &&
((state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK)) &&
(keyval == GDK_KEY_g || keyval == GDK_KEY_G))
{
if (!search (wt, TRUE, TRUE))
gtk_widget_error_bell (GTK_WIDGET (wt));
return GDK_EVENT_STOP;
}
else if (search_started &&
((state & (default_accel | GDK_SHIFT_MASK)) == default_accel) &&
(keyval == GDK_KEY_g || keyval == GDK_KEY_G))
{
if (!search (wt, TRUE, TRUE))
gtk_widget_error_bell (GTK_WIDGET (wt));
return GDK_EVENT_STOP;
}
}
return GDK_EVENT_PROPAGATE;
}
static void
destroy_controller (GtkEventController *controller)
{
gtk_widget_remove_controller (gtk_event_controller_get_widget (controller), controller);
}
static gboolean toplevel_filter_func (gpointer item,
gpointer data);
static void
map (GtkWidget *widget)
{
GtkInspectorObjectTree *wt = GTK_INSPECTOR_OBJECT_TREE (widget);
GtkEventController *controller;
GtkWidget *toplevel;
GTK_WIDGET_CLASS (gtk_inspector_object_tree_parent_class)->map (widget);
toplevel = GTK_WIDGET (gtk_widget_get_root (widget));
controller = gtk_event_controller_key_new ();
g_object_set_data_full (G_OBJECT (toplevel), "object-controller", controller, (GDestroyNotify)destroy_controller);
g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), widget);
gtk_widget_add_controller (toplevel, controller);
gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (wt->priv->search_bar), toplevel);
}
static void
unmap (GtkWidget *widget)
{
GtkWidget *toplevel;
toplevel = GTK_WIDGET (gtk_widget_get_root (widget));
g_object_set_data (G_OBJECT (toplevel), "object-controller", NULL);
GTK_WIDGET_CLASS (gtk_inspector_object_tree_parent_class)->unmap (widget);
}
static gboolean
match_string (const gchar *string,
const gchar *text)
{
gchar *lower;
gboolean match = FALSE;
if (string)
{
lower = g_ascii_strdown (string, -1);
match = g_str_has_prefix (lower, text);
g_free (lower);
}
return match;
}
static gboolean
match_object (GObject *object,
const char *text)
{
if (match_string (G_OBJECT_TYPE_NAME (object), text) ||
match_string (gtk_inspector_get_object_name (object), text))
return TRUE;
if (GTK_IS_LABEL (object))
return match_string (gtk_label_get_label (GTK_LABEL (object)), text);
else if (GTK_IS_BUTTON (object))
return match_string (gtk_button_get_label (GTK_BUTTON (object)), text);
else if (GTK_IS_WINDOW (object))
return match_string (gtk_window_get_title (GTK_WINDOW (object)), text);
else if (GTK_IS_TREE_VIEW_COLUMN (object))
return match_string (gtk_tree_view_column_get_title (GTK_TREE_VIEW_COLUMN (object)), text);
else
return FALSE;
}
static GObject *
search_children (GObject *object,
const char *text,
gboolean forward)
{
GListModel *children;
GObject *child, *result;
guint i, n;
children = object_get_children (object);
if (children == NULL)
return NULL;
n = g_list_model_get_n_items (children);
for (i = 0; i < n; i++)
{
child = g_list_model_get_item (children, forward ? i : n - i - 1);
if (match_object (child, text))
return child;
result = search_children (child, text, forward);
g_object_unref (child);
if (result)
return result;
}
return NULL;
}
static gboolean
search (GtkInspectorObjectTree *wt,
gboolean forward,
gboolean force_progress)
{
GtkInspectorObjectTreePrivate *priv = wt->priv;
GListModel *model = G_LIST_MODEL (priv->tree_model);
GtkTreeListRow *row_item;
GObject *child, *result;
guint i, selected, n, row;
const char *text;
text = gtk_editable_get_text (GTK_EDITABLE (priv->search_entry));
if (gtk_list_box_get_selected_row (priv->list))
{
selected = gtk_list_box_row_get_index (gtk_list_box_get_selected_row (priv->list));
}
else
{
selected = 0;
force_progress = FALSE;
}
n = g_list_model_get_n_items (model);
for (i = 0; i < n; i++)
{
row = (selected + (forward ? i : n - i - 1)) % n;
row_item = g_list_model_get_item (model, row);
child = gtk_tree_list_row_get_item (row_item);
if (i > 0 || !force_progress)
{
if (match_object (child, text))
{
gtk_list_box_select_row (priv->list, gtk_list_box_get_row_at_index (priv->list, row));
g_object_unref (child);
g_object_unref (row_item);
return TRUE;
}
}
if (!gtk_tree_list_row_get_expanded (row_item))
{
result = search_children (child, text, forward);
if (result)
{
gtk_inspector_object_tree_select_object (wt, result);
g_object_unref (result);
g_object_unref (child);
g_object_unref (row_item);
return TRUE;
}
}
g_object_unref (child);
g_object_unref (row_item);
}
return FALSE;
}
static void
on_search_changed (GtkSearchEntry *entry,
GtkInspectorObjectTree *wt)
{
if (!search (wt, TRUE, FALSE))
gtk_widget_error_bell (GTK_WIDGET (wt));
}
static void
next_match (GtkButton *button,
GtkInspectorObjectTree *wt)
{
if (gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar)))
{
if (!search (wt, TRUE, TRUE))
gtk_widget_error_bell (GTK_WIDGET (wt));
}
}
static void
previous_match (GtkButton *button,
GtkInspectorObjectTree *wt)
{
if (gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar)))
{
if (!search (wt, FALSE, TRUE))
gtk_widget_error_bell (GTK_WIDGET (wt));
}
}
static void
stop_search (GtkWidget *entry,
GtkInspectorObjectTree *wt)
{
gtk_editable_set_text (GTK_EDITABLE (wt->priv->search_entry), "");
gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (wt->priv->search_bar), FALSE);
}
static GtkWidget *
gtk_inspector_object_tree_create_list_widget (gpointer row_item,
gpointer user_data)
{
GtkInspectorObjectTree *wt = user_data;
gpointer item;
GtkWidget *row, *box, *column, *child;
guint depth;
item = gtk_tree_list_row_get_item (row_item);
row = gtk_list_box_row_new ();
g_object_set_data_full (G_OBJECT (row), "make-sure-its-not-unreffed", g_object_ref (row_item), g_object_unref);
if (GTK_IS_WIDGET (item))
{
g_signal_connect_object (item, "map", G_CALLBACK (widget_mapped), row, 0);
g_signal_connect_object (item, "unmap", G_CALLBACK (widget_unmapped), row, 0);
if (!gtk_widget_get_mapped (item))
widget_unmapped (item, GTK_LIST_BOX_ROW (row));
}
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
column = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_size_group_add_widget (wt->priv->type_size_group, column);
gtk_box_append (GTK_BOX (box), column);
/* expander */
depth = gtk_tree_list_row_get_depth (row_item);
if (depth > 0)
{
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_size_request (child, 16 * depth, 0);
gtk_box_append (GTK_BOX (column), child);
}
if (gtk_tree_list_row_is_expandable (row_item))
{
GtkWidget *title, *arrow;
child = g_object_new (GTK_TYPE_BOX, "css-name", "expander", NULL);
title = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "css-name", "title", NULL);
gtk_button_set_has_frame (GTK_BUTTON (title), FALSE);
g_object_bind_property (row_item, "expanded", title, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gtk_box_append (GTK_BOX (child), title);
arrow = gtk_builtin_icon_new ("expander");
gtk_button_set_child (GTK_BUTTON (title), arrow);
}
else
{
child = gtk_image_new (); /* empty whatever */
}
gtk_box_append (GTK_BOX (column), child);
/* 1st column: type name */
child = gtk_label_new (G_OBJECT_TYPE_NAME (item));
gtk_label_set_width_chars (GTK_LABEL (child), 30);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
gtk_box_append (GTK_BOX (column), child);
/* 2nd column: name */
child = gtk_label_new (gtk_inspector_get_object_name (item));
gtk_label_set_width_chars (GTK_LABEL (child), 15);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
gtk_size_group_add_widget (wt->priv->name_size_group, child);
gtk_box_append (GTK_BOX (box), child);
/* 3rd column: label */
child = gtk_label_new (NULL);
if (GTK_IS_LABEL (item))
g_object_bind_property (item, "label", child, "label", G_BINDING_SYNC_CREATE);
else if (GTK_IS_BUTTON (item))
g_object_bind_property (item, "label", child, "label", G_BINDING_SYNC_CREATE);
else if (GTK_IS_WINDOW (item))
g_object_bind_property (item, "title", child, "label", G_BINDING_SYNC_CREATE);
else if (GTK_IS_TREE_VIEW_COLUMN (item))
g_object_bind_property (item, "title", child, "label", G_BINDING_SYNC_CREATE);
gtk_label_set_width_chars (GTK_LABEL (child), 15);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
gtk_size_group_add_widget (wt->priv->label_size_group, child);
gtk_box_append (GTK_BOX (box), child);
g_object_unref (item);
return row;
}
static GListModel *
create_model_for_object (gpointer object,
gpointer user_data)
{
return object_get_children (object);
}
static gboolean
toplevel_filter_func (gpointer item,
gpointer data)
{
GdkDisplay *display = data;
if (!GTK_IS_WINDOW (item))
return FALSE;
if (g_str_equal (G_OBJECT_TYPE_NAME (item), "GtkInspectorWindow"))
return FALSE;
return gtk_widget_get_display (item) == display;
}
static GListModel *
create_root_model (GdkDisplay *display)
{
GtkFilterListModel *filter;
GtkFlattenListModel *flatten;
GListStore *list, *special;
gpointer item;
list = g_list_store_new (G_TYPE_LIST_MODEL);
special = g_list_store_new (G_TYPE_OBJECT);
item = g_application_get_default ();
if (item)
g_list_store_append (special, item);
g_list_store_append (special, gtk_settings_get_for_display (display));
g_list_store_append (list, special);
g_object_unref (special);
filter = gtk_filter_list_model_new_for_type (G_TYPE_OBJECT);
gtk_filter_list_model_set_filter_func (filter,
toplevel_filter_func,
display, NULL);
gtk_filter_list_model_set_model (filter, gtk_window_get_toplevels ());
g_list_store_append (list, filter);
g_object_unref (filter);
flatten = gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (list));
g_object_unref (list);
return G_LIST_MODEL (flatten);
}
static void
gtk_inspector_object_tree_init (GtkInspectorObjectTree *wt)
{
wt->priv = gtk_inspector_object_tree_get_instance_private (wt);
gtk_widget_init_template (GTK_WIDGET (wt));
gtk_search_bar_connect_entry (GTK_SEARCH_BAR (wt->priv->search_bar),
GTK_EDITABLE (wt->priv->search_entry));
}
static void
gtk_inspector_object_tree_dispose (GObject *object)
{
GtkInspectorObjectTree *wt = GTK_INSPECTOR_OBJECT_TREE (object);
g_clear_object (&wt->priv->tree_model);
G_OBJECT_CLASS (gtk_inspector_object_tree_parent_class)->dispose (object);
}
static void
gtk_inspector_object_tree_class_init (GtkInspectorObjectTreeClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->dispose = gtk_inspector_object_tree_dispose;
widget_class->map = map;
widget_class->unmap = unmap;
signals[OBJECT_ACTIVATED] =
g_signal_new ("object-activated",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkInspectorObjectTreeClass, object_activated),
NULL, NULL,
NULL,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
signals[OBJECT_SELECTED] =
g_signal_new ("object-selected",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkInspectorObjectTreeClass, object_selected),
NULL, NULL,
NULL,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/object-tree.ui");
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, list);
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, search_bar);
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, search_entry);
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, type_size_group);
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, name_size_group);
gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorObjectTree, label_size_group);
gtk_widget_class_bind_template_callback (widget_class, on_search_changed);
gtk_widget_class_bind_template_callback (widget_class, on_row_activated);
gtk_widget_class_bind_template_callback (widget_class, next_match);
gtk_widget_class_bind_template_callback (widget_class, previous_match);
gtk_widget_class_bind_template_callback (widget_class, stop_search);
}
static guint
model_get_item_index (GListModel *model,
gpointer item)
{
gpointer cmp;
guint i;
for (i = 0; (cmp = g_list_model_get_item (model, i)); i++)
{
if (cmp == item)
{
g_object_unref (cmp);
return i;
}
g_object_unref (cmp);
}
return G_MAXUINT;
}
static GtkTreeListRow *
find_and_expand_object (GtkTreeListModel *model,
GObject *object)
{
GtkTreeListRow *result;
GObject *parent;
guint pos;
parent = object_get_parent (object);
if (parent)
{
GtkTreeListRow *parent_row = find_and_expand_object (model, parent);
if (parent_row == NULL)
return NULL;
gtk_tree_list_row_set_expanded (parent_row, TRUE);
pos = model_get_item_index (gtk_tree_list_row_get_children (parent_row), object);
result = gtk_tree_list_row_get_child_row (parent_row, pos);
g_object_unref (parent_row);
}
else
{
pos = model_get_item_index (gtk_tree_list_model_get_model (model), object);
result = gtk_tree_list_model_get_child_row (model, pos);
}
return result;
}
void
gtk_inspector_object_tree_select_object (GtkInspectorObjectTree *wt,
GObject *object)
{
GtkTreeListRow *row_item;
GtkListBoxRow *row_widget;
row_item = find_and_expand_object (wt->priv->tree_model, object);
if (row_item == NULL)
return;
row_widget = gtk_list_box_get_row_at_index (wt->priv->list,
gtk_tree_list_row_get_position (row_item));
g_return_if_fail (row_widget != NULL);
gtk_list_box_select_row (wt->priv->list, row_widget);
g_signal_emit (wt, signals[OBJECT_SELECTED], 0, object); // FIXME
g_object_unref (row_item);
}
void
gtk_inspector_object_tree_set_display (GtkInspectorObjectTree *wt,
GdkDisplay *display)
{
GListModel *root_model;
root_model = create_root_model (display);
wt->priv->tree_model = gtk_tree_list_model_new (FALSE,
root_model,
FALSE,
create_model_for_object,
NULL,
NULL);
g_object_unref (root_model);
gtk_list_box_bind_model (wt->priv->list,
G_LIST_MODEL (wt->priv->tree_model),
gtk_inspector_object_tree_create_list_widget,
wt,
NULL);
}
Reference in New Issue View Git Blame Copy Permalink