* [PATCH 1/4] inspect: add custom ast treeview model
@ 2010-04-02 18:40 Christopher Li
0 siblings, 0 replies; only message in thread
From: Christopher Li @ 2010-04-02 18:40 UTC (permalink / raw)
To: Linux-Sparse; +Cc: Kamil Dudka, Josh Triplett
[-- Attachment #1: Type: text/plain, Size: 249 bytes --]
It is custom gtk treeview model to wrap the C data structure
use by sparse. The ast model does not have any sparse specific
stuff in it. Instead, it provide a simplier call back based
API to allow user construct tree view object very easily.
Chris
[-- Attachment #2: 0001-inspect-add-custom-ast-treeview-model.patch --]
[-- Type: application/octet-stream, Size: 20075 bytes --]
From 30dd73b56f7f018e059088b7937b1629d5782759 Mon Sep 17 00:00:00 2001
From: Christopher Li <sparse@chrisli.org>
Date: Tue, 30 Mar 2010 15:48:38 -0700
Subject: [PATCH 1/4] inspect: add custom ast treeview model
It is custom gtk treeview model to wrap the C data structure
use by sparse. The ast model does not have any sparse specific
stuff in it. Instead, it provide a simplier call back based
API to allow user construct tree view object very easily.
---
ast-model.c | 468 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ast-model.h | 88 +++++++++++
ast-view.c | 48 ++++++
ast-view.h | 7 +
4 files changed, 611 insertions(+), 0 deletions(-)
create mode 100644 ast-model.c
create mode 100644 ast-model.h
create mode 100644 ast-view.c
create mode 100644 ast-view.h
diff --git a/ast-model.c b/ast-model.c
new file mode 100644
index 0000000..f516340
--- /dev/null
+++ b/ast-model.c
@@ -0,0 +1,468 @@
+/*
+ * ast-model.c
+ *
+ * A custom tree model to simplify viewing of AST objects.
+ * Modify from the Gtk+ tree view tutorial, custom-list.c
+ * by Tim-Philipp Mueller < tim at centricular dot net >
+ *
+ * Copyright (C) 2010 Christopher Li
+ */
+
+
+#include "ast-model.h"
+#include "stdint.h"
+
+/* boring declarations of local functions */
+
+static void ast_init(AstNode *pkg_tree);
+static void ast_class_init(AstNodeClass *klass);
+static void ast_tree_model_init(GtkTreeModelIface *iface);
+static void ast_finalize(GObject *object);
+static GtkTreeModelFlags ast_get_flags(GtkTreeModel *tree_model);
+static gint ast_get_n_columns(GtkTreeModel *tree_model);
+static GType ast_get_column_type(GtkTreeModel *tree_model, gint index);
+static gboolean ast_get_iter(GtkTreeModel *tree_model, GtkTreeIter *iter,
+ GtkTreePath *path);
+static GtkTreePath *ast_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter);
+static void ast_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter,
+ gint column, GValue *value);
+static gboolean ast_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gboolean ast_iter_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+static gboolean ast_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gint ast_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gboolean ast_iter_nth_child(GtkTreeModel *tree_model, GtkTreeIter *iter,
+ GtkTreeIter *parent, gint n);
+static gboolean ast_iter_parent(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child);
+
+static GObjectClass *parent_class = NULL; /* GObject stuff - nothing to worry about */
+
+static inline
+void inspect_child_node(AstNode *node)
+{
+ if (node->inspect) {
+ node->inspect(node);
+ node->inspect = NULL;
+ }
+}
+
+
+static inline
+AstNode* ast_nth_child(AstNode *node, int n)
+{
+ if (!node)
+ return NULL;
+
+ inspect_child_node(node);
+
+ if (n >= node->childnodes->len)
+ return FALSE;
+ return g_array_index(node->childnodes, AstNode *, n);
+}
+
+
+static inline
+gboolean ast_set_iter(GtkTreeIter *iter, AstNode *node)
+{
+ iter->user_data = node;
+ iter->user_data2 = iter->user_data3 = NULL;
+ return node != NULL;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_type: here we register our new type and its interfaces
+ * with the type system. If you want to implement
+ * additional interfaces like GtkTreeSortable, you
+ * will need to do it here.
+ *
+ *****************************************************************************/
+
+GType
+ast_get_type (void)
+{
+ static GType ast_type = 0;
+ static const GTypeInfo ast_info = {
+ sizeof (AstNodeClass),
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) ast_class_init,
+ NULL, /* class finalize */
+ NULL, /* class_data */
+ sizeof (AstNode),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) ast_init
+ };
+ static const GInterfaceInfo tree_model_info = {
+ (GInterfaceInitFunc) ast_tree_model_init,
+ NULL,
+ NULL
+ };
+
+
+
+ if (ast_type)
+ return ast_type;
+
+ /* Some boilerplate type registration stuff */
+ ast_type = g_type_register_static(G_TYPE_OBJECT, "AstNode",
+ &ast_info, (GTypeFlags)0);
+
+ /* Here we register our GtkTreeModel interface with the type system */
+ g_type_add_interface_static(ast_type, GTK_TYPE_TREE_MODEL, &tree_model_info);
+
+ return ast_type;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_class_init: more boilerplate GObject/GType stuff.
+ * Init callback for the type system,
+ * called once when our new class is created.
+ *
+ *****************************************************************************/
+
+static void
+ast_class_init (AstNodeClass *klass)
+{
+ GObjectClass *object_class;
+
+ parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
+ object_class = (GObjectClass*) klass;
+
+ object_class->finalize = ast_finalize;
+}
+
+/*****************************************************************************
+ *
+ * ast_tree_model_init: init callback for the interface registration
+ * in ast_get_type. Here we override
+ * the GtkTreeModel interface functions that
+ * we implement.
+ *
+ *****************************************************************************/
+
+static void
+ast_tree_model_init (GtkTreeModelIface *iface)
+{
+ iface->get_flags = ast_get_flags;
+ iface->get_n_columns = ast_get_n_columns;
+ iface->get_column_type = ast_get_column_type;
+ iface->get_iter = ast_get_iter;
+ iface->get_path = ast_get_path;
+ iface->get_value = ast_get_value;
+ iface->iter_next = ast_iter_next;
+ iface->iter_children = ast_iter_children;
+ iface->iter_has_child = ast_iter_has_child;
+ iface->iter_n_children = ast_iter_n_children;
+ iface->iter_nth_child = ast_iter_nth_child;
+ iface->iter_parent = ast_iter_parent;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_init: this is called everytime a new ast node object
+ * instance is created (we do that in ast_new).
+ * Initialise the list structure's fields here.
+ *
+ *****************************************************************************/
+
+static void
+ast_init (AstNode *node)
+{
+ node->childnodes = g_array_new(FALSE, TRUE, sizeof(AstNode *));
+ node->stamp = g_random_int(); /* Random int to check whether iters belong to out model */
+}
+
+
+/*****************************************************************************
+ *
+ * ast_finalize: this is called just before an ast node is
+ * destroyed. Free dynamically allocated memory here.
+ *
+ *****************************************************************************/
+
+static void
+ast_finalize (GObject *object)
+{
+ /* AstNode *node = AST_NODE(object); */
+
+ /* FIXME: free all node memory */
+
+ /* must chain up - finalize parent */
+ (* parent_class->finalize) (object);
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_flags: tells the rest of the world whether our tree model
+ * has any special characteristics. In our case,
+ * we have a list model (instead of a tree), and each
+ * tree iter is valid as long as the row in question
+ * exists, as it only contains a pointer to our struct.
+ *
+ *****************************************************************************/
+
+static GtkTreeModelFlags
+ast_get_flags(GtkTreeModel *tree_model)
+{
+ return (GTK_TREE_MODEL_ITERS_PERSIST);
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_n_columns: tells the rest of the world how many data
+ * columns we export via the tree model interface
+ *
+ *****************************************************************************/
+
+static gint
+ast_get_n_columns(GtkTreeModel *tree_model)
+{
+ return 1;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_column_type: tells the rest of the world which type of
+ * data an exported model column contains
+ *
+ *****************************************************************************/
+
+static GType
+ast_get_column_type(GtkTreeModel *tree_model,
+ gint index)
+{
+ return G_TYPE_STRING;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_iter: converts a tree path (physical position) into a
+ * tree iter structure (the content of the iter
+ * fields will only be used internally by our model).
+ * We simply store a pointer to our AstNodeItem
+ * structure that represents that row in the tree iter.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_get_iter(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreePath *path)
+{
+ AstNode *node;
+ gint *indices, depth;
+ int i;
+
+ node = AST_NODE(tree_model);
+ indices = gtk_tree_path_get_indices(path);
+ depth = gtk_tree_path_get_depth(path);
+
+ for (i = 0; i < depth; i++)
+ node = ast_nth_child(node, indices[i]);
+
+ return ast_set_iter(iter, node);
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_path: converts a tree iter into a tree path (ie. the
+ * physical position of that row in the list).
+ *
+ *****************************************************************************/
+
+static GtkTreePath *
+ast_get_path(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
+{
+ GtkTreePath *path;
+ AstNode *root = AST_NODE(tree_model);
+ AstNode *node = AST_NODE(iter->user_data);
+
+ path = gtk_tree_path_new();
+ while (node != root) {
+ gtk_tree_path_prepend_index(path, node->index);
+ node = node->parent;
+ }
+ return path;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_get_value: Returns a row's exported data columns
+ * (_get_value is what gtk_tree_model_get uses)
+ *
+ *****************************************************************************/
+
+static void
+ast_get_value(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gint column,
+ GValue *value)
+{
+ AstNode *node = iter->user_data;
+
+ g_assert(AST_IS_NODE(tree_model));
+ if (column != 1)
+ return;
+
+ inspect_child_node(node);
+
+ g_value_init(value, G_TYPE_STRING);
+ g_value_set_string(value, node->text);
+ return;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_next: Takes an iter structure and sets it to point
+ * to the next row.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_next(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
+{
+ AstNode *node = iter->user_data;
+
+ g_assert(AST_IS_NODE (tree_model));
+
+ node = ast_nth_child(node->parent, node->index + 1);
+ return ast_set_iter(iter, node);
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_children: Returns TRUE or FALSE depending on whether
+ * the row specified by 'parent' has any children.
+ * If it has children, then 'iter' is set to
+ * point to the first child. Special case: if
+ * 'parent' is NULL, then the first top-level
+ * row should be returned if it exists.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
+{
+ return ast_iter_nth_child(tree_model, iter, parent, 0);
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_has_child: Returns TRUE or FALSE depending on whether
+ * the row specified by 'iter' has any children.
+ * We only have a list and thus no children.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
+{
+ AstNode *node = iter->user_data;
+ inspect_child_node(node);
+ return node->childnodes->len > 0;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_n_children: Returns the number of children the row
+ * specified by 'iter' has. This is usually 0,
+ * as we only have a list and thus do not have
+ * any children to any rows. A special case is
+ * when 'iter' is NULL, in which case we need
+ * to return the number of top-level node,
+ * ie. the number of rows in our list.
+ *
+ *****************************************************************************/
+
+static gint
+ast_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
+{
+ AstNode *node = iter->user_data;
+
+ inspect_child_node(node);
+ return node->childnodes->len;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_nth_child: If the row specified by 'parent' has any
+ * children, set 'iter' to the n-th child and
+ * return TRUE if it exists, otherwise FALSE.
+ * A special case is when 'parent' is NULL, in
+ * which case we need to set 'iter' to the n-th
+ * row if it exists.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_nth_child(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint n)
+{
+ AstNode *node = parent ? parent->user_data : (AstNode*) tree_model;
+ GArray *array = node->childnodes;
+ if (n >= array->len)
+ return FALSE;
+ iter->user_data = g_array_index(array, AstNode *, n);
+ return TRUE;
+}
+
+
+/*****************************************************************************
+ *
+ * ast_iter_parent: Point 'iter' to the parent node of 'child'. As
+ * we have a list and thus no children and no
+ * parents of children, we can just return FALSE.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child)
+{
+ AstNode *node = (AstNode *) child->user_data;
+ iter->user_data = node->parent;
+ return node->parent != NULL;
+}
+
+
+AstNode *
+ast_new (AstNode *parent, int index, const char *text, void *ptr, void (*inspect)(AstNode*))
+{
+ AstNode *node = (AstNode*) g_object_new (AST_TYPE_NODE, NULL);
+ g_assert(node != NULL);
+ node->parent = parent;
+ node->index = index;
+ node->text = text;
+ node->inspect = inspect;
+ node->ptr = ptr;
+ return node;
+}
+
diff --git a/ast-model.h b/ast-model.h
new file mode 100644
index 0000000..2eea056
--- /dev/null
+++ b/ast-model.h
@@ -0,0 +1,88 @@
+
+/*
+ * ast-model.h
+ *
+ * Copyright (C) 2010 Christopher Li.
+ *
+ */
+
+#ifndef _ast_model_h_
+#define _ast_model_h_
+
+#include <stdint.h>
+#include <gtk/gtk.h>
+#include "lib.h"
+
+#define AST_TYPE_NODE (ast_get_type ())
+#define AST_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), AST_TYPE_NODE, AstNode))
+#define AST_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), AST_TYPE_NODE, AstNodeClass))
+#define AST_IS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), AST_TYPE_NODE))
+#define AST_IS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), AST_TYPE_NODE))
+#define AST_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), AST_TYPE_NODE, AstNodeClass))
+
+enum
+{
+ AST_COL_RECORD = 0,
+ AST_COL_NAME,
+ AST_N_COLUMNS,
+} ;
+
+
+typedef struct AstNode AstNode;
+typedef struct AstNodeClass AstNodeClass;
+
+
+
+/* AstNode: this structure contains everything we need for our
+ * model implementation. You can add extra fields to
+ * this structure, e.g. hashtables to quickly lookup
+ * rows or whatever else you might need, but it is
+ * crucial that 'parent' is the first member of the
+ * structure. */
+
+struct AstNode
+{
+ GObject base; /* this MUST be the first member */
+
+ AstNode *parent;
+ int index;
+ const gchar *text;
+ void (*inspect)(struct AstNode* node);
+ void *ptr;
+ GArray *childnodes;
+ gint stamp;
+};
+
+
+
+/* AstNodeClass: more boilerplate GObject stuff */
+
+struct AstNodeClass
+{
+ GObjectClass base_class;
+};
+
+
+GType ast_get_type(void);
+AstNode* ast_new(AstNode *parent, int index, const char *prefix, void *ptr, void (*expand)(AstNode*));
+
+
+static inline
+void ast_append_child(AstNode *parent, const char *text,
+ void *ptr, void (*inspect)(AstNode*))
+{
+ if (ptr) {
+ AstNode *child = ast_new(parent, parent->childnodes->len,
+ text, ptr, inspect);
+ g_array_append_val(parent->childnodes, child);
+ }
+}
+
+static inline
+void ast_append_attribute(AstNode *parent, const char *text)
+{
+ AstNode *child = ast_new(parent, parent->childnodes->len, text, NULL, NULL);
+ g_array_append_val(parent->childnodes, child);
+}
+
+#endif /* _ast_h_*/
diff --git a/ast-view.c b/ast-view.c
new file mode 100644
index 0000000..40bf060
--- /dev/null
+++ b/ast-view.c
@@ -0,0 +1,48 @@
+
+#include <stdlib.h>
+#include "ast-model.h"
+#include "ast-inspect.h"
+
+GtkWidget *
+create_view_and_model (void *ptr)
+{
+ GtkTreeViewColumn *text;
+ GtkCellRenderer *renderer;
+ AstNode *root;
+ GtkWidget *view;
+
+ root = ast_new(NULL, 0, "", ptr, inspect_symbol_list);
+
+ view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(root));
+
+ g_object_unref(root); /* destroy store automatically with view */
+
+ renderer = gtk_cell_renderer_text_new();
+ text = gtk_tree_view_column_new_with_attributes("Node", renderer,
+ "text", AST_COL_NAME,
+ NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(view), text);
+
+ return view;
+}
+
+void
+treeview_main (struct symbol_list *syms)
+{
+ GtkWidget *window, *view, *scrollwin;
+
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_default_size (GTK_WINDOW(window), 400, 600);
+ g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
+
+ scrollwin = gtk_scrolled_window_new(NULL,NULL);
+
+ view = create_view_and_model(syms);
+
+ gtk_container_add(GTK_CONTAINER(scrollwin), view);
+ gtk_container_add(GTK_CONTAINER(window), scrollwin);
+
+ gtk_widget_show_all(window);
+
+ gtk_main();
+}
diff --git a/ast-view.h b/ast-view.h
new file mode 100644
index 0000000..da8f5f5
--- /dev/null
+++ b/ast-view.h
@@ -0,0 +1,7 @@
+
+#include <gtk/gtk.h>
+#include "lib.h"
+
+extern void treeview_main(struct symbol_list *syms);
+
+
--
1.6.6.1
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2010-04-02 18:46 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2010-04-02 18:40 [PATCH 1/4] inspect: add custom ast treeview model Christopher Li
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).