+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
+Wed Oct 25 20:40:25 2000 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtktreemodel.h: Got rid of GtkTreeNode, and changed it to
+ GtkTreeIter. Added iterators everywhere.
+
+ * gtk/gtktreeviewcolumn.c: Changed to use the iterators.
+
+ * gtk/gtktreeviewselection.c: Changed to use the iterators.
+
+ * gtk/gtktreestore.c: Changed to use the iterators.
+
+ * gtk/gtkliststore.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/gtkmodelsimple.c: Commented out the code. Will convert to
+ iterators tomorrow.
+
+ * gtk/treestoretest.c: Changed to use iterators.
+
+ * demos/testgtk/main.c: Moved to use the new iterator system.
+
Thu Oct 26 02:10:32 2000 Tim Janik <timj@gtk.org>
* gtk/Makefile.am: invoke maketypes.awk with LC_ALL=C to avoid
static GtkTextBuffer *info_buffer;
static GtkTextBuffer *source_buffer;
-static GtkWidget *demo_clist;
-static Demo *current_demo;
+static gchar *current_file = NULL;
+
+enum {
+ TITLE_COLUMN,
+ FILENAME_COLUMN,
+ FUNC_COLUMN,
+ ITALIC_COLUMN,
+ NUM_COLUMNS
+};
gboolean
read_line (FILE *stream, GString *str)
}
void
-load_file (Demo *demo)
+load_file (const gchar *filename)
{
FILE *file;
GtkTextIter start, end;
int state = 0;
gboolean in_para = 0;
- if (current_demo == demo)
+ if (current_file && !strcmp (current_file, filename))
return;
- current_demo = demo;
+ g_free (current_file);
+ current_file = g_strdup (filename);
gtk_text_buffer_get_bounds (info_buffer, &start, &end);
gtk_text_buffer_delete (info_buffer, &start, &end);
gtk_text_buffer_get_bounds (source_buffer, &start, &end);
gtk_text_buffer_delete (source_buffer, &start, &end);
- file = fopen (demo->filename, "r");
+ file = fopen (filename, "r");
if (!file)
{
- g_warning ("Cannot open %s: %s\n", demo->filename, g_strerror (errno));
+ g_warning ("Cannot open %s: %s\n", filename, g_strerror (errno));
return;
}
}
gboolean
-button_press_event_cb (GtkCList *clist,
- GdkEventButton *event)
+button_press_event_cb (GtkTreeView *tree_view,
+ GdkEventButton *event,
+ GtkTreeModel *model)
{
- if (event->type == GDK_2BUTTON_PRESS &&
- event->window == clist->clist_window)
+ if (event->type == GDK_2BUTTON_PRESS)
{
- gint row, column;
-
- if (gtk_clist_get_selection_info (clist,
- event->x, event->y,
- &row, &column))
+ GtkTreePath *path = NULL;
+
+ gtk_tree_view_get_path_at_pos (tree_view,
+ event->window,
+ event->x,
+ event->y,
+ &path,
+ NULL);
+ if (path)
{
- Demo *demo = gtk_clist_get_row_data (clist, row);
- demo->func();
+ GtkTreeIter iter;
+ gboolean italic;
+ GVoidFunc func;
+
+ gtk_tree_model_get_iter (model, &iter, path);
+ gtk_tree_store_iter_get (model, &iter,
+ FUNC_COLUMN, &func,
+ ITALIC_COLUMN, &italic,
+ -1);
+ (func) ();
+ gtk_tree_store_iter_set (model, &iter,
+ ITALIC_COLUMN, !italic,
+ -1);
+ gtk_tree_path_free (path);
}
- gtk_signal_emit_stop_by_name (GTK_OBJECT (clist), "button_press_event");
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (tree_view),
+ "button_press_event");
return TRUE;
}
return FALSE;
}
-void
-select_row_cb (GtkCList *clist,
- gint row,
- gint column,
- GdkEvent *event)
+static void
+selection_cb (GtkTreeSelection *selection,
+ GtkTreeModel *model)
{
- Demo *demo = gtk_clist_get_row_data (clist, row);
- load_file (demo);
+ GtkTreeIter iter;
+ GValue value = {0, };
+
+ if (! gtk_tree_selection_get_selected (selection, &iter))
+ return;
+
+ gtk_tree_model_iter_get_value (model, &iter,
+ FILENAME_COLUMN,
+ &value);
+ load_file (g_value_get_string (&value));
+ g_value_unset (&value);
}
-GtkWidget *
+static GtkWidget *
create_text (GtkTextBuffer **buffer,
gboolean is_source)
{
return scrolled_window;
}
+/* Technically a list, but if we do go to 80 demos, we may want to move to a tree */
+static GtkWidget *
+create_tree (void)
+{
+ GtkTreeSelection *selection;
+ GtkCellRenderer *cell;
+ GtkWidget *tree_view;
+ GtkObject *column;
+ GtkObject *model;
+ GtkTreeIter iter;
+ gint i;
+
+ model = gtk_tree_store_new_with_values (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
+ tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+
+ gtk_tree_selection_set_type (GTK_TREE_SELECTION (selection),
+ GTK_TREE_SELECTION_SINGLE);
+ gtk_widget_set_usize (tree_view, 200, -1);
+
+ for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model), &iter, NULL);
+
+ gtk_tree_store_iter_set (GTK_TREE_STORE (model),
+ &iter,
+ TITLE_COLUMN, testgtk_demos[i].title,
+ FILENAME_COLUMN, testgtk_demos[i].filename,
+ FUNC_COLUMN, testgtk_demos[i].func,
+ ITALIC_COLUMN, FALSE,
+ -1);
+ }
+
+ cell = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("Widget",
+ cell,
+ "text", TITLE_COLUMN,
+ "italic", ITALIC_COLUMN,
+ NULL);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
+ GTK_TREE_VIEW_COLUMN (column));
+
+ gtk_signal_connect (GTK_OBJECT (selection), "selection_changed", selection_cb, model);
+ gtk_signal_connect (GTK_OBJECT (tree_view), "button_press_event", GTK_SIGNAL_FUNC (button_press_event_cb), model);
+
+ return tree_view;
+}
+
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *notebook;
GtkWidget *hbox;
+ GtkWidget *tree;
GtkTextTag *tag;
- int i;
gtk_init (&argc, &argv);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), hbox);
- demo_clist = gtk_clist_new (1);
- gtk_clist_set_selection_mode (GTK_CLIST (demo_clist), GTK_SELECTION_BROWSE);
-
- gtk_widget_set_usize (demo_clist, 200, -1);
- gtk_box_pack_start (GTK_BOX (hbox), demo_clist, FALSE, FALSE, 0);
+ tree = create_tree ();
+ gtk_box_pack_start (GTK_BOX (hbox), tree, FALSE, FALSE, 0);
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
gtk_widget_show_all (window);
- for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
- {
- gint row = gtk_clist_append (GTK_CLIST (demo_clist), &testgtk_demos[i].title);
- gtk_clist_set_row_data (GTK_CLIST (demo_clist), row, &testgtk_demos[i]);
- }
- load_file (&testgtk_demos[0]);
-
- gtk_signal_connect (GTK_OBJECT (demo_clist), "button_press_event",
- GTK_SIGNAL_FUNC (button_press_event_cb), NULL);
-
- gtk_signal_connect (GTK_OBJECT (demo_clist), "select_row",
- GTK_SIGNAL_FUNC (select_row_cb), NULL);
+ load_file (testgtk_demos[0].filename);
gtk_main ();
static GtkTextBuffer *info_buffer;
static GtkTextBuffer *source_buffer;
-static GtkWidget *demo_clist;
-static Demo *current_demo;
+static gchar *current_file = NULL;
+
+enum {
+ TITLE_COLUMN,
+ FILENAME_COLUMN,
+ FUNC_COLUMN,
+ ITALIC_COLUMN,
+ NUM_COLUMNS
+};
gboolean
read_line (FILE *stream, GString *str)
}
void
-load_file (Demo *demo)
+load_file (const gchar *filename)
{
FILE *file;
GtkTextIter start, end;
int state = 0;
gboolean in_para = 0;
- if (current_demo == demo)
+ if (current_file && !strcmp (current_file, filename))
return;
- current_demo = demo;
+ g_free (current_file);
+ current_file = g_strdup (filename);
gtk_text_buffer_get_bounds (info_buffer, &start, &end);
gtk_text_buffer_delete (info_buffer, &start, &end);
gtk_text_buffer_get_bounds (source_buffer, &start, &end);
gtk_text_buffer_delete (source_buffer, &start, &end);
- file = fopen (demo->filename, "r");
+ file = fopen (filename, "r");
if (!file)
{
- g_warning ("Cannot open %s: %s\n", demo->filename, g_strerror (errno));
+ g_warning ("Cannot open %s: %s\n", filename, g_strerror (errno));
return;
}
}
gboolean
-button_press_event_cb (GtkCList *clist,
- GdkEventButton *event)
+button_press_event_cb (GtkTreeView *tree_view,
+ GdkEventButton *event,
+ GtkTreeModel *model)
{
- if (event->type == GDK_2BUTTON_PRESS &&
- event->window == clist->clist_window)
+ if (event->type == GDK_2BUTTON_PRESS)
{
- gint row, column;
-
- if (gtk_clist_get_selection_info (clist,
- event->x, event->y,
- &row, &column))
+ GtkTreePath *path = NULL;
+
+ gtk_tree_view_get_path_at_pos (tree_view,
+ event->window,
+ event->x,
+ event->y,
+ &path,
+ NULL);
+ if (path)
{
- Demo *demo = gtk_clist_get_row_data (clist, row);
- demo->func();
+ GtkTreeIter iter;
+ gboolean italic;
+ GVoidFunc func;
+
+ gtk_tree_model_get_iter (model, &iter, path);
+ gtk_tree_store_iter_get (model, &iter,
+ FUNC_COLUMN, &func,
+ ITALIC_COLUMN, &italic,
+ -1);
+ (func) ();
+ gtk_tree_store_iter_set (model, &iter,
+ ITALIC_COLUMN, !italic,
+ -1);
+ gtk_tree_path_free (path);
}
- gtk_signal_emit_stop_by_name (GTK_OBJECT (clist), "button_press_event");
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (tree_view),
+ "button_press_event");
return TRUE;
}
return FALSE;
}
-void
-select_row_cb (GtkCList *clist,
- gint row,
- gint column,
- GdkEvent *event)
+static void
+selection_cb (GtkTreeSelection *selection,
+ GtkTreeModel *model)
{
- Demo *demo = gtk_clist_get_row_data (clist, row);
- load_file (demo);
+ GtkTreeIter iter;
+ GValue value = {0, };
+
+ if (! gtk_tree_selection_get_selected (selection, &iter))
+ return;
+
+ gtk_tree_model_iter_get_value (model, &iter,
+ FILENAME_COLUMN,
+ &value);
+ load_file (g_value_get_string (&value));
+ g_value_unset (&value);
}
-GtkWidget *
+static GtkWidget *
create_text (GtkTextBuffer **buffer,
gboolean is_source)
{
return scrolled_window;
}
+/* Technically a list, but if we do go to 80 demos, we may want to move to a tree */
+static GtkWidget *
+create_tree (void)
+{
+ GtkTreeSelection *selection;
+ GtkCellRenderer *cell;
+ GtkWidget *tree_view;
+ GtkObject *column;
+ GtkObject *model;
+ GtkTreeIter iter;
+ gint i;
+
+ model = gtk_tree_store_new_with_values (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
+ tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+
+ gtk_tree_selection_set_type (GTK_TREE_SELECTION (selection),
+ GTK_TREE_SELECTION_SINGLE);
+ gtk_widget_set_usize (tree_view, 200, -1);
+
+ for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model), &iter, NULL);
+
+ gtk_tree_store_iter_set (GTK_TREE_STORE (model),
+ &iter,
+ TITLE_COLUMN, testgtk_demos[i].title,
+ FILENAME_COLUMN, testgtk_demos[i].filename,
+ FUNC_COLUMN, testgtk_demos[i].func,
+ ITALIC_COLUMN, FALSE,
+ -1);
+ }
+
+ cell = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("Widget",
+ cell,
+ "text", TITLE_COLUMN,
+ "italic", ITALIC_COLUMN,
+ NULL);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
+ GTK_TREE_VIEW_COLUMN (column));
+
+ gtk_signal_connect (GTK_OBJECT (selection), "selection_changed", selection_cb, model);
+ gtk_signal_connect (GTK_OBJECT (tree_view), "button_press_event", GTK_SIGNAL_FUNC (button_press_event_cb), model);
+
+ return tree_view;
+}
+
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *notebook;
GtkWidget *hbox;
+ GtkWidget *tree;
GtkTextTag *tag;
- int i;
gtk_init (&argc, &argv);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), hbox);
- demo_clist = gtk_clist_new (1);
- gtk_clist_set_selection_mode (GTK_CLIST (demo_clist), GTK_SELECTION_BROWSE);
-
- gtk_widget_set_usize (demo_clist, 200, -1);
- gtk_box_pack_start (GTK_BOX (hbox), demo_clist, FALSE, FALSE, 0);
+ tree = create_tree ();
+ gtk_box_pack_start (GTK_BOX (hbox), tree, FALSE, FALSE, 0);
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
gtk_widget_show_all (window);
- for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
- {
- gint row = gtk_clist_append (GTK_CLIST (demo_clist), &testgtk_demos[i].title);
- gtk_clist_set_row_data (GTK_CLIST (demo_clist), row, &testgtk_demos[i]);
- }
- load_file (&testgtk_demos[0]);
-
- gtk_signal_connect (GTK_OBJECT (demo_clist), "button_press_event",
- GTK_SIGNAL_FUNC (button_press_event_cb), NULL);
-
- gtk_signal_connect (GTK_OBJECT (demo_clist), "select_row",
- GTK_SIGNAL_FUNC (select_row_cb), NULL);
+ load_file (testgtk_demos[0].filename);
gtk_main ();
#include "gtksignal.h"
#define G_SLIST(x) ((GSList *) x)
-
+#if 0
enum {
- NODE_CHANGED,
- NODE_INSERTED,
- NODE_CHILD_TOGGLED,
- NODE_DELETED,
+ CHANGED,
+ INSERTED,
+ CHILD_TOGGLED,
+ DELETED,
LAST_SIGNAL
};
static void gtk_list_store_class_init (GtkListStoreClass *class);
static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface);
static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model);
-static GtkTreeNode gtk_list_store_get_node (GtkTreeModel *tree_model,
+static GtkTreeIter *gtk_list_store_get_iter (GtkTreeModel *tree_model,
GtkTreePath *path);
static GtkTreePath *gtk_list_store_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static void gtk_list_store_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
+ GtkTreeIter *iter);
+static void gtk_list_store_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
gint column,
GValue *value);
-static gboolean gtk_list_store_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node);
-static GtkTreeNode gtk_list_store_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static gboolean gtk_list_store_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static gint gtk_list_store_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static GtkTreeNode gtk_list_store_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
+static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static GtkTreeIter *gtk_list_store_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static GtkTreeIter *gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
gint n);
-static GtkTreeNode gtk_list_store_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node);
+static GtkTreeIter *gtk_list_store_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
GtkType
object_class = (GtkObjectClass*) class;
- list_store_signals[NODE_CHANGED] =
- gtk_signal_new ("node_changed",
+ list_store_signals[CHANGED] =
+ gtk_signal_new ("changed",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkListStoreClass, node_changed),
+ GTK_SIGNAL_OFFSET (GtkListStoreClass, changed),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- list_store_signals[NODE_INSERTED] =
- gtk_signal_new ("node_inserted",
+ list_store_signals[INSERTED] =
+ gtk_signal_new ("inserted",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkListStoreClass, node_inserted),
+ GTK_SIGNAL_OFFSET (GtkListStoreClass, inserted),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- list_store_signals[NODE_CHILD_TOGGLED] =
- gtk_signal_new ("node_child_toggled",
+ list_store_signals[CHILD_TOGGLED] =
+ gtk_signal_new ("child_toggled",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkListStoreClass, node_child_toggled),
+ GTK_SIGNAL_OFFSET (GtkListStoreClass, child_toggled),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- list_store_signals[NODE_DELETED] =
- gtk_signal_new ("node_deleted",
+ list_store_signals[DELETED] =
+ gtk_signal_new ("deleted",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkListStoreClass, node_deleted),
+ GTK_SIGNAL_OFFSET (GtkListStoreClass, deleted),
gtk_marshal_VOID__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
gtk_list_store_tree_model_init (GtkTreeModelIface *iface)
{
iface->get_n_columns = gtk_list_store_get_n_columns;
- iface->get_node = gtk_list_store_get_node;
+ iface->get_iter = gtk_list_store_get_iter;
iface->get_path = gtk_list_store_get_path;
- iface->node_get_value = gtk_list_store_node_get_value;
- iface->node_next = gtk_list_store_node_next;
- iface->node_children = gtk_list_store_node_children;
- iface->node_has_child = gtk_list_store_node_has_child;
- iface->node_n_children = gtk_list_store_node_n_children;
- iface->node_nth_child = gtk_list_store_node_nth_child;
- iface->node_parent = gtk_list_store_node_parent;
+ iface->iter_get_value = gtk_list_store_iter_get_value;
+ iface->iter_next = gtk_list_store_iter_next;
+ iface->iter_children = gtk_list_store_iter_children;
+ iface->iter_has_child = gtk_list_store_iter_has_child;
+ iface->iter_n_children = gtk_list_store_iter_n_children;
+ iface->iter_nth_child = gtk_list_store_iter_nth_child;
+ iface->iter_parent = gtk_list_store_iter_parent;
}
static void
return GTK_LIST_STORE (tree_model)->n_columns;
}
-static GtkTreeNode
-gtk_list_store_get_node (GtkTreeModel *tree_model,
+static GtkTreeIter *
+gtk_list_store_get_iter (GtkTreeModel *tree_model,
GtkTreePath *path)
{
g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, NULL);
- return (GtkTreeNode) g_slist_nth (G_SLIST (GTK_LIST_STORE (tree_model)->root),
+ return (GtkTreeIter) g_slist_nth (G_SLIST (GTK_LIST_STORE (tree_model)->root),
gtk_tree_path_get_indices (path)[0]);
}
static GtkTreePath *
gtk_list_store_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node)
+ GtkTreeIter iter)
{
GtkTreePath *retval;
GSList *list;
for (list = G_SLIST (GTK_LIST_STORE (tree_model)->root); list; list = list->next)
{
i++;
- if (list == G_SLIST (node))
+ if (list == G_SLIST (iter))
break;
}
if (list == NULL)
}
static void
-gtk_list_store_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
+gtk_list_store_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter iter,
gint column,
GValue *value)
{
g_return_if_fail (tree_model != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (tree_model));
- g_return_if_fail (node != NULL);
+ g_return_if_fail (iter != NULL);
g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns);
- list = G_SLIST (node)->data;
+ list = G_SLIST (iter)->data;
while (tmp_column-- > 0 && list)
list = list->next;
g_return_if_fail (list != NULL);
- gtk_tree_data_list_node_to_value (list,
+ gtk_tree_data_list_iter_to_value (list,
GTK_LIST_STORE (tree_model)->column_headers[column],
value);
}
static gboolean
-gtk_list_store_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node)
+gtk_list_store_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- if (node == NULL || *node == NULL)
+ if (iter == NULL || *iter == NULL)
return FALSE;
- *node = (GtkTreeNode) G_SLIST (*node)->next;
+ *iter = (GtkTreeIter) G_SLIST (*iter)->next;
- return (*node != NULL);
+ return (*iter != NULL);
}
-static GtkTreeNode
-gtk_list_store_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+static GtkTreeIter
+gtk_list_store_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter iter)
{
return NULL;
}
static gboolean
-gtk_list_store_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_list_store_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter iter)
{
return FALSE;
}
static gint
-gtk_list_store_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter iter)
{
return 0;
}
-static GtkTreeNode
-gtk_list_store_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
+static GtkTreeIter
+gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter iter,
gint n)
{
return NULL;
}
-static GtkTreeNode
-gtk_list_store_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node)
+static GtkTreeIter
+gtk_list_store_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter iter)
{
return NULL;
}
/* Public accessors */
-GtkTreeNode
-gtk_list_store_node_new (void)
+GtkTreeIter
+gtk_list_store_iter_new (void)
{
- GtkTreeNode retval = (GtkTreeNode) g_slist_alloc ();
+ GtkTreeIter retval = (GtkTreeIter) g_slist_alloc ();
return retval;
}
* manipulations on it's own.
*/
void
-gtk_list_store_node_set_cell (GtkListStore *list_store,
- GtkTreeNode node,
+gtk_list_store_iter_set_cell (GtkListStore *list_store,
+ GtkTreeIter iter,
gint column,
GValue *value)
{
g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
- g_return_if_fail (node != NULL);
+ g_return_if_fail (iter != NULL);
g_return_if_fail (column >= 0 && column < list_store->n_columns);
- prev = list = G_SLIST (node)->data;
+ prev = list = G_SLIST (iter)->data;
while (list != NULL)
{
if (column == 0)
{
- gtk_tree_data_list_value_to_node (list, value);
+ gtk_tree_data_list_value_to_iter (list, value);
return;
}
list = list->next;
}
- if (G_SLIST (node)->data == NULL)
+ if (G_SLIST (iter)->data == NULL)
{
- G_SLIST (node)->data = list = gtk_tree_data_list_alloc ();
+ G_SLIST (iter)->data = list = gtk_tree_data_list_alloc ();
list->next = NULL;
}
else
list->next = NULL;
column --;
}
- gtk_tree_data_list_value_to_node (list, value);
+ gtk_tree_data_list_value_to_iter (list, value);
}
void
-gtk_list_store_node_remove (GtkListStore *list_store,
- GtkTreeNode node)
+gtk_list_store_iter_remove (GtkListStore *list_store,
+ GtkTreeIter iter)
{
/* FIXME: implement */
g_warning ("Remember to implement this function\n");
}
-GtkTreeNode
-gtk_list_store_node_insert (GtkListStore *list_store,
+GtkTreeIter
+gtk_list_store_iter_insert (GtkListStore *list_store,
gint position,
- GtkTreeNode node)
+ GtkTreeIter iter)
{
GSList *list;
- g_return_val_if_fail (list_store != NULL, node);
- g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), node);
- g_return_val_if_fail (node != NULL, node);
- g_return_val_if_fail (position < 0, node);
- g_return_val_if_fail (G_SLIST (node)->next == NULL, node);
+ g_return_val_if_fail (list_store != NULL, iter);
+ g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), iter);
+ g_return_val_if_fail (iter != NULL, iter);
+ g_return_val_if_fail (position < 0, iter);
+ g_return_val_if_fail (G_SLIST (iter)->next == NULL, iter);
if (position == 0)
{
- gtk_list_store_node_prepend (list_store, node);
- return node;
+ gtk_list_store_iter_prepend (list_store, iter);
+ return iter;
}
list = g_slist_nth (G_SLIST (list_store->root), position);
if (list)
{
- G_SLIST (node)->next = list->next;
- list->next = G_SLIST (node)->next;
+ G_SLIST (iter)->next = list->next;
+ list->next = G_SLIST (iter)->next;
}
- return node;
+ return iter;
}
-GtkTreeNode
-gtk_list_store_node_insert_before (GtkListStore *list_store,
- GtkTreeNode sibling,
- GtkTreeNode node)
+GtkTreeIter
+gtk_list_store_iter_insert_before (GtkListStore *list_store,
+ GtkTreeIter sibling,
+ GtkTreeIter iter)
{
- g_return_val_if_fail (list_store != NULL, node);
- g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), node);
- g_return_val_if_fail (node != NULL, node);
+ g_return_val_if_fail (list_store != NULL, iter);
+ g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), iter);
+ g_return_val_if_fail (iter != NULL, iter);
/* FIXME: This is all wrong. This is actually insert_after */
if (sibling == NULL)
- return gtk_list_store_node_prepend (list_store, node);
+ return gtk_list_store_iter_prepend (list_store, iter);
- G_SLIST (node)->next = G_SLIST (sibling)->next;
- G_SLIST (sibling)->next = G_SLIST (node);
- return node;
+ G_SLIST (iter)->next = G_SLIST (sibling)->next;
+ G_SLIST (sibling)->next = G_SLIST (iter);
+ return iter;
}
-GtkTreeNode
-gtk_list_store_node_prepend (GtkListStore *list_store,
- GtkTreeNode node)
+GtkTreeIter
+gtk_list_store_iter_prepend (GtkListStore *list_store,
+ GtkTreeIter iter)
{
- g_return_val_if_fail (list_store != NULL, node);
- g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), node);
- g_return_val_if_fail (node != NULL, node);
+ g_return_val_if_fail (list_store != NULL, iter);
+ g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), iter);
+ g_return_val_if_fail (iter != NULL, iter);
- G_SLIST (node)->next = G_SLIST (list_store->root);
- list_store->root = node;
+ G_SLIST (iter)->next = G_SLIST (list_store->root);
+ list_store->root = iter;
- return node;
+ return iter;
}
-GtkTreeNode
-gtk_list_store_node_append (GtkListStore *list_store,
- GtkTreeNode node)
+GtkTreeIter
+gtk_list_store_iter_append (GtkListStore *list_store,
+ GtkTreeIter iter)
{
GSList *list;
- g_return_val_if_fail (list_store != NULL, node);
- g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), node);
- g_return_val_if_fail (node != NULL, node);
- g_return_val_if_fail (G_SLIST (node)->next == NULL, node);
+ g_return_val_if_fail (list_store != NULL, iter);
+ g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), iter);
+ g_return_val_if_fail (iter != NULL, iter);
+ g_return_val_if_fail (G_SLIST (iter)->next == NULL, iter);
list = g_slist_last (G_SLIST (list_store->root));
if (list == NULL)
- list_store->root = node;
+ list_store->root = iter;
else
- list->next = G_SLIST (node);
+ list->next = G_SLIST (iter);
- return node;
+ return iter;
}
-GtkTreeNode
-gtk_list_store_node_get_root (GtkListStore *list_store)
+GtkTreeIter
+gtk_list_store_iter_get_root (GtkListStore *list_store)
{
g_return_val_if_fail (list_store != NULL, NULL);
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), NULL);
- return (GtkTreeNode *) list_store->root;
+ return (GtkTreeIter *) list_store->root;
}
+#endif
GtkObject parent;
/*< private >*/
- GtkTreeNode root;
+ gint stamp;
+ gpointer root;
gint n_columns;
GType *column_headers;
};
/* signals */
/* Will be moved into the GtkTreeModelIface eventually */
- void (* node_changed) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_inserted) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_child_toggled) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_deleted) (GtkTreeModel *tree_model,
- GtkTreePath *path);
+ void (* changed) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* inserted) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* child_toggled) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* deleted) (GtkTreeModel *tree_model,
+ GtkTreePath *path);
};
GtkType gtk_list_store_get_type (void);
void gtk_list_store_set_column_type (GtkListStore *store,
gint column,
GType type);
-GtkTreeNode gtk_list_store_node_new (void);
+GtkTreeIter *gtk_list_store_node_new (void);
void gtk_list_store_node_set_cell (GtkListStore *store,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint column,
GValue *value);
void gtk_list_store_node_remove (GtkListStore *store,
- GtkTreeNode node);
-GtkTreeNode gtk_list_store_node_insert (GtkListStore *store,
+ GtkTreeIter *iter);
+GtkTreeIter *gtk_list_store_node_insert (GtkListStore *store,
gint position,
- GtkTreeNode node);
-GtkTreeNode gtk_list_store_node_insert_before (GtkListStore *store,
- GtkTreeNode sibling,
- GtkTreeNode node);
-GtkTreeNode gtk_list_store_node_prepend (GtkListStore *store,
- GtkTreeNode node);
-GtkTreeNode gtk_list_store_node_append (GtkListStore *store,
- GtkTreeNode node);
+ GtkTreeIter *iter);
+GtkTreeIter *gtk_list_store_node_insert_before (GtkListStore *store,
+ GtkTreeIter sibling,
+ GtkTreeIter *iter);
+GtkTreeIter *gtk_list_store_node_prepend (GtkListStore *store,
+ GtkTreeIter *iter);
+GtkTreeIter *gtk_list_store_node_append (GtkListStore *store,
+ GtkTreeIter *iter);
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
-
+#if 0
#include "gtkmodelsimple.h"
#include "gtksignal.h"
enum {
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_deleted", path, node);
}
+#endif
extern "C" {
#endif /* __cplusplus */
+#if 0
+
#define GTK_TYPE_MODEL_SIMPLE (gtk_model_simple_get_type ())
#define GTK_MODEL_SIMPLE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_MODEL_SIMPLE, GtkModelSimple))
#define GTK_MODEL_SIMPLE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_MODEL_SIMPLE, GtkModelSimpleClass))
#define GTK_IS_MODEL_SIMPLE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_MODEL_SIMPLE))
#define GTK_IS_MODEL_SIMPLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_MODEL_SIMPLE))
-
typedef struct _GtkModelSimple GtkModelSimple;
typedef struct _GtkModelSimpleClass GtkModelSimpleClass;
/* signals */
/* Will be moved into the GtkTreeModelIface eventually */
- void (* node_changed) (GtkTreeModel *tree_model,
+ void (* changed) (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeNode node);
- void (* node_inserted) (GtkTreeModel *tree_model,
+ void (* inserted) (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeNode node);
- void (* node_child_toggled) (GtkTreeModel *tree_model,
+ void (* child_toggled) (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeNode node);
- void (* node_deleted) (GtkTreeModel *tree_model,
+ void (* deleted) (GtkTreeModel *tree_model,
GtkTreePath *path);
};
GtkTreeNode node);
-
+#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
{
GtkRBNode *tmp_node;
+ if (height < 0)
+ {
+ *new_tree = NULL;
+ *new_node = NULL;
+ return 0;
+ }
+
tmp_node = tree->root;
while (tmp_node != tree->nil &&
(tmp_node->left->offset > height ||
case G_TYPE_UINT:
g_value_set_uint (value, list->data.v_uint);
break;
+ case G_TYPE_POINTER:
+ g_value_set_pointer (value, (gpointer) list->data.v_pointer);
+ break;
case G_TYPE_FLOAT:
g_value_set_float (value, list->data.v_float);
break;
case G_TYPE_OBJECT:
g_value_set_object (value, (GObject *) list->data.v_pointer);
break;
+ default:
+ g_warning ("Unsupported type (%s) retrieved.", g_type_name (value->g_type));
+ return;
}
}
case G_TYPE_UINT:
list->data.v_uint = g_value_get_uint (value);
break;
+ case G_TYPE_POINTER:
+ list->data.v_pointer = g_value_get_pointer (value);
+ break;
case G_TYPE_FLOAT:
list->data.v_float = g_value_get_float (value);
break;
gtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
{
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_n_columns != NULL, 0);
+
return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_n_columns) (tree_model);
}
/**
- * gtk_tree_model_get_node:
+ * gtk_tree_model_get_iter:
* @tree_model: A #GtkTreeModel.
- * @path: The @GtkTreePath.
+ * @iter: The uninitialized #GtkTreeIter.
+ * @path: The #GtkTreePath.
*
- * Returns a #GtkTreeNode located at @path. If such a node does not exist, NULL
- * is returned.
+ * Sets @iter to a valid iterator pointing to @path. If the model does not
+ * provide an implementation of this function, it is implemented in terms of
+ * @gtk_tree_model_iter_nth_child.
*
- * Return value: A #GtkTreeNode located at @path, or NULL.
+ * Return value: TRUE, if @iter was set.
**/
-GtkTreeNode
-gtk_tree_model_get_node (GtkTreeModel *tree_model,
+gboolean
+gtk_tree_model_get_iter (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
GtkTreePath *path)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_node != NULL, NULL);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_node) (tree_model, path);
+ GtkTreeIter parent;
+ gint *indices;
+ gint depth, i;
+
+ if (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_iter != NULL)
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_iter) (tree_model, iter, path);
+
+ g_return_val_if_fail (path != NULL, FALSE);
+ indices = gtk_tree_path_get_indices (path);
+ depth = gtk_tree_path_get_depth (path);
+
+ g_return_val_if_fail (depth > 0, FALSE);
+
+ if (! gtk_tree_model_iter_nth_child (tree_model, iter, NULL, indices[0]))
+ return FALSE;
+
+ for (i = 1; i < depth; i++)
+ {
+ parent = *iter;
+ if (! gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i]))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/**
+ * gtk_tree_model_iter_invalid:
+ * @tree_model: A #GtkTreeModel.
+ * @iter: The #GtkTreeIter.
+ *
+ * Tests the validity of @iter, and returns TRUE if it is invalid.
+ *
+ * Return value: TRUE, if @iter is invalid.
+ **/
+gboolean
+gtk_tree_model_iter_invalid (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
+{
+ g_return_val_if_fail (tree_model != NULL, FALSE);
+ if (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_invalid)
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_invalid) (tree_model, iter);
+
+ /* Default implementation. Returns false if iter is false, or the stamp is 0 */
+ if (iter == NULL || iter->stamp == 0)
+ return TRUE;
+
+ return FALSE;
}
/**
* gtk_tree_model_get_path:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode.
+ * @iter: The #GtkTreeIter.
*
- * Returns a newly created #GtkTreePath that points to @node. This path should
+ * Returns a newly created #GtkTreePath referenced by @iter. This path should
* be freed with #gtk_tree_path_free.
*
* Return value: a newly created #GtkTreePath.
**/
GtkTreePath *
gtk_tree_model_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node)
+ GtkTreeIter *iter)
{
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_path != NULL, NULL);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_path) (tree_model, node);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_path) (tree_model, iter);
}
/**
- * gtk_tree_model_node_get_value:
+ * gtk_tree_model_iter_get_value:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode.
- * @column: A column on the node.
+ * @iter: The #GtkTreeIter.
+ * @column: The column to lookup the value at.
* @value: An empty #GValue to set.
*
* Sets initializes and sets @value to that at @column. When done with value,
* #g_value_unset needs to be called on it.
**/
void
-gtk_tree_model_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
+gtk_tree_model_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
gint column,
GValue *value)
{
- g_return_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_get_value != NULL);
- (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_get_value) (tree_model, node, column, value);
+ g_return_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_get_value != NULL);
+
+ (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_get_value) (tree_model, iter, column, value);
}
/**
- * gtk_tree_model_node_next:
+ * gtk_tree_model_iter_next:
* @tree_model: A #GtkTreeModel.
- * @node: A reference to a #GtkTreeNode.
+ * @iter: The #GtkTreeIter.
*
- * Sets @node to be the node following it at the current level. If there is no
- * next @node, FALSE is returned, and *@node is set to NULL.
+ * Sets @iter to point to the node following it at the current level. If there
+ * is no next @iter, FALSE is returned and @iter is set to be invalid.
*
- * Return value: TRUE if @node has been changed to the next node.
+ * Return value: TRUE if @iter has been changed to the next node.
**/
gboolean
-gtk_tree_model_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node)
+gtk_tree_model_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_next != NULL, FALSE);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_next) (tree_model, node);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_next != NULL, FALSE);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_next) (tree_model, iter);
}
/**
- * gtk_tree_model_node_children:
+ * gtk_tree_model_iter_children:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode to get children from.
+ * @iter: The #GtkTreeIter.
+ * @child: The new #GtkTreeIter.
*
- * Returns the first child node of @node. If it has no children, then NULL is
- * returned.
+ * Sets @iter to point to the first child of @parent. If @parent has no children,
+ * FALSE is returned and @iter is set to be invalid. @parent will remain a valid
+ * node after this function has been called.
*
- * Return value: The first child of @node, or NULL.
+ * Return value: TRUE, if @child has been set to the first child.
**/
-GtkTreeNode
-gtk_tree_model_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gboolean
+gtk_tree_model_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_children != NULL, NULL);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_children) (tree_model, node);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_children != NULL, FALSE);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_children) (tree_model, iter, parent);
}
/**
- * gtk_tree_model_node_has_child:
+ * gtk_tree_model_iter_has_child:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode to test for children.
+ * @iter: The #GtkTreeIter to test for children.
*
- * Returns TRUE if @node has children, FALSE otherwise.
+ * Returns TRUE if @iter has children, FALSE otherwise.
*
- * Return value: TRUE if @node has children.
+ * Return value: TRUE if @iter has children.
**/
gboolean
-gtk_tree_model_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_has_child != NULL, FALSE);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_has_child) (tree_model, node);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_has_child != NULL, FALSE);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_has_child) (tree_model, iter);
}
/**
- * gtk_tree_model_node_n_children:
+ * gtk_tree_model_iter_n_children:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode.
+ * @iter: The #GtkTreeIter.
*
- * Returns the number of children that @node has.
+ * Returns the number of children that @iter has.
*
- * Return value: The number of children of @node.
+ * Return value: The number of children of @iter.
**/
gint
-gtk_tree_model_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_n_children != NULL, -1);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_n_children) (tree_model, node);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children != NULL, -1);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children) (tree_model, iter);
}
/**
- * gtk_tree_model_node_nth_child:
+ * gtk_tree_model_iter_nth_child:
* @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode to get the child from.
- * @n: The index of the desired #GtkTreeNode.
+ * @iter: The #GtkTreeIter to set to the nth child.
+ * @parent: The #GtkTreeIter to get the child from, or NULL.
+ * @n: Then index of the desired child.
*
- * Returns a child of @node, using the given index. The first index is 0. If
- * the index is too big, NULL is returned.
+ * Sets @iter to be the child of @parent, using the given index. The first index
+ * is 0. If the index is too big, or @parent has no children, @iter is set to an
+ * invalid iterator and FALSE is returned. @parent will remain a valid node after
+ * this function has been called. If @parent is NULL, then the root node is assumed.
*
- * Return value: the child of @node at index @n.
+ * Return value: TRUE, if @parent has an nth child.
**/
-GtkTreeNode
-gtk_tree_model_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
+gboolean
+gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
gint n)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_nth_child != NULL, NULL);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_nth_child) (tree_model, node, n);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_nth_child != NULL, FALSE);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_nth_child) (tree_model, iter, parent, n);
}
/**
- * gtk_tree_model_node_parent:
- * @tree_model: A #GtkTreeModel.
- * @node: The #GtkTreeNode.
+ * gtk_tree_model_iter_parent:
+ * @tree_model: A #GtkTreeModel
+ * @iter: The #GtkTreeIter.
+ * @parent: The #GtkTreeIter to set to the parent
*
- * Returns the parent of @node. If @node is at depth 0, then NULL is returned.
+ * Sets @iter to be the parent of @child. If @child is at the toplevel, and
+ * doesn't have a parent, then @iter is set to an invalid iterator and FALSE
+ * is returned. @child will remain a valid node after this function has been
+ * called.
*
- * Return value: Returns the parent node of @node, or NULL.
+ * Return value: TRUE, if @iter is set to the parent of @child.
**/
-GtkTreeNode
-gtk_tree_model_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gboolean
+gtk_tree_model_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child)
{
- g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->node_parent != NULL, NULL);
- return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->node_parent) (tree_model, node);
+ g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_parent != NULL, FALSE);
+
+ return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_parent) (tree_model, iter, child);
}
#define GTK_TREE_MODEL_GET_IFACE(obj) ((GtkTreeModelIface *)g_type_interface_peek (((GTypeInstance *)GTK_TREE_MODEL (obj))->g_class, GTK_TYPE_TREE_MODEL))
-typedef gpointer GtkTreeNode;
+typedef struct _GtkTreeIter GtkTreeIter;
typedef struct _GtkTreePath GtkTreePath;
typedef struct _GtkTreeModel GtkTreeModel; /* Dummy typedef */
typedef struct _GtkTreeModelIface GtkTreeModelIface;
+struct _GtkTreeIter
+{
+ gint stamp;
+ gpointer tree_node;
+};
+
struct _GtkTreeModelIface
{
GTypeInterface g_iface;
* objects implementing this interface need this. Later, it will be moved
* back here.
*/
- void (* node_changed) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_inserted) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_child_toggled) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_deleted) (GtkTreeModel *tree_model,
- GtkTreePath *path);
+ void (* changed) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* inserted) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* child_toggled) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* deleted) (GtkTreeModel *tree_model,
+ GtkTreePath *path);
/* VTable - not signals */
gint (* get_n_columns) (GtkTreeModel *tree_model);
- GtkTreeNode (* get_node) (GtkTreeModel *tree_model,
+ GType (* get_column_type) (GtkTreeModel *tree_model,
+ gint index);
+ gboolean (* get_iter) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
GtkTreePath *path);
+ gboolean (* iter_invalid) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
GtkTreePath *(* get_path) (GtkTreeModel *tree_model,
- GtkTreeNode node);
- void (* node_get_value) (GtkTreeModel *tree_model,
- GtkTreeNode node,
+ GtkTreeIter *iter);
+ void (* iter_get_value) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
gint column,
GValue *value);
- gboolean (* node_next) (GtkTreeModel *tree_model,
- GtkTreeNode *node);
- GtkTreeNode (* node_children) (GtkTreeModel *tree_model,
- GtkTreeNode node);
- gboolean (* node_has_child) (GtkTreeModel *tree_model,
- GtkTreeNode node);
- gint (* node_n_children) (GtkTreeModel *tree_model,
- GtkTreeNode node);
- GtkTreeNode (* node_nth_child) (GtkTreeModel *tree_model,
- GtkTreeNode node,
+ gboolean (* iter_next) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+ gboolean (* iter_children) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child);
+ gboolean (* iter_has_child) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+ gint (* iter_n_children) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+ gboolean (* iter_nth_child) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
gint n);
- GtkTreeNode (* node_parent) (GtkTreeModel *tree_model,
- GtkTreeNode node);
+ gboolean (* iter_parent) (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
};
-/* Basic tree_model operations */
-GtkType gtk_tree_model_get_type (void) G_GNUC_CONST;
-
-/* GtkTreePath Operations */
-GtkTreePath *gtk_tree_path_new (void);
-GtkTreePath *gtk_tree_path_new_from_string (gchar *path);
-gchar *gtk_tree_path_to_string (GtkTreePath *path);
-GtkTreePath *gtk_tree_path_new_root (void);
-void gtk_tree_path_append_index (GtkTreePath *path,
- gint index);
-void gtk_tree_path_prepend_index (GtkTreePath *path,
- gint index);
-gint gtk_tree_path_get_depth (GtkTreePath *path);
-gint *gtk_tree_path_get_indices (GtkTreePath *path);
-void gtk_tree_path_free (GtkTreePath *path);
-GtkTreePath *gtk_tree_path_copy (GtkTreePath *path);
-gint gtk_tree_path_compare (const GtkTreePath *a,
- const GtkTreePath *b);
-void gtk_tree_path_next (GtkTreePath *path);
-gint gtk_tree_path_prev (GtkTreePath *path);
-gint gtk_tree_path_up (GtkTreePath *path);
-void gtk_tree_path_down (GtkTreePath *path);
-
-/* Header operations */
-gint gtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
-
-/* Node operations */
-GtkTreeNode gtk_tree_model_get_node (GtkTreeModel *tree_model,
- GtkTreePath *path);
-GtkTreePath *gtk_tree_model_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node);
-void gtk_tree_model_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
- gint column,
- GValue *value);
-gboolean gtk_tree_model_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node);
-GtkTreeNode gtk_tree_model_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-gboolean gtk_tree_model_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node);
-gint gtk_tree_model_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_model_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
- gint n);
-GtkTreeNode gtk_tree_model_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node);
+/* Path operations */
+GtkTreePath *gtk_tree_path_new (void);
+GtkTreePath *gtk_tree_path_new_from_string (gchar *path);
+gchar *gtk_tree_path_to_string (GtkTreePath *path);
+GtkTreePath *gtk_tree_path_new_root (void);
+void gtk_tree_path_append_index (GtkTreePath *path,
+ gint index);
+void gtk_tree_path_prepend_index (GtkTreePath *path,
+ gint index);
+gint gtk_tree_path_get_depth (GtkTreePath *path);
+gint *gtk_tree_path_get_indices (GtkTreePath *path);
+void gtk_tree_path_free (GtkTreePath *path);
+GtkTreePath *gtk_tree_path_copy (GtkTreePath *path);
+gint gtk_tree_path_compare (const GtkTreePath *a,
+ const GtkTreePath *b);
+void gtk_tree_path_next (GtkTreePath *path);
+gint gtk_tree_path_prev (GtkTreePath *path);
+gint gtk_tree_path_up (GtkTreePath *path);
+void gtk_tree_path_down (GtkTreePath *path);
+
+
+/* GtkTreeModel stuff */
+GtkType gtk_tree_model_get_type (void) G_GNUC_CONST;
+
+
+/* Column information */
+gint gtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
+GType gtk_tree_model_get_column_type (GtkTreeModel *tree_model,
+ gint index);
+
+
+/* Iterator movement */
+gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+gboolean gtk_tree_model_iter_invalid (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+GtkTreePath *gtk_tree_model_get_path (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+void gtk_tree_model_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gint column,
+ GValue *value);
+gboolean gtk_tree_model_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+gboolean gtk_tree_model_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+gboolean gtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+gint gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+gboolean gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint n);
+gboolean gtk_tree_model_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child);
#ifdef __cplusplus
#endif /* __GTK_TREE_MODEL_H__ */
-
* gtk_tree_selection_get_selected:
* @selection: A #GtkTreeSelection.
*
- * Returns the currently selected node if @selection is set to
- * #GTK_TREE_SELECTION_SINGLE. Otherwise, it returns the anchor.
+ * Sets @iter to the currently selected node if @selection is set to
+ * #GTK_TREE_SELECTION_SINGLE. Otherwise, it uses the anchor. @iter may be
+ * NULL if you just want to test if @selection has any selected nodes.
*
- * Return value: The selected #GtkTreeNode.
+ * Return value: The if a node is selected.
**/
-GtkTreeNode
-gtk_tree_selection_get_selected (GtkTreeSelection *selection)
+gboolean
+gtk_tree_selection_get_selected (GtkTreeSelection *selection,
+ GtkTreeIter *iter)
{
- GtkTreeNode *retval;
GtkRBTree *tree;
GtkRBNode *node;
- g_return_val_if_fail (selection != NULL, NULL);
- g_return_val_if_fail (GTK_IS_TREE_SELECTION (selection), NULL);
+ g_return_val_if_fail (selection != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_TREE_SELECTION (selection), FALSE);
if (selection->tree_view->priv->anchor == NULL)
- return NULL;
+ return FALSE;
+ else if (iter == NULL)
+ return TRUE;
- g_return_val_if_fail (selection->tree_view != NULL, NULL);
- g_return_val_if_fail (selection->tree_view->priv->model != NULL, NULL);
+ g_return_val_if_fail (selection->tree_view != NULL, FALSE);
+ g_return_val_if_fail (selection->tree_view->priv->model != NULL, FALSE);
if (!_gtk_tree_view_find_node (selection->tree_view,
selection->tree_view->priv->anchor,
/* We don't want to return the anchor if it isn't actually selected.
*/
- return NULL;
+ return FALSE;
- retval = gtk_tree_model_get_node (selection->tree_view->priv->model,
- selection->tree_view->priv->anchor);
- return retval;
+ return gtk_tree_model_get_iter (selection->tree_view->priv->model,
+ iter,
+ selection->tree_view->priv->anchor);
}
/**
GtkTreePath *path;
GtkRBTree *tree;
GtkRBNode *node;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
g_return_if_fail (selection != NULL);
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
/* find the node internally */
path = gtk_tree_path_new_root ();
- tree_node = gtk_tree_model_get_node (selection->tree_view->priv->model, path);
+ gtk_tree_model_get_iter (selection->tree_view->priv->model,
+ &iter, path);
gtk_tree_path_free (path);
do
{
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
- (* func) (selection->tree_view->priv->model, tree_node, data);
+ (* func) (selection->tree_view->priv->model, &iter, data);
if (node->children)
{
+ gboolean has_child;
+ GtkTreeIter tmp;
+
tree = node->children;
node = tree->root;
while (node->left != tree->nil)
node = node->left;
- tree_node = gtk_tree_model_node_children (selection->tree_view->priv->model, tree_node);
+ tmp = iter;
+ has_child = gtk_tree_model_iter_children (selection->tree_view->priv->model, &iter, &tmp);
/* Sanity Check! */
- TREE_VIEW_INTERNAL_ASSERT_VOID (tree_node != NULL);
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
}
else
{
node = _gtk_rbtree_next (tree, node);
if (node != NULL)
{
- gtk_tree_model_node_next (selection->tree_view->priv->model, &tree_node);
+ gboolean has_next;
+
+ has_next = gtk_tree_model_iter_next (selection->tree_view->priv->model, &iter);
done = TRUE;
/* Sanity Check! */
- TREE_VIEW_INTERNAL_ASSERT_VOID (tree_node != NULL);
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
}
else
{
+ gboolean has_parent;
+ GtkTreeIter tmp_iter = iter;
+
node = tree->parent_node;
tree = tree->parent_tree;
if (tree == NULL)
/* we've run out of tree */
/* We're done with this function */
return;
- tree_node = gtk_tree_model_node_parent (selection->tree_view->priv->model, tree_node);
+ has_parent = gtk_tree_model_iter_parent (selection->tree_view->priv->model, &iter, &tmp_iter);
/* Sanity check */
- TREE_VIEW_INTERNAL_ASSERT_VOID (tree_node != NULL);
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
}
}
while (!done);
}
/**
- * gtk_tree_selection_select_node:
+ * gtk_tree_selection_select_iter:
* @selection: A #GtkTreeSelection.
- * @tree_node: The #GtkTreeNode to be selected.
+ * @iter: The #GtkTreeIter to be selected.
*
- * Selects the specified node.
+ * Selects the specified iterator.
**/
void
-gtk_tree_selection_select_node (GtkTreeSelection *selection,
- GtkTreeNode tree_node)
+gtk_tree_selection_select_iter (GtkTreeSelection *selection,
+ GtkTreeIter *iter)
{
GtkTreePath *path;
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (selection->tree_view != NULL);
g_return_if_fail (selection->tree_view->priv->model != NULL);
+ g_return_if_fail (iter == NULL);
path = gtk_tree_model_get_path (selection->tree_view->priv->model,
- tree_node);
+ iter);
if (path == NULL)
return;
/**
- * gtk_tree_selection_unselect_node:
+ * gtk_tree_selection_unselect_iter:
* @selection: A #GtkTreeSelection.
- * @tree_node: The #GtkTreeNode to be unselected.
+ * @iter: The #GtkTreeIter to be unselected.
*
- * Unselects the specified node.
+ * Unselects the specified iterator.
**/
void
-gtk_tree_selection_unselect_node (GtkTreeSelection *selection,
- GtkTreeNode tree_node)
+gtk_tree_selection_unselect_iter (GtkTreeSelection *selection,
+ GtkTreeIter *iter)
{
GtkTreePath *path;
g_return_if_fail (selection != NULL);
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (selection->tree_view->priv->model != NULL);
+ g_return_if_fail (iter == NULL);
path = gtk_tree_model_get_path (selection->tree_view->priv->model,
- tree_node);
+ iter);
if (path == NULL)
return;
}
if (selected == TRUE)
{
- GtkTreeNode tree_node;
- tree_node = gtk_tree_model_get_node (selection->tree_view->priv->model, path);
-
node->flags ^= GTK_RBNODE_IS_SELECTED;
/* FIXME: just draw the one node*/
GtkTreePath *path,
gpointer data);
typedef void (* GtkTreeSelectionForeachFunc) (GtkTreeModel *model,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gpointer data);
struct _GtkTreeSelection
/* Only meaningful if GTK_TREE_SELECTION_SINGLE is set */
/* Use selected_foreach for GTK_TREE_SELECTION_MULTI */
-GtkTreeNode gtk_tree_selection_get_selected (GtkTreeSelection *selection);
+gboolean gtk_tree_selection_get_selected (GtkTreeSelection *selection,
+ GtkTreeIter *iter);
/* FIXME: Get a more convenient get_selection function???? one returning GSList?? */
void gtk_tree_selection_selected_foreach (GtkTreeSelection *selection,
GtkTreePath *path);
void gtk_tree_selection_unselect_path (GtkTreeSelection *selection,
GtkTreePath *path);
-void gtk_tree_selection_select_node (GtkTreeSelection *selection,
- GtkTreeNode tree_node);
-void gtk_tree_selection_unselect_node (GtkTreeSelection *selection,
- GtkTreeNode tree_node);
+void gtk_tree_selection_select_iter (GtkTreeSelection *selection,
+ GtkTreeIter *iter);
+void gtk_tree_selection_unselect_iter (GtkTreeSelection *selection,
+ GtkTreeIter *iter);
void gtk_tree_selection_select_all (GtkTreeSelection *selection);
void gtk_tree_selection_unselect_all (GtkTreeSelection *selection);
void gtk_tree_selection_select_range (GtkTreeSelection *selection,
#include "gtktreedatalist.h"
#include "gtksignal.h"
#include <string.h>
+#include <gobject/gvaluecollector.h>
#define G_NODE(node) ((GNode *)node)
enum {
- NODE_CHANGED,
- NODE_INSERTED,
- NODE_CHILD_TOGGLED,
- NODE_DELETED,
+ CHANGED,
+ INSERTED,
+ CHILD_TOGGLED,
+ DELETED,
LAST_SIGNAL
};
static guint tree_store_signals[LAST_SIGNAL] = { 0 };
-static void gtk_tree_store_init (GtkTreeStore *tree_store);
-static void gtk_tree_store_class_init (GtkTreeStoreClass *tree_store_class);
-static void gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
-static gint gtk_tree_store_get_n_columns (GtkTreeModel *tree_model);
-static GtkTreeNode gtk_tree_store_get_node (GtkTreeModel *tree_model,
- GtkTreePath *path);
-static GtkTreePath *gtk_tree_store_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static void gtk_tree_store_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
- gint column,
- GValue *value);
-static gboolean gtk_tree_store_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node);
-static GtkTreeNode gtk_tree_store_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static gboolean gtk_tree_store_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static gint gtk_tree_store_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node);
-static GtkTreeNode gtk_tree_store_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
- gint n);
-static GtkTreeNode gtk_tree_store_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node);
+static void gtk_tree_store_init (GtkTreeStore *tree_store);
+static void gtk_tree_store_class_init (GtkTreeStoreClass *tree_store_class);
+static void gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
+static gint gtk_tree_store_get_n_columns (GtkTreeModel *tree_model);
+static GtkTreePath *gtk_tree_store_get_path (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static void gtk_tree_store_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gint column,
+ GValue *value);
+static gboolean gtk_tree_store_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gboolean gtk_tree_store_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+static gboolean gtk_tree_store_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gint gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gboolean gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child,
+ gint n);
+static gboolean gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
GtkType
object_class = (GtkObjectClass *) tree_store_class;
- tree_store_signals[NODE_CHANGED] =
- gtk_signal_new ("node_changed",
+ tree_store_signals[CHANGED] =
+ gtk_signal_new ("changed",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTreeStoreClass, node_changed),
+ GTK_SIGNAL_OFFSET (GtkTreeStoreClass, changed),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- tree_store_signals[NODE_INSERTED] =
- gtk_signal_new ("node_inserted",
+ tree_store_signals[INSERTED] =
+ gtk_signal_new ("inserted",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTreeStoreClass, node_inserted),
+ GTK_SIGNAL_OFFSET (GtkTreeStoreClass, inserted),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- tree_store_signals[NODE_CHILD_TOGGLED] =
- gtk_signal_new ("node_child_toggled",
+ tree_store_signals[CHILD_TOGGLED] =
+ gtk_signal_new ("child_toggled",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTreeStoreClass, node_child_toggled),
+ GTK_SIGNAL_OFFSET (GtkTreeStoreClass, child_toggled),
gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
- tree_store_signals[NODE_DELETED] =
- gtk_signal_new ("node_deleted",
+ tree_store_signals[DELETED] =
+ gtk_signal_new ("deleted",
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTreeStoreClass, node_deleted),
+ GTK_SIGNAL_OFFSET (GtkTreeStoreClass, deleted),
gtk_marshal_VOID__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
gtk_tree_store_tree_model_init (GtkTreeModelIface *iface)
{
iface->get_n_columns = gtk_tree_store_get_n_columns;
- iface->get_node = gtk_tree_store_get_node;
iface->get_path = gtk_tree_store_get_path;
- iface->node_get_value = gtk_tree_store_node_get_value;
- iface->node_next = gtk_tree_store_node_next;
- iface->node_children = gtk_tree_store_node_children;
- iface->node_has_child = gtk_tree_store_node_has_child;
- iface->node_n_children = gtk_tree_store_node_n_children;
- iface->node_nth_child = gtk_tree_store_node_nth_child;
- iface->node_parent = gtk_tree_store_node_parent;
+ iface->iter_get_value = gtk_tree_store_iter_get_value;
+ iface->iter_next = gtk_tree_store_iter_next;
+ iface->iter_children = gtk_tree_store_iter_children;
+ iface->iter_has_child = gtk_tree_store_iter_has_child;
+ iface->iter_n_children = gtk_tree_store_iter_n_children;
+ iface->iter_nth_child = gtk_tree_store_iter_nth_child;
+ iface->iter_parent = gtk_tree_store_iter_parent;
}
static void
gtk_tree_store_init (GtkTreeStore *tree_store)
{
- tree_store->root = gtk_tree_store_node_new ();
+ tree_store->root = g_node_new (NULL);
+ tree_store->stamp = 1;
}
-GtkObject *
+GtkTreeStore *
gtk_tree_store_new (void)
{
- return GTK_OBJECT (gtk_type_new (gtk_tree_store_get_type ()));
+ return GTK_TREE_STORE (gtk_type_new (gtk_tree_store_get_type ()));
}
-GtkObject *
+GtkTreeStore *
gtk_tree_store_new_with_values (gint n_columns,
...)
{
- GtkObject *retval;
+ GtkTreeStore *retval;
va_list args;
gint i;
g_return_val_if_fail (n_columns > 0, NULL);
retval = gtk_tree_store_new ();
- gtk_tree_store_set_n_columns (GTK_TREE_STORE (retval),
- n_columns);
+ gtk_tree_store_set_n_columns (retval, n_columns);
va_start (args, n_columns);
+
for (i = 0; i < n_columns; i++)
- gtk_tree_store_set_column_type (GTK_TREE_STORE (retval),
- i, va_arg (args, GType));
+ gtk_tree_store_set_column_type (retval, i, va_arg (args, GType));
va_end (args);
return GTK_TREE_STORE (tree_model)->n_columns;
}
-static GtkTreeNode
-gtk_tree_store_get_node (GtkTreeModel *tree_model,
- GtkTreePath *path)
-{
- gint i;
- GtkTreeNode node;
- gint *indices = gtk_tree_path_get_indices (path);
-
- node = GTK_TREE_STORE (tree_model)->root;
-
- for (i = 0; i < gtk_tree_path_get_depth (path); i ++)
- {
- node = (GtkTreeNode) gtk_tree_store_node_nth_child (tree_model,
- (GtkTreeNode) node,
- indices[i]);
- if (node == NULL)
- return NULL;
- }
- return (GtkTreeNode) node;
-}
-
static GtkTreePath *
gtk_tree_store_get_path (GtkTreeModel *tree_model,
- GtkTreeNode node)
+ GtkTreeIter *iter)
{
GtkTreePath *retval;
GNode *tmp_node;
gint i = 0;
g_return_val_if_fail (tree_model != NULL, NULL);
-
- if (node == NULL)
- return NULL;
- if (node == G_NODE (GTK_TREE_STORE (tree_model)->root))
+ g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), NULL);
+ g_return_val_if_fail (iter != NULL, NULL);
+ g_return_val_if_fail (GTK_TREE_STORE (tree_model)->stamp == iter->stamp, NULL);
+ if (iter->tree_node == NULL)
return NULL;
- if (G_NODE (node)->parent == G_NODE (GTK_TREE_STORE (tree_model)->root))
+ if (G_NODE (iter->tree_node)->parent == G_NODE (GTK_TREE_STORE (tree_model)->root))
{
retval = gtk_tree_path_new ();
tmp_node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
}
else
{
+ GtkTreeIter tmp_iter = *iter;
+ tmp_iter.tree_node = G_NODE (tmp_iter.tree_node)->parent;
+
retval = gtk_tree_store_get_path (tree_model,
- G_NODE (node)->parent);
- tmp_node = G_NODE (node)->parent->children;
+ &tmp_iter);
+ tmp_node = G_NODE (iter->tree_node)->parent->children;
}
if (retval == NULL)
return NULL;
+
if (tmp_node == NULL)
{
gtk_tree_path_free (retval);
for (; tmp_node; tmp_node = tmp_node->next)
{
- if (tmp_node == G_NODE (node))
+ if (tmp_node == G_NODE (iter->tree_node))
break;
i++;
}
+
if (tmp_node == NULL)
{
/* We couldn't find node, meaning it's prolly not ours */
+ /* Perhaps I should do a g_return_if_fail here. */
gtk_tree_path_free (retval);
return NULL;
}
static void
-gtk_tree_store_node_get_value (GtkTreeModel *tree_model,
- GtkTreeNode node,
+gtk_tree_store_iter_get_value (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
gint column,
GValue *value)
{
g_return_if_fail (tree_model != NULL);
g_return_if_fail (GTK_IS_TREE_STORE (tree_model));
- g_return_if_fail (node != NULL);
+ g_return_if_fail (iter != NULL);
+ g_return_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->stamp);
g_return_if_fail (column < GTK_TREE_STORE (tree_model)->n_columns);
- list = G_NODE (node)->data;
+ list = G_NODE (iter->tree_node)->data;
while (tmp_column-- > 0 && list)
list = list->next;
- g_return_if_fail (list != NULL);
-
- gtk_tree_data_list_node_to_value (list,
- GTK_TREE_STORE (tree_model)->column_headers[column],
- value);
+ if (list)
+ {
+ gtk_tree_data_list_node_to_value (list,
+ GTK_TREE_STORE (tree_model)->column_headers[column],
+ value);
+ }
+ else
+ {
+ /* We want to return an initialized but empty (default) value */
+ g_value_init (value, GTK_TREE_STORE (tree_model)->column_headers[column]);
+ }
}
static gboolean
-gtk_tree_store_node_next (GtkTreeModel *tree_model,
- GtkTreeNode *node)
+gtk_tree_store_iter_next (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- if (node == NULL || *node == NULL)
+ if (iter->tree_node == NULL)
return FALSE;
- *node = (GtkTreeNode) G_NODE (*node)->next;
- return (*node != NULL);
+ iter->tree_node = G_NODE (iter->tree_node)->next;
+
+ return (iter->tree_node != NULL);
}
-static GtkTreeNode
-gtk_tree_store_node_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+static gboolean
+gtk_tree_store_iter_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
{
- return (GtkTreeNode) G_NODE (node)->children;
+ iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
+ iter->tree_node = G_NODE (parent->tree_node)->children;
+
+ return iter->tree_node != NULL;
}
static gboolean
-gtk_tree_store_node_has_child (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_tree_store_iter_has_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- return G_NODE (node)->children != NULL;
+ g_return_val_if_fail (tree_model != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->stamp, FALSE);
+
+ return G_NODE (iter->tree_node)->children != NULL;
}
static gint
-gtk_tree_store_node_n_children (GtkTreeModel *tree_model,
- GtkTreeNode node)
+gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
+ GNode *node;
gint i = 0;
- node = (GtkTreeNode) G_NODE (node)->children;
- while (node != NULL)
+ g_return_val_if_fail (tree_model != NULL, 0);
+ g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
+ g_return_val_if_fail (iter != NULL, 0);
+ g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->stamp, 0);
+
+ node = G_NODE (iter->tree_node)->children;
+ while (node)
{
i++;
- node = (GtkTreeNode) G_NODE (node)->next;
+ node = node->next;
}
return i;
}
-static GtkTreeNode
-gtk_tree_store_node_nth_child (GtkTreeModel *tree_model,
- GtkTreeNode node,
+static gboolean
+gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
gint n)
{
- g_return_val_if_fail (node != NULL, NULL);
+ GNode *parent_node;
- return (GtkTreeNode) g_node_nth_child (G_NODE (node), n);
-}
+ g_return_val_if_fail (tree_model != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
+ if (parent)
+ g_return_val_if_fail (parent->stamp == GTK_TREE_STORE (tree_model)->stamp, FALSE);
-static GtkTreeNode
-gtk_tree_store_node_parent (GtkTreeModel *tree_model,
- GtkTreeNode node)
-{
- return (GtkTreeNode) G_NODE (node)->parent;
+ if (parent == NULL)
+ parent_node = GTK_TREE_STORE (tree_model)->root;
+ else
+ parent_node = parent->tree_node;
+
+ iter->tree_node = g_node_nth_child (parent_node, n);
+
+ if (iter->tree_node == NULL)
+ iter->stamp = 0;
+ else
+ iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
+
+ return (iter->tree_node != NULL);
}
-/* Public accessors */
-GtkTreeNode
-gtk_tree_store_node_new (void)
+static gboolean
+gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child)
{
- GtkTreeNode retval;
+ iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
+ iter->tree_node = G_NODE (child->tree_node)->parent;
- retval = (GtkTreeNode) g_node_new (NULL);
- return retval;
+ if (iter->tree_node == GTK_TREE_STORE (tree_model)->root)
+ {
+ iter->stamp = 0;
+ return FALSE;
+ }
+
+ return TRUE;
}
/*
* manipulations on it's own.
*/
void
-gtk_tree_store_node_set_cell (GtkTreeStore *tree_store,
- GtkTreeNode node,
+gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
gint column,
GValue *value)
{
g_return_if_fail (tree_store != NULL);
g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
- g_return_if_fail (node != NULL);
g_return_if_fail (column >= 0 && column < tree_store->n_columns);
- prev = list = G_NODE (node)->data;
+ prev = list = G_NODE (iter->tree_node)->data;
while (list != NULL)
{
list = list->next;
}
- if (G_NODE (node)->data == NULL)
+ if (G_NODE (iter->tree_node)->data == NULL)
{
- G_NODE (node)->data = list = gtk_tree_data_list_alloc ();
+ G_NODE (iter->tree_node)->data = list = gtk_tree_data_list_alloc ();
list->next = NULL;
}
else
}
void
-gtk_tree_store_node_remove (GtkTreeStore *model,
- GtkTreeNode node)
+gtk_tree_store_iter_setv (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ va_list var_args)
+{
+ gint column;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
+
+ column = va_arg (var_args, gint);
+
+ while (column >= 0)
+ {
+ GValue value = { 0, };
+ gchar *error = NULL;
+
+ if (column >= tree_store->n_columns)
+ {
+ g_warning ("Invalid column number %d added to iter", column);
+ break;
+ }
+ g_value_init (&value, tree_store->column_headers[column]);
+
+ G_VALUE_COLLECT (&value, var_args, &error);
+ if (error)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+
+ /* we purposely leak the value here, it might not be
+ * in a sane state if an error condition occoured
+ */
+ break;
+ }
+
+ gtk_tree_store_iter_set_cell (tree_store,
+ iter,
+ column,
+ &value);
+
+ g_value_unset (&value);
+
+ column = va_arg (var_args, gint);
+ }
+}
+
+void
+gtk_tree_store_iter_set (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
+
+ va_start (var_args, iter);
+ gtk_tree_store_iter_setv (tree_store, iter, var_args);
+ va_end (var_args);
+}
+
+void
+gtk_tree_store_iter_getv (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ va_list var_args)
+{
+ gint column;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
+
+ column = va_arg (var_args, gint);
+
+ while (column >= 0)
+ {
+ GValue value = { 0, };
+ gchar *error = NULL;
+
+ if (column >= tree_store->n_columns)
+ {
+ g_warning ("Invalid column number %d accessed", column);
+ break;
+ }
+
+ gtk_tree_store_iter_get_value (GTK_TREE_MODEL (tree_store), iter, column, &value);
+
+ G_VALUE_LCOPY (&value, var_args, &error);
+ if (error)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+
+ /* we purposely leak the value here, it might not be
+ * in a sane state if an error condition occoured
+ */
+ break;
+ }
+
+ g_value_unset (&value);
+
+ column = va_arg (var_args, gint);
+ }
+}
+
+void
+gtk_tree_store_iter_get (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
+
+ va_start (var_args, iter);
+ gtk_tree_store_iter_getv (tree_store, iter, var_args);
+ va_end (var_args);
+}
+
+void
+gtk_tree_store_iter_remove (GtkTreeStore *model,
+ GtkTreeIter *iter)
{
GtkTreePath *path;
GNode *parent;
g_return_if_fail (model != NULL);
g_return_if_fail (GTK_IS_TREE_STORE (model));
- g_return_if_fail (node != NULL);
- /* FIXME: if node is NULL, do I want to free the tree? */
- parent = G_NODE (node)->parent;
+ parent = G_NODE (iter->tree_node)->parent;
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), node);
- g_node_destroy (G_NODE (node));
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
+ g_node_destroy (G_NODE (iter->tree_node));
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_deleted",
+ "deleted",
path);
if (parent != G_NODE (model->root) && parent->children == NULL)
{
gtk_tree_path_up (path);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_child_toggled",
+ "child_toggled",
path,
parent);
}
gtk_tree_path_free (path);
}
-GtkTreeNode
-gtk_tree_store_node_insert (GtkTreeStore *model,
- GtkTreeNode parent,
- gint position,
- GtkTreeNode node)
+void
+gtk_tree_store_iter_insert (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint position)
{
GtkTreePath *path;
- g_return_val_if_fail (model != NULL, node);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), node);
- g_return_val_if_fail (node != NULL, node);
-
- if (parent == NULL)
- parent = model->root;
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
- g_node_insert (G_NODE (parent), position, G_NODE (node));
+ if (parent->tree_node == NULL)
+ parent->tree_node = model->root;
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), node);
+ iter->stamp = model->stamp;
+ iter->tree_node = g_node_new (NULL);
+ g_node_insert (G_NODE (parent->tree_node), position, G_NODE (iter->tree_node));
+
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_inserted",
- path, node);
+ "inserted",
+ path, iter);
gtk_tree_path_free (path);
-
- return node;
}
-GtkTreeNode
-gtk_tree_store_node_insert_before (GtkTreeStore *model,
- GtkTreeNode parent,
- GtkTreeNode sibling,
- GtkTreeNode node)
+void
+gtk_tree_store_iter_insert_before (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ GtkTreeIter *sibling)
{
GtkTreePath *path;
+ GNode *parent_node = NULL;
- g_return_val_if_fail (model != NULL, node);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), node);
- g_return_val_if_fail (node != NULL, node);
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
+ g_return_if_fail (iter != NULL);
+ if (parent != NULL)
+ g_return_if_fail (parent->stamp == model->stamp);
+ if (sibling != NULL)
+ g_return_if_fail (sibling->stamp == model->stamp);
- if (parent == NULL && sibling == NULL)
- parent = model->root;
+ iter->stamp = model->stamp;
+ iter->tree_node = g_node_new (NULL);
- if (parent == NULL)
- parent = (GtkTreeNode) G_NODE (sibling)->parent;
+ if (parent == NULL && sibling == NULL)
+ parent_node = model->root;
+ else if (parent == NULL)
+ parent_node = G_NODE (sibling->tree_node)->parent;
+ else
+ parent_node = G_NODE (parent->tree_node);
- g_node_insert_before (G_NODE (parent), G_NODE (sibling), G_NODE (node));
+ g_node_insert_before (parent_node,
+ sibling ? G_NODE (sibling->tree_node) : NULL,
+ G_NODE (iter->tree_node));
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), node);
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_inserted",
- path, node);
+ "inserted",
+ path, iter);
gtk_tree_path_free (path);
-
- return node;
}
-GtkTreeNode
-gtk_tree_store_node_insert_after (GtkTreeStore *model,
- GtkTreeNode parent,
- GtkTreeNode sibling,
- GtkTreeNode node)
+void
+gtk_tree_store_iter_insert_after (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ GtkTreeIter *sibling)
{
GtkTreePath *path;
+ GNode *parent_node;
- g_return_val_if_fail (model != NULL, node);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), node);
- g_return_val_if_fail (node != NULL, node);
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
+ g_return_if_fail (iter != NULL);
+ if (parent != NULL)
+ g_return_if_fail (parent->stamp == model->stamp);
+ if (sibling != NULL)
+ g_return_if_fail (sibling->stamp == model->stamp);
- if (parent == NULL && sibling == NULL)
- parent = model->root;
+ iter->stamp = model->stamp;
+ iter->tree_node = g_node_new (NULL);
- if (parent == NULL)
- parent = (GtkTreeNode) G_NODE (sibling)->parent;
+ if (parent == NULL && sibling == NULL)
+ parent_node = model->root;
+ else if (parent == NULL)
+ parent_node = G_NODE (sibling->tree_node)->parent;
+ else
+ parent_node = G_NODE (parent->tree_node);
- g_node_insert_after (G_NODE (parent), G_NODE (sibling), G_NODE (node));
+ g_node_insert_after (parent_node,
+ sibling ? G_NODE (sibling->tree_node) : NULL,
+ G_NODE (iter->tree_node));
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), node);
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_inserted",
- path, node);
+ "inserted",
+ path, iter);
gtk_tree_path_free (path);
- return node;
}
-GtkTreeNode
-gtk_tree_store_node_prepend (GtkTreeStore *model,
- GtkTreeNode parent,
- GtkTreeNode node)
+void
+gtk_tree_store_iter_prepend (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
{
- g_return_val_if_fail (model != NULL, node);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), node);
- g_return_val_if_fail (node != NULL, node);
+ GNode *parent_node;
+
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
+ g_return_if_fail (iter != NULL);
+ if (parent != NULL)
+ g_return_if_fail (parent->stamp == model->stamp);
if (parent == NULL)
- parent = model->root;
+ parent_node = model->root;
+ else
+ parent_node = parent->tree_node;
- if (G_NODE (parent)->children == NULL)
+ iter->stamp = model->stamp;
+ iter->tree_node = g_node_new (NULL);
+
+ if (parent_node->children == NULL)
{
GtkTreePath *path;
- g_node_prepend (G_NODE (parent), G_NODE (node));
- if (parent != model->root)
+
+ g_node_prepend (parent_node, G_NODE (iter->tree_node));
+
+ if (parent_node != model->root)
{
path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_child_toggled",
+ "child_toggled",
path,
parent);
- gtk_tree_path_append_index (path, 1);
+ gtk_tree_path_append_index (path, 0);
}
else
{
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), G_NODE (parent)->children);
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
}
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_inserted",
+ "inserted",
path,
- G_NODE (parent)->children);
+ iter);
gtk_tree_path_free (path);
}
else
{
- gtk_tree_store_node_insert_after (model,
- parent == model->root?NULL:parent,
- NULL,
- node);
+ gtk_tree_store_iter_insert_after (model, iter, parent, NULL);
}
- return node;
}
-GtkTreeNode
-gtk_tree_store_node_append (GtkTreeStore *model,
- GtkTreeNode parent,
- GtkTreeNode node)
+void
+gtk_tree_store_iter_append (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
{
- g_return_val_if_fail (model != NULL, node);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), node);
- g_return_val_if_fail (node != NULL, node);
+ GNode *parent_node;
+
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
+ g_return_if_fail (iter != NULL);
+ if (parent != NULL)
+ g_return_if_fail (parent->stamp == model->stamp);
if (parent == NULL)
- parent = model->root;
+ parent_node = model->root;
+ else
+ parent_node = parent->tree_node;
- if (G_NODE (parent)->children == NULL)
+ iter->stamp = model->stamp;
+ iter->tree_node = g_node_new (NULL);
+
+ if (parent_node->children == NULL)
{
GtkTreePath *path;
- g_node_append (G_NODE (parent), G_NODE (node));
- if (parent != model->root)
+
+ g_node_append (parent_node, G_NODE (iter->tree_node));
+
+ if (parent_node != model->root)
{
path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_child_toggled",
+ "child_toggled",
path,
parent);
- gtk_tree_path_append_index (path, 1);
+ gtk_tree_path_append_index (path, 0);
}
else
{
- path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), G_NODE (parent)->children);
+ path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
}
gtk_signal_emit_by_name (GTK_OBJECT (model),
- "node_inserted",
+ "inserted",
path,
- G_NODE (parent)->children);
+ iter);
gtk_tree_path_free (path);
}
else
{
- gtk_tree_store_node_insert_before (model,
- parent == model->root?NULL:parent,
- NULL,
- node);
+ gtk_tree_store_iter_insert_before (model, iter, parent, NULL);
}
- return node;
}
-GtkTreeNode
-gtk_tree_store_node_get_root (GtkTreeStore *model)
+void
+gtk_tree_store_get_root (GtkTreeStore *model,
+ GtkTreeIter *iter)
{
- g_return_val_if_fail (model != NULL, NULL);
- g_return_val_if_fail (GTK_IS_TREE_STORE (model), NULL);
+ g_return_if_fail (model != NULL);
+ g_return_if_fail (GTK_IS_TREE_STORE (model));
+ g_return_if_fail (iter != NULL);
- return (GtkTreeNode) model->root;
+ iter->stamp = model->stamp;
+ iter->tree_node = G_NODE (model->root)->children;
}
gboolean
-gtk_tree_store_node_is_ancestor (GtkTreeStore *model,
- GtkTreeNode node,
- GtkTreeNode descendant)
+gtk_tree_store_iter_is_ancestor (GtkTreeStore *model,
+ GtkTreeIter *iter,
+ GtkTreeIter *descendant)
{
g_return_val_if_fail (model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_STORE (model), FALSE);
- g_return_val_if_fail (node != NULL, FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (descendant != NULL, FALSE);
+ g_return_val_if_fail (iter->stamp == model->stamp, FALSE);
+ g_return_val_if_fail (descendant->stamp == model->stamp, FALSE);
- return g_node_is_ancestor (G_NODE (node), G_NODE (descendant));
+ return g_node_is_ancestor (G_NODE (iter->tree_node),
+ G_NODE (descendant->tree_node));
}
gint
-gtk_tree_store_node_depth (GtkTreeStore *model,
- GtkTreeNode node)
+gtk_tree_store_iter_depth (GtkTreeStore *model,
+ GtkTreeIter *iter)
{
g_return_val_if_fail (model != NULL, 0);
g_return_val_if_fail (GTK_IS_TREE_STORE (model), 0);
- g_return_val_if_fail (node != NULL, 0);
+ g_return_val_if_fail (iter != NULL, 0);
+ g_return_val_if_fail (iter->stamp == model->stamp, 0);
- return g_node_depth (G_NODE (node));
+ return g_node_depth (G_NODE (iter->tree_node)) - 1;
}
#define __GTK_TREE_STORE_H__
#include <gtk/gtktreemodel.h>
+#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
struct _GtkTreeStore
{
GtkObject parent;
- GtkTreeNode root;
+
+ gint stamp;
+ gpointer root;
gint n_columns;
GType *column_headers;
};
/* signals */
/* Will be moved into the GtkTreeModelIface eventually */
- void (* node_changed) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_inserted) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_child_toggled) (GtkTreeModel *tree_model,
- GtkTreePath *path,
- GtkTreeNode node);
- void (* node_deleted) (GtkTreeModel *tree_model,
- GtkTreePath *path);
+ void (* changed) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* inserted) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* child_toggled) (GtkTreeModel *tree_model,
+ GtkTreePath *path,
+ GtkTreeIter *iter);
+ void (* deleted) (GtkTreeModel *tree_model,
+ GtkTreePath *path);
};
-GtkType gtk_tree_store_get_type (void);
-GtkObject *gtk_tree_store_new (void);
-GtkObject *gtk_tree_store_new_with_values (gint n_columns,
- ...);
-void gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
- gint n_columns);
-void gtk_tree_store_set_column_type (GtkTreeStore *store,
- gint column,
- GType type);
-
-GtkTreeNode gtk_tree_store_node_new (void);
-void gtk_tree_store_node_set_cell (GtkTreeStore *tree_store,
- GtkTreeNode node,
- gint column,
- GValue *value);
-void gtk_tree_store_node_remove (GtkTreeStore *tree_store,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_insert (GtkTreeStore *tree_store,
- GtkTreeNode parent,
- gint position,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_insert_before (GtkTreeStore *tree_store,
- GtkTreeNode parent,
- GtkTreeNode sibling,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_insert_after (GtkTreeStore *tree_store,
- GtkTreeNode parent,
- GtkTreeNode sibling,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_prepend (GtkTreeStore *tree_store,
- GtkTreeNode parent,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_append (GtkTreeStore *tree_store,
- GtkTreeNode parent,
- GtkTreeNode node);
-GtkTreeNode gtk_tree_store_node_get_root (GtkTreeStore *tree_store);
-gboolean gtk_tree_store_node_is_ancestor (GtkTreeStore *tree_store,
- GtkTreeNode node,
- GtkTreeNode descendant);
-gint gtk_tree_store_node_depth (GtkTreeStore *tree_store,
- GtkTreeNode node);
-
+GtkType gtk_tree_store_get_type (void);
+GtkTreeStore *gtk_tree_store_new (void);
+GtkTreeStore *gtk_tree_store_new_with_values (gint n_columns,
+ ...);
+void gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
+ gint n_columns);
+void gtk_tree_store_set_column_type (GtkTreeStore *store,
+ gint column,
+ GType type);
+void gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ gint column,
+ GValue *value);
+void gtk_tree_store_iter_set (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ ...);
+void gtk_tree_store_iter_setv (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ va_list var_args);
+void gtk_tree_store_iter_get (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ ...);
+void gtk_tree_store_iter_getv (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ va_list var_args);
+void gtk_tree_store_iter_remove (GtkTreeStore *tree_store,
+ GtkTreeIter *iter);
+void gtk_tree_store_iter_insert (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint position);
+void gtk_tree_store_iter_insert_before (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ GtkTreeIter *sibling);
+void gtk_tree_store_iter_insert_after (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ GtkTreeIter *sibling);
+void gtk_tree_store_iter_prepend (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+void gtk_tree_store_iter_append (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+void gtk_tree_store_get_root (GtkTreeStore *tree_store,
+ GtkTreeIter *iter);
+gboolean gtk_tree_store_iter_is_ancestor (GtkTreeStore *tree_store,
+ GtkTreeIter *iter,
+ GtkTreeIter *descendant);
+gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
+ GtkTreeIter *iter);
#ifdef __cplusplus
static void gtk_tree_view_set_adjustments (GtkTreeView *tree_view,
GtkAdjustment *hadj,
GtkAdjustment *vadj);
-static void gtk_tree_view_node_changed (GtkTreeModel *model,
+static void gtk_tree_view_changed (GtkTreeModel *model,
GtkTreePath *path,
- GtkTreeNode tree_node,
+ GtkTreeIter *iter,
gpointer data);
-static void gtk_tree_view_node_inserted (GtkTreeModel *model,
+static void gtk_tree_view_inserted (GtkTreeModel *model,
GtkTreePath *path,
- GtkTreeNode tree_node,
+ GtkTreeIter *iter,
gpointer data);
-static void gtk_tree_view_node_child_toggled (GtkTreeModel *model,
+static void gtk_tree_view_child_toggled (GtkTreeModel *model,
GtkTreePath *path,
- GtkTreeNode tree_node,
+ GtkTreeIter *iter,
gpointer data);
-static void gtk_tree_view_node_deleted (GtkTreeModel *model,
+static void gtk_tree_view_deleted (GtkTreeModel *model,
GtkTreePath *path,
gpointer data);
gint *x);
static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view);
-static gint gtk_tree_view_insert_node_height (GtkTreeView *tree_view,
+static gint gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth);
static void gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth,
gboolean recurse,
gboolean calc_bounds);
static void gtk_tree_view_calc_size (GtkTreeView *priv,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth);
-static gboolean gtk_tree_view_discover_dirty_node (GtkTreeView *tree_view,
- GtkTreeNode node,
+static gboolean gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
+ GtkTreeIter *iter,
gint depth,
gint *height);
static void gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth);
static void gtk_tree_view_check_dirty (GtkTreeView *tree_view);
static void gtk_tree_view_create_button (GtkTreeView *tree_view,
widget_class->size_allocate = gtk_tree_view_size_allocate;
widget_class->draw = gtk_tree_view_draw;
widget_class->expose_event = gtk_tree_view_expose;
- // widget_class->key_press_event = gtk_tree_view_key_press;
widget_class->motion_notify_event = gtk_tree_view_motion;
widget_class->enter_notify_event = gtk_tree_view_enter_notify;
widget_class->leave_notify_event = gtk_tree_view_leave_notify;
GtkRBNode *node, *last_node = NULL;
GtkRBNode *cursor = NULL;
GtkRBTree *cursor_tree = NULL, *last_tree = NULL;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
GtkCellRenderer *cell;
gint new_y;
gint y_offset, x_offset, cell_offset;
path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
tree,
node);
- tree_node = gtk_tree_model_get_node (tree_view->priv->model, path);
+ gtk_tree_model_get_iter (tree_view->priv->model,
+ &iter,
+ path);
depth = gtk_tree_path_get_depth (path);
gtk_tree_path_free (path);
cell = column->cell;
gtk_tree_view_column_set_cell_data (column,
tree_view->priv->model,
- tree_node);
+ &iter);
background_area.x = cell_offset;
background_area.width = TREE_VIEW_COLUMN_SIZE (column);
y_offset += max_height;
if (node->children)
{
+ GtkTreeIter parent = iter;
+ gboolean has_child;
+
tree = node->children;
node = tree->root;
while (node->left != tree->nil)
node = node->left;
- tree_node = gtk_tree_model_node_children (tree_view->priv->model, tree_node);
+ has_child = gtk_tree_model_iter_children (tree_view->priv->model,
+ &iter,
+ &parent);
cell = gtk_tree_view_get_column (tree_view, 0)->cell;
depth++;
/* Sanity Check! */
- TREE_VIEW_INTERNAL_ASSERT (tree_node != NULL, FALSE);
+ TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
}
else
{
node = _gtk_rbtree_next (tree, node);
if (node != NULL)
{
- gtk_tree_model_node_next (tree_view->priv->model, &tree_node);
+ gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
cell = gtk_tree_view_get_column (tree_view, 0)->cell;
done = TRUE;
/* Sanity Check! */
- TREE_VIEW_INTERNAL_ASSERT (tree_node != NULL, FALSE);
+ TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
}
else
{
+ GtkTreeIter parent_iter = iter;
+ gboolean has_parent;
+
node = tree->parent_node;
tree = tree->parent_tree;
if (tree == NULL)
- /* we've run out of tree. It's okay though, as we'd only break
- * out of the while loop below. */
+ /* we've run out of tree. It's okay to return though, as
+ * we'd only break out of the while loop below. */
return TRUE;
- tree_node = gtk_tree_model_node_parent (tree_view->priv->model, tree_node);
+ has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
+ &iter,
+ &parent_iter);
depth--;
/* Sanity check */
- TREE_VIEW_INTERNAL_ASSERT (tree_node != NULL, FALSE);
+ TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
}
}
while (!done);
{
GtkTreeViewColumn *column = list->data;
GtkCellRenderer *cell;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
if (!column->visible)
continue;
continue;
}
- tree_node = gtk_tree_model_get_node (tree_view->priv->model,
- path);
+ gtk_tree_model_get_iter (tree_view->priv->model,
+ &iter,
+ path);
gtk_tree_view_column_set_cell_data (column,
tree_view->priv->model,
- tree_node);
+ &iter);
path_string = gtk_tree_path_to_string (path);
if (gtk_cell_renderer_event (cell,
if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
{
GtkTreePath *path;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
/* Actually activate the node */
if (tree_view->priv->button_pressed_node->children == NULL)
{
+ GtkTreeIter child;
path = _gtk_tree_view_find_path (GTK_TREE_VIEW (widget),
tree_view->priv->button_pressed_tree,
tree_view->priv->button_pressed_node);
tree_view->priv->button_pressed_node->children = _gtk_rbtree_new ();
tree_view->priv->button_pressed_node->children->parent_tree = tree_view->priv->button_pressed_tree;
tree_view->priv->button_pressed_node->children->parent_node = tree_view->priv->button_pressed_node;
- tree_node = gtk_tree_model_get_node (tree_view->priv->model, path);
- tree_node = gtk_tree_model_node_children (tree_view->priv->model, tree_node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
gtk_tree_view_build_tree (tree_view,
tree_view->priv->button_pressed_node->children,
- tree_node,
+ &child,
gtk_tree_path_get_depth (path) + 1,
FALSE,
GTK_WIDGET_REALIZED (widget));
path = _gtk_tree_view_find_path (GTK_TREE_VIEW (widget),
tree_view->priv->button_pressed_node->children,
tree_view->priv->button_pressed_node->children->root);
- tree_node = gtk_tree_model_get_node (tree_view->priv->model, path);
+ gtk_tree_model_get_iter (tree_view->priv->model,
+ &iter,
+ path);
gtk_tree_view_discover_dirty (GTK_TREE_VIEW (widget),
tree_view->priv->button_pressed_node->children,
- tree_node,
+ &iter,
gtk_tree_path_get_depth (path));
_gtk_rbtree_remove (tree_view->priv->button_pressed_node->children);
}
*/
static void
-gtk_tree_view_node_changed (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeNode tree_node,
- gpointer data)
+gtk_tree_view_changed (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *)data;
GtkRBTree *tree;
g_return_if_fail (path != NULL || node != NULL);
if (path == NULL)
- path = gtk_tree_model_get_path (model, tree_node);
- else if (tree_node == NULL)
- tree_node = gtk_tree_model_get_node (model, path);
+ path = gtk_tree_model_get_path (model, iter);
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, iter, path);
if (_gtk_tree_view_find_node (tree_view,
path,
/* We aren't actually showing the node */
return;
- dirty_marked = gtk_tree_view_discover_dirty_node (tree_view,
- tree_node,
+ dirty_marked = gtk_tree_view_discover_dirty_iter (tree_view,
+ iter,
gtk_tree_path_get_depth (path),
&height);
}
static void
-gtk_tree_view_node_inserted (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeNode tree_node,
- gpointer data)
+gtk_tree_view_inserted (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *) data;
gint *indices;
gint i = 0;
tmptree = tree = tree_view->priv->tree;
- g_return_if_fail (path != NULL || tree_node != NULL);
+ g_return_if_fail (path != NULL || iter != NULL);
if (path == NULL)
- path = gtk_tree_model_get_path (model, tree_node);
- else if (tree_node == NULL)
- tree_node = gtk_tree_model_get_node (model, path);
+ path = gtk_tree_model_get_path (model, iter);
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, iter, path);
depth = gtk_tree_path_get_depth (path);
indices = gtk_tree_path_get_indices (path);
GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
tree,
tmpnode);
- gtk_tree_view_node_child_toggled (model, tmppath, NULL, data);
+ gtk_tree_view_child_toggled (model, tmppath, NULL, data);
gtk_tree_path_free (tmppath);
return;
}
}
}
- max_height = gtk_tree_view_insert_node_height (tree_view,
+ max_height = gtk_tree_view_insert_iter_height (tree_view,
tree,
- tree_node,
+ iter,
depth);
if (indices[depth - 1] == 0)
{
}
static void
-gtk_tree_view_node_child_toggled (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeNode tree_node,
- gpointer data)
+gtk_tree_view_child_toggled (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *)data;
+ GtkTreeIter real_iter;
gboolean has_child;
GtkRBTree *tree;
GtkRBNode *node;
g_return_if_fail (path != NULL || node != NULL);
+ if (iter)
+ real_iter = *iter;
+
if (path == NULL)
- path = gtk_tree_model_get_path (model, tree_node);
- else if (tree_node == NULL)
- tree_node = gtk_tree_model_get_node (model, path);
+ path = gtk_tree_model_get_path (model, iter);
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, &real_iter, path);
if (_gtk_tree_view_find_node (tree_view,
path,
/* We aren't actually showing the node */
return;
- has_child = gtk_tree_model_node_has_child (model, tree_node);
+ has_child = gtk_tree_model_iter_has_child (model, &real_iter);
/* Sanity check.
*/
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
}
static void
-gtk_tree_view_node_deleted (GtkTreeModel *model,
- GtkTreePath *path,
- gpointer data)
+gtk_tree_view_deleted (GtkTreeModel *model,
+ GtkTreePath *path,
+ gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *)data;
GtkRBTree *tree;
/* Internal tree functions */
static gint
-gtk_tree_view_insert_node_height (GtkTreeView *tree_view,
+gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth)
{
GtkTreeViewColumn *column;
}
cell = column->cell;
- gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, node);
+ gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, &height);
max_height = MAX (max_height, TREE_VIEW_VERTICAL_SEPERATOR + height);
static void
gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth,
gboolean recurse,
gboolean calc_bounds)
{
GtkRBNode *temp = NULL;
- GtkTreeNode child;
gint max_height;
- if (!node)
+ if (gtk_tree_model_iter_invalid (tree_view->priv->model, iter))
return;
+
do
{
max_height = 0;
if (calc_bounds)
- max_height = gtk_tree_view_insert_node_height (tree_view,
+ max_height = gtk_tree_view_insert_iter_height (tree_view,
tree,
- node,
+ iter,
depth);
temp = _gtk_rbtree_insert_after (tree, temp, max_height);
if (recurse)
{
- child = gtk_tree_model_node_children (tree_view->priv->model, node);
- if (child != NULL)
+ GtkTreeIter child;
+
+ if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter));
{
temp->children = _gtk_rbtree_new ();
temp->children->parent_tree = tree;
temp->children->parent_node = temp;
- gtk_tree_view_build_tree (tree_view, temp->children, child, depth + 1, recurse, calc_bounds);
+ gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse, calc_bounds);
}
}
- if (gtk_tree_model_node_has_child (tree_view->priv->model, node))
+ if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
{
if ((temp->flags>K_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
temp->flags ^= GTK_RBNODE_IS_PARENT;
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
}
}
- while (gtk_tree_model_node_next (tree_view->priv->model, &node));
+ while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
}
static void
gtk_tree_view_calc_size (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth)
{
GtkRBNode *temp = tree->root;
- GtkTreeNode child;
+ GtkTreeIter child;
GtkCellRenderer *cell;
GList *list;
GtkTreeViewColumn *column;
gint i;
/* FIXME: Make this function robust against internal inconsistencies! */
- if (!node)
+ if (gtk_tree_model_iter_invalid (tree_view->priv->model, iter))
return;
+
TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
while (temp->left != tree->nil)
if (!column->visible)
continue;
- gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, node);
+ gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
cell = column->cell;
gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, &height);
max_height = MAX (max_height, TREE_VIEW_VERTICAL_SEPERATOR + height);
column->size = MAX (column->size, width);
}
_gtk_rbtree_node_set_height (tree, temp, max_height);
- child = gtk_tree_model_node_children (tree_view->priv->model, node);
- if (child != NULL && temp->children != NULL)
- gtk_tree_view_calc_size (tree_view, temp->children, child, depth + 1);
+ if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
+ temp->children != NULL)
+ gtk_tree_view_calc_size (tree_view, temp->children, &child, depth + 1);
temp = _gtk_rbtree_next (tree, temp);
}
- while (gtk_tree_model_node_next (tree_view->priv->model, &node));
+ while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
}
static gboolean
-gtk_tree_view_discover_dirty_node (GtkTreeView *tree_view,
- GtkTreeNode node,
+gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
+ GtkTreeIter *iter,
gint depth,
gint *height)
{
gint retval = FALSE;
gint tmpheight;
- /* Do stuff with node */
if (height)
*height = 0;
continue;
cell = column->cell;
- gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, node);
+ gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
if (height)
{
static void
gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
GtkRBTree *tree,
- GtkTreeNode node,
+ GtkTreeIter *iter,
gint depth)
{
GtkRBNode *temp = tree->root;
GtkTreeViewColumn *column;
GList *list;
- GtkTreeNode child;
+ GtkTreeIter child;
gboolean is_all_dirty;
/* FIXME: Make this function robust against internal inconsistencies! */
- if (!node)
+ if (gtk_tree_model_iter_invalid (tree_view->priv->model,
+ iter))
return;
+
TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
while (temp->left != tree->nil)
break;
}
}
+
if (is_all_dirty)
return;
- gtk_tree_view_discover_dirty_node (tree_view,
- node,
+ gtk_tree_view_discover_dirty_iter (tree_view,
+ iter,
depth,
FALSE);
- child = gtk_tree_model_node_children (tree_view->priv->model, node);
- if (child != NULL && temp->children != NULL)
- gtk_tree_view_discover_dirty (tree_view, temp->children, child, depth + 1);
+ if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
+ temp->children != NULL)
+ gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
temp = _gtk_rbtree_next (tree, temp);
}
- while (gtk_tree_model_node_next (tree_view->priv->model, &node));
+ while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
}
gtk_tree_view_check_dirty (GtkTreeView *tree_view)
{
GtkTreePath *path;
- GtkTreeNode tree_node;
gboolean dirty = FALSE;
GList *list;
GtkTreeViewColumn *column;
path = gtk_tree_path_new_root ();
if (path != NULL)
{
- tree_node = gtk_tree_model_get_node (tree_view->priv->model, path);
+ GtkTreeIter iter;
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
gtk_tree_path_free (path);
- gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, tree_node, 1);
+ gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, &iter, 1);
_gtk_tree_view_set_size (tree_view, -1, -1);
}
static void
gtk_tree_view_create_button (GtkTreeView *tree_view,
- gint i)
+ gint i)
{
GtkWidget *button;
GtkTreeViewColumn *column;
if (GTK_TREE_VIEW_COLUMN (list->data)->button == widget)
break;
- // gtk_signal_emit (GTK_OBJECT (clist), clist_signals[CLICK_COLUMN], i);
+ /* FIXME:
+ * gtk_signal_emit (GTK_OBJECT (clist), clist_signals[CLICK_COLUMN], i); */
}
/* Make sure the node is visible vertically */
gtk_tree_view_set_model_realized (GtkTreeView *tree_view)
{
GtkTreePath *path;
- GtkTreeNode node;
+ GtkTreeIter iter;
tree_view->priv->tree = _gtk_rbtree_new ();
gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
- "node_changed",
- gtk_tree_view_node_changed,
+ "changed",
+ gtk_tree_view_changed,
tree_view);
gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
- "node_inserted",
- gtk_tree_view_node_inserted,
+ "inserted",
+ gtk_tree_view_inserted,
tree_view);
gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
- "node_child_toggled",
- gtk_tree_view_node_child_toggled,
+ "child_toggled",
+ gtk_tree_view_child_toggled,
tree_view);
gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
- "node_deleted",
- gtk_tree_view_node_deleted,
+ "deleted",
+ gtk_tree_view_deleted,
tree_view);
if (tree_view->priv->column == NULL)
if (path == NULL)
return;
- node = gtk_tree_model_get_node (tree_view->priv->model, path);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
gtk_tree_path_free (path);
- gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, node, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
+ gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
gtk_tree_view_create_buttons (tree_view);
GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
{
gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
- gtk_tree_view_node_changed,
+ gtk_tree_view_changed,
tree_view);
gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
- gtk_tree_view_node_inserted,
+ gtk_tree_view_inserted,
tree_view);
gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
- gtk_tree_view_node_child_toggled,
+ gtk_tree_view_child_toggled,
tree_view);
gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
- gtk_tree_view_node_deleted,
+ gtk_tree_view_deleted,
tree_view);
_gtk_rbtree_free (tree_view->priv->tree);
}
}
}
+/**
+ * gtk_tree_view_get_path_at_pos:
+ * @tree_view: A #GtkTreeView.
+ * @window: The #GtkWindow to check against.
+ * @x: The x position to be identified.
+ * @y: The y position to be identified.
+ * @path: A pointer to a #GtkTreePath pointer to be filled in, or NULL
+ * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or NULL
+ *
+ * Finds the path at the point (@x, @y) relative to @window. If @window is
+ * NULL, then the point is found relative to the widget coordinates. This
+ * function is expected to be called after an event, with event->window being
+ * passed in as @window. It is primarily for things like popup menus. If @path
+ * is non-NULL, then it will be filled with the #GtkTreePath at that point.
+ * This path should be freed with #gtk_tree_path_free. If @column is non-NULL,
+ * then it will be filled with the column at that point.
+ *
+ * Return value: TRUE if a row exists at that coordinate.
+ **/
+gboolean
+gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
+ GdkWindow *window,
+ gint x,
+ gint y,
+ GtkTreePath **path,
+ GtkTreeViewColumn **column)
+
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ g_return_val_if_fail (tree_view != NULL, FALSE);
+ g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
+ g_return_val_if_fail (x >= 0, FALSE);
+ g_return_val_if_fail (y >= 0, FALSE);
+ g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
+
+ if (window)
+ g_return_val_if_fail (window == tree_view->priv->bin_window, FALSE);
+
+ if (path)
+ *path = NULL;
+ if (column)
+ *column = NULL;
+
+ if (x > tree_view->priv->hadjustment->upper)
+ return FALSE;
+
+ if (column)
+ {
+ GtkTreeViewColumn *tmp_column;
+ GtkTreeViewColumn *last_column = NULL;
+ GList *list;
+
+ for (list = tree_view->priv->column; list; list = list->next)
+ {
+ tmp_column = list->data;
+
+ if (tmp_column->visible == FALSE)
+ continue;
+
+ last_column = tmp_column;
+ if (x <= tmp_column->size)
+ {
+ *column = tmp_column;
+ break;
+ }
+ x -= tmp_column->size;
+ }
+
+ if (*column == NULL)
+ *column = last_column;
+ }
+
+ if (window)
+ {
+ _gtk_rbtree_find_offset (tree_view->priv->tree,
+ y - TREE_VIEW_HEADER_HEIGHT (tree_view),
+ &tree, &node);
+ }
+ else
+ {
+ if (y < TREE_VIEW_HEADER_HEIGHT (tree_view))
+ return FALSE;
+
+ _gtk_rbtree_find_offset (tree_view->priv->tree, y - TREE_VIEW_HEADER_HEIGHT (tree_view) +
+ tree_view->priv->vadjustment->value,
+ &tree, &node);
+ }
+
+ if (tree == NULL)
+ return FALSE;
+
+ if (path)
+ *path = _gtk_tree_view_find_path (tree_view, tree, node);
+
+ return TRUE;
+}
+
static void
gtk_tree_view_expand_all_helper (GtkRBTree *tree,
GtkRBNode *node,
else if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT && node->children == NULL)
{
GtkTreePath *path;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
+ GtkTreeIter child;
node->children = _gtk_rbtree_new ();
node->children->parent_tree = tree;
node->children->parent_node = node;
path = _gtk_tree_view_find_path (tree_view, tree, node);
- tree_node = gtk_tree_model_get_node (tree_view->priv->model, path);
- tree_node = gtk_tree_model_node_children (tree_view->priv->model, tree_node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
gtk_tree_view_build_tree (tree_view,
node->children,
- tree_node,
+ &child,
gtk_tree_path_get_depth (path) + 1,
TRUE,
GTK_WIDGET_REALIZED (tree_view));
static void
gtk_tree_view_collapse_all_helper (GtkRBTree *tree,
GtkRBNode *node,
- gpointer data)
+ gpointer data)
{
if (node->children)
{
GtkTreePath *path;
- GtkTreeNode tree_node;
+ GtkTreeIter iter;
path = _gtk_tree_view_find_path (GTK_TREE_VIEW (data),
node->children,
node->children->root);
- tree_node = gtk_tree_model_get_node (GTK_TREE_VIEW (data)->priv->model, path);
+ gtk_tree_model_get_iter (GTK_TREE_VIEW (data)->priv->model,
+ &iter,
+ path);
gtk_tree_view_discover_dirty (GTK_TREE_VIEW (data),
node->children,
- tree_node,
+ &iter,
gtk_tree_path_get_depth (path));
_gtk_rbtree_remove (node->children);
gtk_tree_path_free (path);
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
gint (*expand_row) (GtkTreeView *tree_view,
- GtkTreeNode node);
+ GtkTreeIter *iter);
};
-/* Creators */
GtkType gtk_tree_view_get_type (void);
GtkWidget *gtk_tree_view_new (void);
-GtkWidget *gtk_tree_view_new_with_model (GtkTreeModel *model);
-GtkTreeModel *gtk_tree_view_get_model (GtkTreeView *tree_view);
-void gtk_tree_view_set_model (GtkTreeView *tree_view,
- GtkTreeModel *tree_model);
-GtkTreeSelection *gtk_tree_view_get_selection (GtkTreeView *tree_view);
-GtkAdjustment *gtk_tree_view_get_hadjustment (GtkTreeView *layout);
-void gtk_tree_view_set_hadjustment (GtkTreeView *layout,
- GtkAdjustment *adjustment);
-GtkAdjustment *gtk_tree_view_get_vadjustment (GtkTreeView *layout);
-void gtk_tree_view_set_vadjustment (GtkTreeView *layout,
- GtkAdjustment *adjustment);
-gboolean gtk_tree_view_get_headers_visible (GtkTreeView *tree_view);
-void gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
- gboolean headers_visible);
-void gtk_tree_view_columns_autosize (GtkTreeView *tree_view);
-void gtk_tree_view_set_headers_active (GtkTreeView *tree_view,
- gboolean active);
-gint gtk_tree_view_append_column (GtkTreeView *tree_view,
- GtkTreeViewColumn *column);
-gint gtk_tree_view_remove_column (GtkTreeView *tree_view,
- GtkTreeViewColumn *column);
-gint gtk_tree_view_insert_column (GtkTreeView *tree_view,
- GtkTreeViewColumn *column,
- gint position);
-GtkTreeViewColumn *gtk_tree_view_get_column (GtkTreeView *tree_view,
- gint n);
+GtkWidget *gtk_tree_view_new_with_model (GtkTreeModel *model);
+
+GtkTreeModel *gtk_tree_view_get_model (GtkTreeView *tree_view);
+void gtk_tree_view_set_model (GtkTreeView *tree_view,
+ GtkTreeModel *tree_model);
+GtkTreeSelection *gtk_tree_view_get_selection (GtkTreeView *tree_view);
+GtkAdjustment *gtk_tree_view_get_hadjustment (GtkTreeView *layout);
+void gtk_tree_view_set_hadjustment (GtkTreeView *layout,
+ GtkAdjustment *adjustment);
+GtkAdjustment *gtk_tree_view_get_vadjustment (GtkTreeView *layout);
+void gtk_tree_view_set_vadjustment (GtkTreeView *layout,
+ GtkAdjustment *adjustment);
+gboolean gtk_tree_view_get_headers_visible (GtkTreeView *tree_view);
+void gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
+ gboolean headers_visible);
+void gtk_tree_view_columns_autosize (GtkTreeView *tree_view);
+void gtk_tree_view_set_headers_active (GtkTreeView *tree_view,
+ gboolean active);
+gint gtk_tree_view_append_column (GtkTreeView *tree_view,
+ GtkTreeViewColumn *column);
+gint gtk_tree_view_remove_column (GtkTreeView *tree_view,
+ GtkTreeViewColumn *column);
+gint gtk_tree_view_insert_column (GtkTreeView *tree_view,
+ GtkTreeViewColumn *column,
+ gint position);
+GtkTreeViewColumn *gtk_tree_view_get_column (GtkTreeView *tree_view,
+ gint n);
/* Actions */
-void gtk_tree_view_move_to (GtkTreeView *tree_view,
- GtkTreePath *path,
- GtkTreeViewColumn *column,
- gfloat row_align,
- gfloat col_align);
-void gtk_tree_view_expand_all (GtkTreeView *tree_view);
-void gtk_tree_view_collapse_all (GtkTreeView *tree_view);
+void gtk_tree_view_move_to (GtkTreeView *tree_view,
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gfloat row_align,
+ gfloat col_align);
+gboolean gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
+ GdkWindow *window,
+ gint x,
+ gint y,
+ GtkTreePath **path,
+ GtkTreeViewColumn **column);
+void gtk_tree_view_expand_all (GtkTreeView *tree_view);
+void gtk_tree_view_collapse_all (GtkTreeView *tree_view);
#ifdef __cplusplus
void
gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
GtkTreeModel *tree_model,
- GtkTreeNode tree_node)
+ GtkTreeIter *iter)
{
GSList *list;
GValue value = { 0, };
if (tree_column->func && (* tree_column->func) (tree_column,
tree_model,
- tree_node,
+ iter,
tree_column->func_data))
return;
while (list && list->next)
{
- gtk_tree_model_node_get_value (tree_model,
- tree_node,
+ gtk_tree_model_iter_get_value (tree_model,
+ iter,
GPOINTER_TO_INT (list->next->data),
&value);
g_object_set_param (cell, (gchar *) list->data, &value);
typedef gboolean (* GtkTreeViewColumnFunc) (GtkTreeViewColumn *tree_column,
GtkTreeModel *tree_model,
- GtkTreeNode tree_node,
+ GtkTreeIter *iter,
gpointer data);
struct _GtkTreeViewColumn
...);
void gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
GtkTreeModel *tree_model,
- GtkTreeNode tree_node);
+ GtkTreeIter *iter);
void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
gboolean visible);
gboolean gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column);
static void
selection_changed (GtkTreeSelection *selection,
- GtkWidget *button)
+ GtkWidget *button)
{
- if (gtk_tree_selection_get_selected (selection))
+ if (gtk_tree_selection_get_selected (selection,
+ NULL))
gtk_widget_set_sensitive (button, TRUE);
else
gtk_widget_set_sensitive (button, FALSE);
}
-static GtkTreeNode *
-node_new ()
+static void
+node_set (GtkTreeIter *iter)
{
- static GValue value = {0, };
static gint i = 0;
gchar *str;
- GtkTreeNode *node = gtk_tree_store_node_new ();
- g_value_init (&value, G_TYPE_STRING);
str = g_strdup_printf ("FOO: %d", i++);
- g_value_set_string (&value, str);
+ gtk_tree_store_iter_set (GTK_TREE_STORE (model), iter, 0, str, -1);
g_free (str);
- gtk_tree_store_node_set_cell (GTK_TREE_STORE (model), node, 0, &value);
- g_value_unset (&value);
- return node;
}
static void
-node_remove (GtkWidget *button, GtkTreeView *tree_view)
+iter_remove (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_remove (GTK_TREE_STORE (model),
- selected);
+ GtkTreeIter selected;
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_remove (GTK_TREE_STORE (model),
+ &selected);
+ }
}
static void
-node_insert (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert (GtkWidget *button, GtkTreeView *tree_view)
{
GtkWidget *entry;
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
+ GtkTreeIter iter;
+ GtkTreeIter selected;
entry = gtk_object_get_user_data (GTK_OBJECT (button));
- gtk_tree_store_node_insert (GTK_TREE_STORE (model),
- selected,
- atoi (gtk_entry_get_text (GTK_ENTRY (entry))),
- node_new ());
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert (GTK_TREE_STORE (model),
+ &iter,
+ &selected,
+ atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ }
+ else
+ {
+ gtk_tree_store_iter_insert (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ }
+
+ node_set (&iter);
}
static void
-node_insert_before (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert_before (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_insert_before (GTK_TREE_STORE (model),
- NULL,
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
-node_insert_after (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert_after (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_insert_after (GTK_TREE_STORE (model),
- NULL,
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+
+ node_set (&iter);
}
static void
-node_prepend (GtkWidget *button, GtkTreeView *tree_view)
+iter_prepend (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_prepend (GTK_TREE_STORE (model),
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_prepend (GTK_TREE_STORE (model),
+ &iter,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_prepend (GTK_TREE_STORE (model),
+ &iter,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
-node_append (GtkWidget *button, GtkTreeView *tree_view)
+iter_append (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_append (GTK_TREE_STORE (model),
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model),
+ &iter,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model),
+ &iter,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL);
/* buttons */
- button = gtk_button_new_with_label ("gtk_tree_store_node_remove");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_remove");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_remove, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert");
hbox = gtk_hbox_new (FALSE, 8);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_object_set_user_data (GTK_OBJECT (button), entry);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert_before");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_before");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert_before, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert_after");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_after");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert_after, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_prepend");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_prepend");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_prepend, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view);
- button = gtk_button_new_with_label ("gtk_tree_store_node_append");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_append");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_append, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view);
/* The selected column */
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("nodes", cell, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column));
+ /* A few to start */
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+
/* Show it all */
gtk_widget_show_all (window);
}
make_window ();
make_window ();
- /* A few to start */
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
-
gtk_main ();
return 0;
static void
selection_changed (GtkTreeSelection *selection,
- GtkWidget *button)
+ GtkWidget *button)
{
- if (gtk_tree_selection_get_selected (selection))
+ if (gtk_tree_selection_get_selected (selection,
+ NULL))
gtk_widget_set_sensitive (button, TRUE);
else
gtk_widget_set_sensitive (button, FALSE);
}
-static GtkTreeNode *
-node_new ()
+static void
+node_set (GtkTreeIter *iter)
{
- static GValue value = {0, };
static gint i = 0;
gchar *str;
- GtkTreeNode *node = gtk_tree_store_node_new ();
- g_value_init (&value, G_TYPE_STRING);
str = g_strdup_printf ("FOO: %d", i++);
- g_value_set_string (&value, str);
+ gtk_tree_store_iter_set (GTK_TREE_STORE (model), iter, 0, str, -1);
g_free (str);
- gtk_tree_store_node_set_cell (GTK_TREE_STORE (model), node, 0, &value);
- g_value_unset (&value);
- return node;
}
static void
-node_remove (GtkWidget *button, GtkTreeView *tree_view)
+iter_remove (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_remove (GTK_TREE_STORE (model),
- selected);
+ GtkTreeIter selected;
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_remove (GTK_TREE_STORE (model),
+ &selected);
+ }
}
static void
-node_insert (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert (GtkWidget *button, GtkTreeView *tree_view)
{
GtkWidget *entry;
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
+ GtkTreeIter iter;
+ GtkTreeIter selected;
entry = gtk_object_get_user_data (GTK_OBJECT (button));
- gtk_tree_store_node_insert (GTK_TREE_STORE (model),
- selected,
- atoi (gtk_entry_get_text (GTK_ENTRY (entry))),
- node_new ());
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert (GTK_TREE_STORE (model),
+ &iter,
+ &selected,
+ atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ }
+ else
+ {
+ gtk_tree_store_iter_insert (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
+ }
+
+ node_set (&iter);
}
static void
-node_insert_before (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert_before (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_insert_before (GTK_TREE_STORE (model),
- NULL,
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
-node_insert_after (GtkWidget *button, GtkTreeView *tree_view)
+iter_insert_after (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_insert_after (GTK_TREE_STORE (model),
- NULL,
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model),
+ &iter,
+ NULL,
+ &selected);
+ }
+
+ node_set (&iter);
}
static void
-node_prepend (GtkWidget *button, GtkTreeView *tree_view)
+iter_prepend (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_prepend (GTK_TREE_STORE (model),
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_prepend (GTK_TREE_STORE (model),
+ &iter,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_prepend (GTK_TREE_STORE (model),
+ &iter,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
-node_append (GtkWidget *button, GtkTreeView *tree_view)
+iter_append (GtkWidget *button, GtkTreeView *tree_view)
{
- GtkTreeNode *selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)));
- gtk_tree_store_node_append (GTK_TREE_STORE (model),
- selected,
- node_new ());
+ GtkTreeIter iter;
+ GtkTreeIter selected;
+
+ if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+ &selected))
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model),
+ &iter,
+ &selected);
+ }
+ else
+ {
+ gtk_tree_store_iter_append (GTK_TREE_STORE (model),
+ &iter,
+ NULL);
+ }
+
+ node_set (&iter);
}
static void
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL);
/* buttons */
- button = gtk_button_new_with_label ("gtk_tree_store_node_remove");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_remove");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_remove, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert");
hbox = gtk_hbox_new (FALSE, 8);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_object_set_user_data (GTK_OBJECT (button), entry);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert_before");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_before");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert_before, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_insert_after");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_after");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_insert_after, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view);
gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed",
selection_changed,
button);
gtk_widget_set_sensitive (button, FALSE);
- button = gtk_button_new_with_label ("gtk_tree_store_node_prepend");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_prepend");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_prepend, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view);
- button = gtk_button_new_with_label ("gtk_tree_store_node_append");
+ button = gtk_button_new_with_label ("gtk_tree_store_iter_append");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", node_append, tree_view);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view);
/* The selected column */
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("nodes", cell, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column));
+ /* A few to start */
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+ iter_prepend (NULL, GTK_TREE_VIEW (tree_view));
+
/* Show it all */
gtk_widget_show_all (window);
}
make_window ();
make_window ();
- /* A few to start */
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
- gtk_tree_store_node_append (GTK_TREE_STORE (model), NULL, node_new ());
-
gtk_main ();
return 0;
projects / ~andy / gtk / commitdiff