Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Got rid of GtkTreeNode, and changed it to GtkTreeIter. Added iterators

Browse Source 
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.
This commit is contained in:
Jonathan Blandford
2000-10-26 00:36:47 +00:00
committed by Jonathan Blandford
parent aaee910027
commit ef7b510f46
27 changed files with 1928 additions and 1052 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
ChangeLog
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-0
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-10
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-2
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-4
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-6
View File

@@ -1,3 +1,24 @@
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

21
ChangeLog.pre-2-8
View File

@@ -1,3 +1,24 @@
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

156
demos/gtk-demo/main.c
View File

@@ -9,9 +9,16 @@
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)
@@ -60,7 +67,7 @@ read_line (FILE *stream, GString *str)
}
void
load_file (Demo *demo)
load_file (const gchar *filename)
{
FILE *file;
GtkTextIter start, end;
@@ -68,10 +75,11 @@ load_file (Demo *demo)
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);
@@ -79,10 +87,10 @@ load_file (Demo *demo)
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;
}
@@ -184,41 +192,65 @@ load_file (Demo *demo)
}
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)
{
@@ -253,14 +285,62 @@ create_text (GtkTextBuffer **buffer,
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);
@@ -271,11 +351,8 @@ main (int argc, char **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);
@@ -304,19 +381,8 @@ main (int argc, char **argv)
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 ();

156
demos/testgtk/main.c
View File

@@ -9,9 +9,16 @@
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)
@@ -60,7 +67,7 @@ read_line (FILE *stream, GString *str)
}
void
load_file (Demo *demo)
load_file (const gchar *filename)
{
FILE *file;
GtkTextIter start, end;
@@ -68,10 +75,11 @@ load_file (Demo *demo)
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);
@@ -79,10 +87,10 @@ load_file (Demo *demo)
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;
}
@@ -184,41 +192,65 @@ load_file (Demo *demo)
}
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)
{
@@ -253,14 +285,62 @@ create_text (GtkTextBuffer **buffer,
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);
@@ -271,11 +351,8 @@ main (int argc, char **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);
@@ -304,19 +381,8 @@ main (int argc, char **argv)
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 ();

257
gtk/gtkliststore.c
View File

@@ -24,12 +24,12 @@
#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
};
@@ -39,27 +39,27 @@ static void gtk_list_store_init (GtkListStore *list_st
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
@@ -105,38 +105,38 @@ gtk_list_store_class_init (GtkListStoreClass *class)
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);
@@ -149,15 +149,15 @@ static void
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
@@ -246,19 +246,19 @@ gtk_list_store_get_n_columns (GtkTreeModel *tree_model)
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;
@@ -269,7 +269,7 @@ gtk_list_store_get_path (GtkTreeModel *tree_model,
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)
@@ -282,8 +282,8 @@ gtk_list_store_get_path (GtkTreeModel *tree_model,
}
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)
{
@@ -292,74 +292,74 @@ gtk_list_store_node_get_value (GtkTreeModel *tree_model,
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;
}
@@ -368,8 +368,8 @@ gtk_list_store_node_new (void)
* 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)
{
@@ -378,16 +378,16 @@ gtk_list_store_node_set_cell (GtkListStore *list_store,
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;
}
@@ -396,9 +396,9 @@ gtk_list_store_node_set_cell (GtkListStore *list_store,
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
@@ -414,104 +414,105 @@ gtk_list_store_node_set_cell (GtkListStore *list_store,
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

49
gtk/gtkliststore.h
View File

@@ -40,7 +40,8 @@ struct _GtkListStore
GtkObject parent;
/*< private >*/
GtkTreeNode root;
gint stamp;
gpointer root;
gint n_columns;
GType *column_headers;
};
@@ -51,17 +52,17 @@ struct _GtkListStoreClass
/* 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);
@@ -73,23 +74,23 @@ void gtk_list_store_set_n_columns (GtkListStore *store,
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);

3
gtk/gtkmodelsimple.c
View File

@@ -16,7 +16,7 @@
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#if 0
#include "gtkmodelsimple.h"
#include "gtksignal.h"
enum {
@@ -418,3 +418,4 @@ gtk_model_simple_node_deleted (GtkModelSimple *simple,
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_deleted", path, node);
}
#endif

13
gtk/gtkmodelsimple.h
View File

@@ -26,13 +26,14 @@
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;
@@ -47,16 +48,16 @@ struct _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);
};
@@ -78,7 +79,7 @@ void gtk_model_simple_node_deleted (GtkModelSimple *simple,
GtkTreeNode node);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */

7
gtk/gtkrbtree.c
View File

@@ -661,6 +661,13 @@ _gtk_rbtree_find_offset (GtkRBTree *tree,
{
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 ||

9
gtk/gtktreedatalist.c
View File

@@ -152,6 +152,9 @@ gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
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;
@@ -161,6 +164,9 @@ gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
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;
}
}
@@ -185,6 +191,9 @@ gtk_tree_data_list_value_to_node (GtkTreeDataList *list,
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;

239
gtk/gtktreemodel.c
View File

@@ -393,169 +393,240 @@ gint
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.
**/
GtkTreeNode
gtk_tree_model_node_children (GtkTreeModel *tree_model,
GtkTreeNode node)
{
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);
}
/**
* gtk_tree_model_node_has_child:
* @tree_model: A #GtkTreeModel.
* @node: The #GtkTreeNode to test for children.
*
* Returns TRUE if @node has children, FALSE otherwise.
*
* Return value: TRUE if @node has children.
* Return value: TRUE, if @child has been set to the first child.
**/
gboolean
gtk_tree_model_node_has_child (GtkTreeModel *tree_model,
GtkTreeNode node)
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_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_children != NULL, FALSE);
return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_children) (tree_model, iter, parent);
}
/**
* gtk_tree_model_node_n_children:
* gtk_tree_model_iter_has_child:
* @tree_model: A #GtkTreeModel.
* @node: The #GtkTreeNode.
* @iter: The #GtkTreeIter to test for children.
*
* Returns the number of children that @node has.
* Returns TRUE if @iter has children, FALSE otherwise.
*
* Return value: The number of children of @node.
* Return value: TRUE if @iter has children.
**/
gboolean
gtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
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_iter_n_children:
* @tree_model: A #GtkTreeModel.
* @iter: The #GtkTreeIter.
*
* Returns the number of children that @iter has.
*
* 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);
}

172
gtk/gtktreemodel.h
View File

@@ -32,11 +32,17 @@ extern "C" {
#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;
@@ -46,92 +52,111 @@ struct _GtkTreeModelIface
* 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;
/* 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);
/* 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);
/* GtkTreeModel stuff */
GtkType gtk_tree_model_get_type (void) G_GNUC_CONST;
/* 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);
/* 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
@@ -140,4 +165,3 @@ GtkTreeNode gtk_tree_model_node_parent (GtkTreeModel *tree_model,
#endif /* __GTK_TREE_MODEL_H__ */

91
gtk/gtktreeselection.c
View File

@@ -243,26 +243,29 @@ gtk_tree_selection_get_user_data (GtkTreeSelection *selection)
* 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,
@@ -272,11 +275,11 @@ gtk_tree_selection_get_selected (GtkTreeSelection *selection)
/* 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);
}
/**
@@ -295,7 +298,7 @@ gtk_tree_selection_selected_foreach (GtkTreeSelection *selection,
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));
@@ -315,23 +318,28 @@ gtk_tree_selection_selected_foreach (GtkTreeSelection *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
{
@@ -341,24 +349,29 @@ gtk_tree_selection_selected_foreach (GtkTreeSelection *selection,
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);
@@ -440,15 +453,15 @@ gtk_tree_selection_unselect_path (GtkTreeSelection *selection,
}
/**
* 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;
@@ -456,9 +469,10 @@ gtk_tree_selection_select_node (GtkTreeSelection *selection,
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;
@@ -469,24 +483,26 @@ gtk_tree_selection_select_node (GtkTreeSelection *selection,
/**
* 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;
@@ -875,9 +891,6 @@ gtk_tree_selection_real_select_node (GtkTreeSelection *selection,
}
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*/

13
gtk/gtktreeselection.h
View File

@@ -45,7 +45,7 @@ typedef gboolean (* GtkTreeSelectionFunc) (GtkTreeSelection *selection,
GtkTreePath *path,
gpointer data);
typedef void (* GtkTreeSelectionForeachFunc) (GtkTreeModel *model,
GtkTreeNode node,
GtkTreeIter *iter,
gpointer data);
struct _GtkTreeSelection
@@ -78,7 +78,8 @@ gpointer gtk_tree_selection_get_user_data (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,
@@ -88,10 +89,10 @@ void gtk_tree_selection_select_path (GtkTreeSelection
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,

692
gtk/gtktreestore.c
View File

@@ -22,45 +22,47 @@
#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
@@ -106,38 +108,38 @@ gtk_tree_store_class_init (GtkTreeStoreClass *tree_store_class)
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);
@@ -149,47 +151,46 @@ static void
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);
@@ -250,56 +251,39 @@ gtk_tree_store_get_n_columns (GtkTreeModel *tree_model)
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);
@@ -308,13 +292,15 @@ gtk_tree_store_get_path (GtkTreeModel *tree_model,
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;
}
@@ -326,8 +312,8 @@ gtk_tree_store_get_path (GtkTreeModel *tree_model,
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)
{
@@ -336,87 +322,129 @@ gtk_tree_store_node_get_value (GtkTreeModel *tree_model,
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;
static GtkTreeNode
gtk_tree_store_node_children (GtkTreeModel *tree_model,
GtkTreeNode node)
{
return (GtkTreeNode) G_NODE (node)->children;
return (iter->tree_node != NULL);
}
static gboolean
gtk_tree_store_node_has_child (GtkTreeModel *tree_model,
GtkTreeNode node)
gtk_tree_store_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
return G_NODE (node)->children != NULL;
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_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
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);
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);
}
static GtkTreeNode
gtk_tree_store_node_parent (GtkTreeModel *tree_model,
GtkTreeNode node)
static gboolean
gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child)
{
return (GtkTreeNode) G_NODE (node)->parent;
}
iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
iter->tree_node = G_NODE (child->tree_node)->parent;
/* Public accessors */
GtkTreeNode
gtk_tree_store_node_new (void)
{
GtkTreeNode retval;
if (iter->tree_node == GTK_TREE_STORE (tree_model)->root)
{
iter->stamp = 0;
return FALSE;
}
retval = (GtkTreeNode) g_node_new (NULL);
return retval;
return TRUE;
}
/*
@@ -424,8 +452,8 @@ gtk_tree_store_node_new (void)
* 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)
{
@@ -434,10 +462,9 @@ gtk_tree_store_node_set_cell (GtkTreeStore *tree_store,
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)
{
@@ -452,9 +479,9 @@ gtk_tree_store_node_set_cell (GtkTreeStore *tree_store,
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
@@ -474,239 +501,392 @@ gtk_tree_store_node_set_cell (GtkTreeStore *tree_store,
}
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);
g_return_if_fail (model != NULL);
g_return_if_fail (GTK_IS_TREE_STORE (model));
if (parent == NULL)
parent = model->root;
if (parent->tree_node == NULL)
parent->tree_node = model->root;
g_node_insert (G_NODE (parent), position, G_NODE (node));
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);
iter->stamp = model->stamp;
iter->tree_node = g_node_new (NULL);
if (parent == NULL && sibling == NULL)
parent = model->root;
parent_node = model->root;
else if (parent == NULL)
parent_node = G_NODE (sibling->tree_node)->parent;
else
parent_node = G_NODE (parent->tree_node);
if (parent == NULL)
parent = (GtkTreeNode) G_NODE (sibling)->parent;
g_node_insert_before (parent_node,
sibling ? G_NODE (sibling->tree_node) : NULL,
G_NODE (iter->tree_node));
g_node_insert_before (G_NODE (parent), G_NODE (sibling), G_NODE (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);
iter->stamp = model->stamp;
iter->tree_node = g_node_new (NULL);
if (parent == NULL && sibling == NULL)
parent = model->root;
parent_node = model->root;
else if (parent == NULL)
parent_node = G_NODE (sibling->tree_node)->parent;
else
parent_node = G_NODE (parent->tree_node);
if (parent == NULL)
parent = (GtkTreeNode) G_NODE (sibling)->parent;
g_node_insert_after (parent_node,
sibling ? G_NODE (sibling->tree_node) : NULL,
G_NODE (iter->tree_node));
g_node_insert_after (G_NODE (parent), G_NODE (sibling), G_NODE (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;
}

121
gtk/gtktreestore.h
View File

@@ -21,6 +21,7 @@
#define __GTK_TREE_STORE_H__
#include <gtk/gtktreemodel.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
@@ -38,7 +39,9 @@ typedef struct _GtkTreeStoreClass GtkTreeStoreClass;
struct _GtkTreeStore
{
GtkObject parent;
GtkTreeNode root;
gint stamp;
gpointer root;
gint n_columns;
GType *column_headers;
};
@@ -49,62 +52,72 @@ struct _GtkTreeStoreClass
/* 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

385
gtk/gtktreeview.c
View File

@@ -95,19 +95,19 @@ static void gtk_tree_view_forall (GtkContainer *container,
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);
@@ -122,27 +122,27 @@ static gint gtk_tree_view_new_column_width (GtkTreeView *tree_view,
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,
@@ -205,7 +205,6 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
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;
@@ -686,7 +685,7 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
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;
@@ -726,7 +725,9 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
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);
@@ -786,7 +787,7 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
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);
@@ -833,16 +834,21 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
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
{
@@ -852,26 +858,31 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
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);
@@ -1151,7 +1162,7 @@ gtk_tree_view_button_press (GtkWidget *widget,
{
GtkTreeViewColumn *column = list->data;
GtkCellRenderer *cell;
GtkTreeNode tree_node;
GtkTreeIter iter;
if (!column->visible)
continue;
@@ -1179,11 +1190,12 @@ gtk_tree_view_button_press (GtkWidget *widget,
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,
@@ -1298,23 +1310,24 @@ gtk_tree_view_button_release (GtkWidget *widget,
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));
@@ -1324,11 +1337,13 @@ gtk_tree_view_button_release (GtkWidget *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);
}
@@ -1891,10 +1906,10 @@ gtk_tree_view_forall (GtkContainer *container,
*/
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;
@@ -1905,9 +1920,9 @@ gtk_tree_view_node_changed (GtkTreeModel *model,
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,
@@ -1916,8 +1931,8 @@ gtk_tree_view_node_changed (GtkTreeModel *model,
/* 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);
@@ -1937,10 +1952,10 @@ gtk_tree_view_node_changed (GtkTreeModel *model,
}
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;
@@ -1951,12 +1966,12 @@ gtk_tree_view_node_inserted (GtkTreeModel *model,
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);
@@ -1986,7 +2001,7 @@ gtk_tree_view_node_inserted (GtkTreeModel *model,
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;
}
@@ -2022,9 +2037,9 @@ gtk_tree_view_node_inserted (GtkTreeModel *model,
}
}
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)
{
@@ -2041,22 +2056,26 @@ gtk_tree_view_node_inserted (GtkTreeModel *model,
}
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,
@@ -2065,7 +2084,7 @@ gtk_tree_view_node_child_toggled (GtkTreeModel *model,
/* 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)
@@ -2099,9 +2118,9 @@ gtk_tree_view_node_child_toggled (GtkTreeModel *model,
}
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;
@@ -2165,9 +2184,9 @@ gtk_tree_view_node_deleted (GtkTreeModel *model,
/* 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;
@@ -2191,7 +2210,7 @@ gtk_tree_view_insert_node_height (GtkTreeView *tree_view,
}
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);
@@ -2210,55 +2229,56 @@ gtk_tree_view_insert_node_height (GtkTreeView *tree_view,
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&GTK_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;
@@ -2266,8 +2286,9 @@ gtk_tree_view_calc_size (GtkTreeView *tree_view,
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)
@@ -2285,7 +2306,7 @@ gtk_tree_view_calc_size (GtkTreeView *tree_view,
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);
@@ -2300,17 +2321,17 @@ gtk_tree_view_calc_size (GtkTreeView *tree_view,
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)
{
@@ -2321,7 +2342,6 @@ gtk_tree_view_discover_dirty_node (GtkTreeView *tree_view,
gint retval = FALSE;
gint tmpheight;
/* Do stuff with node */
if (height)
*height = 0;
@@ -2335,7 +2355,7 @@ gtk_tree_view_discover_dirty_node (GtkTreeView *tree_view,
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)
{
@@ -2370,18 +2390,20 @@ gtk_tree_view_discover_dirty_node (GtkTreeView *tree_view,
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)
@@ -2399,19 +2421,20 @@ gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
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));
}
@@ -2419,7 +2442,6 @@ static void
gtk_tree_view_check_dirty (GtkTreeView *tree_view)
{
GtkTreePath *path;
GtkTreeNode tree_node;
gboolean dirty = FALSE;
GList *list;
GtkTreeViewColumn *column;
@@ -2442,9 +2464,11 @@ gtk_tree_view_check_dirty (GtkTreeView *tree_view)
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);
}
@@ -2457,7 +2481,7 @@ gtk_tree_view_check_dirty (GtkTreeView *tree_view)
static void
gtk_tree_view_create_button (GtkTreeView *tree_view,
gint i)
gint i)
{
GtkWidget *button;
GtkTreeViewColumn *column;
@@ -2565,7 +2589,8 @@ gtk_tree_view_button_clicked (GtkWidget *widget,
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 */
@@ -2920,25 +2945,25 @@ static void
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)
@@ -2948,9 +2973,9 @@ gtk_tree_view_set_model_realized (GtkTreeView *tree_view)
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);
@@ -2990,16 +3015,16 @@ gtk_tree_view_set_model (GtkTreeView *tree_view,
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);
}
@@ -3487,6 +3512,105 @@ gtk_tree_view_move_to (GtkTreeView *tree_view,
}
}
/**
* 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,
@@ -3503,17 +3627,18 @@ gtk_tree_view_expand_all_helper (GtkRBTree *tree,
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));
@@ -3546,20 +3671,22 @@ gtk_tree_view_expand_all (GtkTreeView *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);

76
gtk/gtktreeview.h
View File

@@ -56,47 +56,53 @@ struct _GtkTreeViewClass
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

8
gtk/gtktreeviewcolumn.c
View File

@@ -315,7 +315,7 @@ gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
void
gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
GtkTreeModel *tree_model,
GtkTreeNode tree_node)
GtkTreeIter *iter)
{
GSList *list;
GValue value = { 0, };
@@ -327,7 +327,7 @@ gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
if (tree_column->func && (* tree_column->func) (tree_column,
tree_model,
tree_node,
iter,
tree_column->func_data))
return;
@@ -336,8 +336,8 @@ gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
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);

4
gtk/gtktreeviewcolumn.h
View File

@@ -46,7 +46,7 @@ typedef struct _GtkTreeViewColumnClass GtkTreeViewColumnClass;
typedef gboolean (* GtkTreeViewColumnFunc) (GtkTreeViewColumn *tree_column,
GtkTreeModel *tree_model,
GtkTreeNode tree_node,
GtkTreeIter *iter,
gpointer data);
struct _GtkTreeViewColumn
@@ -96,7 +96,7 @@ void gtk_tree_view_column_set_attributes (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);

191
gtk/treestoretest.c
View File

@@ -5,89 +5,160 @@ GtkObject *model;
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
@@ -123,56 +194,61 @@ make_window ()
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);
}
@@ -187,11 +263,6 @@ main (int argc, char *argv[])
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;

191
tests/treestoretest.c
View File

@@ -5,89 +5,160 @@ GtkObject *model;
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
@@ -123,56 +194,61 @@ make_window ()
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);
}
@@ -187,11 +263,6 @@ main (int argc, char *argv[])
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;