callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Not sure how this ever worked. Fixed it to use new iter stuff, and added

Browse Source 
Fri Oct 27 17:56:26 2000  Jonathan Blandford  <jrb@redhat.com>

	* gtk/gtkliststore.c: Not sure how this ever worked.  Fixed it to
	use new iter stuff, and added all the appropriate signals et al.

	* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
	code is internal to gtk only.
This commit is contained in:
Jonathan Blandford
2000-10-27 23:34:58 +00:00
committed by Jonathan Blandford
parent 2bf87de4cb
commit 0ccb3e9aed
25 changed files with 945 additions and 698 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-0
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-10
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-2
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-4
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-6
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

9
ChangeLog.pre-2-8
View File

@ -1,3 +1,11 @@
Fri Oct 27 17:56:26 2000 Jonathan Blandford <jrb@redhat.com>
* gtk/gtkliststore.c: Not sure how this ever worked. Fixed it to
use new iter stuff, and added all the appropriate signals et al.
* gtk/gtktreedatalist.h: s/gtk/_gtk to further reinforce that this
code is internal to gtk only.
2000-10-28 Tor Lillqvist <tml@iki.fi> 2000-10-28 Tor Lillqvist <tml@iki.fi>
* gtk/gtk.def * gtk/gtk.def
@ -56,7 +64,6 @@ Fri Oct 27 18:51:44 2000 Tim Janik <timj@gtk.org>
2000-10-26 Havoc Pennington <hp@redhat.com> 2000-10-26 Havoc Pennington <hp@redhat.com>
* gtk/gtkmarshal.list: add new marshallers used by the text widget * gtk/gtkmarshal.list: add new marshallers used by the text widget
* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller * gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
types types

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

@ -214,14 +214,16 @@ button_press_event_cb (GtkTreeView *tree_view,
GVoidFunc func; GVoidFunc func;
gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_store_iter_get (model, &iter, gtk_tree_store_get (GTK_TREE_STORE (model),
FUNC_COLUMN, &func, &iter,
ITALIC_COLUMN, &italic, FUNC_COLUMN, &func,
-1); ITALIC_COLUMN, &italic,
-1);
(func) (); (func) ();
gtk_tree_store_iter_set (model, &iter, gtk_tree_store_set (GTK_TREE_STORE (model),
ITALIC_COLUMN, !italic, &iter,
-1); ITALIC_COLUMN, !italic,
-1);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
@ -243,9 +245,9 @@ selection_cb (GtkTreeSelection *selection,
if (! gtk_tree_selection_get_selected (selection, &iter)) if (! gtk_tree_selection_get_selected (selection, &iter))
return; return;
gtk_tree_model_iter_get_value (model, &iter, gtk_tree_model_get_value (model, &iter,
FILENAME_COLUMN, FILENAME_COLUMN,
&value); &value);
load_file (g_value_get_string (&value)); load_file (g_value_get_string (&value));
g_value_unset (&value); g_value_unset (&value);
} }
@ -307,15 +309,15 @@ create_tree (void)
for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++) for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
gtk_tree_store_iter_set (GTK_TREE_STORE (model), gtk_tree_store_set (GTK_TREE_STORE (model),
&iter, &iter,
TITLE_COLUMN, testgtk_demos[i].title, TITLE_COLUMN, testgtk_demos[i].title,
FILENAME_COLUMN, testgtk_demos[i].filename, FILENAME_COLUMN, testgtk_demos[i].filename,
FUNC_COLUMN, testgtk_demos[i].func, FUNC_COLUMN, testgtk_demos[i].func,
ITALIC_COLUMN, FALSE, ITALIC_COLUMN, FALSE,
-1); -1);
} }
cell = gtk_cell_renderer_text_new (); cell = gtk_cell_renderer_text_new ();

38
demos/testgtk/main.c
View File

@ -214,14 +214,16 @@ button_press_event_cb (GtkTreeView *tree_view,
GVoidFunc func; GVoidFunc func;
gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_store_iter_get (model, &iter, gtk_tree_store_get (GTK_TREE_STORE (model),
FUNC_COLUMN, &func, &iter,
ITALIC_COLUMN, &italic, FUNC_COLUMN, &func,
-1); ITALIC_COLUMN, &italic,
-1);
(func) (); (func) ();
gtk_tree_store_iter_set (model, &iter, gtk_tree_store_set (GTK_TREE_STORE (model),
ITALIC_COLUMN, !italic, &iter,
-1); ITALIC_COLUMN, !italic,
-1);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
@ -243,9 +245,9 @@ selection_cb (GtkTreeSelection *selection,
if (! gtk_tree_selection_get_selected (selection, &iter)) if (! gtk_tree_selection_get_selected (selection, &iter))
return; return;
gtk_tree_model_iter_get_value (model, &iter, gtk_tree_model_get_value (model, &iter,
FILENAME_COLUMN, FILENAME_COLUMN,
&value); &value);
load_file (g_value_get_string (&value)); load_file (g_value_get_string (&value));
g_value_unset (&value); g_value_unset (&value);
} }
@ -307,15 +309,15 @@ create_tree (void)
for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++) for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
gtk_tree_store_iter_set (GTK_TREE_STORE (model), gtk_tree_store_set (GTK_TREE_STORE (model),
&iter, &iter,
TITLE_COLUMN, testgtk_demos[i].title, TITLE_COLUMN, testgtk_demos[i].title,
FILENAME_COLUMN, testgtk_demos[i].filename, FILENAME_COLUMN, testgtk_demos[i].filename,
FUNC_COLUMN, testgtk_demos[i].func, FUNC_COLUMN, testgtk_demos[i].func,
ITALIC_COLUMN, FALSE, ITALIC_COLUMN, FALSE,
-1); -1);
} }
cell = gtk_cell_renderer_text_new (); cell = gtk_cell_renderer_text_new ();

469
gtk/gtkliststore.c
View File

@ -24,7 +24,7 @@
#include "gtksignal.h" #include "gtksignal.h"
#define G_SLIST(x) ((GSList *) x) #define G_SLIST(x) ((GSList *) x)
#if 0
enum { enum {
CHANGED, CHANGED,
INSERTED, INSERTED,
@ -35,31 +35,35 @@ enum {
static guint list_store_signals[LAST_SIGNAL] = { 0 }; static guint list_store_signals[LAST_SIGNAL] = { 0 };
static void gtk_list_store_init (GtkListStore *list_store); static void gtk_list_store_init (GtkListStore *list_store);
static void gtk_list_store_class_init (GtkListStoreClass *class); static void gtk_list_store_class_init (GtkListStoreClass *class);
static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface); static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface);
static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model); static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model);
static GtkTreeIter *gtk_list_store_get_iter (GtkTreeModel *tree_model, static gboolean gtk_list_store_get_iter (GtkTreeModel *tree_model,
GtkTreePath *path); GtkTreeIter *iter,
static GtkTreePath *gtk_list_store_get_path (GtkTreeModel *tree_model, GtkTreePath *path);
GtkTreeIter *iter); static GtkTreePath *gtk_list_store_get_path (GtkTreeModel *tree_model,
static void gtk_list_store_iter_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter);
GtkTreeIter *iter, static void gtk_list_store_get_value (GtkTreeModel *tree_model,
gint column, GtkTreeIter *iter,
GValue *value); gint column,
static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model, GValue *value);
GtkTreeIter *iter); static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model,
static GtkTreeIter *gtk_list_store_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter);
GtkTreeIter *iter); static gboolean gtk_list_store_iter_children (GtkTreeModel *tree_model,
static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter,
GtkTreeIter *iter); GtkTreeIter *parent);
static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model, static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter); GtkTreeIter *iter);
static GtkTreeIter *gtk_list_store_iter_nth_child (GtkTreeModel *tree_model, static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter);
gint n); static gboolean gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
static GtkTreeIter *gtk_list_store_iter_parent (GtkTreeModel *tree_model, GtkTreeIter *iter,
GtkTreeIter *iter); GtkTreeIter *parent,
gint n);
static gboolean gtk_list_store_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
GtkType GtkType
@ -151,7 +155,7 @@ gtk_list_store_tree_model_init (GtkTreeModelIface *iface)
iface->get_n_columns = gtk_list_store_get_n_columns; iface->get_n_columns = gtk_list_store_get_n_columns;
iface->get_iter = gtk_list_store_get_iter; iface->get_iter = gtk_list_store_get_iter;
iface->get_path = gtk_list_store_get_path; iface->get_path = gtk_list_store_get_path;
iface->iter_get_value = gtk_list_store_iter_get_value; iface->get_value = gtk_list_store_get_value;
iface->iter_next = gtk_list_store_iter_next; iface->iter_next = gtk_list_store_iter_next;
iface->iter_children = gtk_list_store_iter_children; iface->iter_children = gtk_list_store_iter_children;
iface->iter_has_child = gtk_list_store_iter_has_child; iface->iter_has_child = gtk_list_store_iter_has_child;
@ -164,32 +168,32 @@ static void
gtk_list_store_init (GtkListStore *list_store) gtk_list_store_init (GtkListStore *list_store)
{ {
list_store->root = NULL; list_store->root = NULL;
list_store->stamp = 1;
} }
GtkObject * GtkListStore *
gtk_list_store_new (void) gtk_list_store_new (void)
{ {
return GTK_OBJECT (gtk_type_new (gtk_list_store_get_type ())); return GTK_LIST_STORE (gtk_type_new (gtk_list_store_get_type ()));
} }
GtkObject * GtkListStore *
gtk_list_store_new_with_types (gint n_columns, gtk_list_store_new_with_types (gint n_columns,
...) ...)
{ {
GtkObject *retval; GtkListStore *retval;
va_list args; va_list args;
gint i; gint i;
g_return_val_if_fail (n_columns > 0, NULL); g_return_val_if_fail (n_columns > 0, NULL);
retval = gtk_list_store_new (); retval = gtk_list_store_new ();
gtk_list_store_set_n_columns (GTK_LIST_STORE (retval), gtk_list_store_set_n_columns (retval, n_columns);
n_columns);
va_start (args, n_columns); va_start (args, n_columns);
for (i = 0; i < n_columns; i++) for (i = 0; i < n_columns; i++)
gtk_list_store_set_column_type (GTK_LIST_STORE (retval), gtk_list_store_set_column_type (retval, i, va_arg (args, GType));
i, va_arg (args, GType));
va_end (args); va_end (args);
@ -204,6 +208,7 @@ gtk_list_store_set_n_columns (GtkListStore *list_store,
g_return_if_fail (list_store != NULL); g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (n_columns > 0);
if (list_store->n_columns == n_columns) if (list_store->n_columns == n_columns)
return; return;
@ -240,138 +245,160 @@ gtk_list_store_set_column_type (GtkListStore *list_store,
static gint static gint
gtk_list_store_get_n_columns (GtkTreeModel *tree_model) gtk_list_store_get_n_columns (GtkTreeModel *tree_model)
{ {
g_return_val_if_fail (tree_model != NULL, 0);
g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), 0); g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), 0);
return GTK_LIST_STORE (tree_model)->n_columns; return GTK_LIST_STORE (tree_model)->n_columns;
} }
static GtkTreeIter * static gboolean
gtk_list_store_get_iter (GtkTreeModel *tree_model, gtk_list_store_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path) GtkTreePath *path)
{ {
g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, NULL); g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), FALSE);
g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
iter->stamp = GTK_LIST_STORE (tree_model)->stamp;
iter->tree_node = g_slist_nth (G_SLIST (GTK_LIST_STORE (tree_model)->root),
gtk_tree_path_get_indices (path)[0]);
return (GtkTreeIter) g_slist_nth (G_SLIST (GTK_LIST_STORE (tree_model)->root), return iter->tree_node != NULL;
gtk_tree_path_get_indices (path)[0]);
} }
static GtkTreePath * static GtkTreePath *
gtk_list_store_get_path (GtkTreeModel *tree_model, gtk_list_store_get_path (GtkTreeModel *tree_model,
GtkTreeIter iter) GtkTreeIter *iter)
{ {
GtkTreePath *retval; GtkTreePath *retval;
GSList *list; GSList *list;
gint i = 0; gint i = 0;
g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), NULL); g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), NULL);
g_return_val_if_fail (iter->stamp == GTK_LIST_STORE (tree_model)->stamp, NULL);
for (list = G_SLIST (GTK_LIST_STORE (tree_model)->root); list; list = list->next) for (list = G_SLIST (GTK_LIST_STORE (tree_model)->root); list; list = list->next)
{ {
i++; if (list == G_SLIST (iter->tree_node))
if (list == G_SLIST (iter))
break; break;
i++;
} }
if (list == NULL) if (list == NULL)
return NULL; return NULL;
retval = gtk_tree_path_new (); retval = gtk_tree_path_new ();
gtk_tree_path_append_index (retval, i); gtk_tree_path_append_index (retval, i);
return retval; return retval;
} }
static void static void
gtk_list_store_iter_get_value (GtkTreeModel *tree_model, gtk_list_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
GtkTreeDataList *list; GtkTreeDataList *list;
gint tmp_column = column; gint tmp_column = column;
g_return_if_fail (tree_model != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (tree_model)); g_return_if_fail (GTK_IS_LIST_STORE (tree_model));
g_return_if_fail (iter != NULL);
g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns); g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns);
g_return_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp);
list = G_SLIST (iter)->data; list = G_SLIST (iter->tree_node)->data;
while (tmp_column-- > 0 && list) while (tmp_column-- > 0 && list)
list = list->next; list = list->next;
g_return_if_fail (list != NULL); if (list == NULL)
g_value_init (value, GTK_LIST_STORE (tree_model)->column_headers[column]);
gtk_tree_data_list_iter_to_value (list, else
GTK_LIST_STORE (tree_model)->column_headers[column], _gtk_tree_data_list_node_to_value (list,
value); GTK_LIST_STORE (tree_model)->column_headers[column],
value);
} }
static gboolean static gboolean
gtk_list_store_iter_next (GtkTreeModel *tree_model, gtk_list_store_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
if (iter == NULL || *iter == NULL) g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), FALSE);
return FALSE; g_return_val_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp, FALSE);
*iter = (GtkTreeIter) G_SLIST (*iter)->next; iter->tree_node = G_SLIST (iter->tree_node)->next;
return (*iter != NULL); return (iter->tree_node != NULL);
} }
static GtkTreeIter static gboolean
gtk_list_store_iter_children (GtkTreeModel *tree_model, gtk_list_store_iter_children (GtkTreeModel *tree_model,
GtkTreeIter iter) GtkTreeIter *iter,
GtkTreeIter *parent)
{ {
return NULL; iter->stamp = 0;
iter->tree_node = NULL;
return FALSE;
} }
static gboolean static gboolean
gtk_list_store_iter_has_child (GtkTreeModel *tree_model, gtk_list_store_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter iter) GtkTreeIter *iter)
{ {
return FALSE; return FALSE;
} }
static gint static gint
gtk_list_store_iter_n_children (GtkTreeModel *tree_model, gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter iter) GtkTreeIter *iter)
{ {
return 0; return 0;
} }
static GtkTreeIter static gboolean
gtk_list_store_iter_nth_child (GtkTreeModel *tree_model, gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter iter, GtkTreeIter *iter,
GtkTreeIter *parent,
gint n) gint n)
{ {
return NULL; g_return_val_if_fail (GTK_IS_LIST_STORE (tree_model), FALSE);
if (parent)
{
g_return_val_if_fail (iter->stamp == GTK_LIST_STORE (tree_model)->stamp, FALSE);
iter->stamp = 0;
iter->tree_node = NULL;
return FALSE;
}
iter->tree_node = g_slist_nth (G_SLIST (GTK_LIST_STORE (tree_model)->root), n);
if (iter->tree_node)
iter->stamp = GTK_LIST_STORE (tree_model)->stamp;
else
iter->stamp = 0;
return (iter->tree_node != NULL);
} }
static GtkTreeIter static gboolean
gtk_list_store_iter_parent (GtkTreeModel *tree_model, gtk_list_store_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter iter) GtkTreeIter *iter,
GtkTreeIter *child)
{ {
return NULL; iter->stamp = 0;
iter->tree_node = NULL;
return FALSE;
} }
/* Public accessors */ /* Public accessors */
GtkTreeIter
gtk_list_store_iter_new (void)
{
GtkTreeIter retval = (GtkTreeIter) g_slist_alloc ();
return retval;
}
/* This is a somewhat inelegant function that does a lot of list /* This is a somewhat inelegant function that does a lot of list
* manipulations on it's own. * manipulations on it's own.
*/ */
void void
gtk_list_store_iter_set_cell (GtkListStore *list_store, gtk_list_store_set_cell (GtkListStore *list_store,
GtkTreeIter iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
GtkTreeDataList *list; GtkTreeDataList *list;
GtkTreeDataList *prev; GtkTreeDataList *prev;
@ -381,13 +408,13 @@ gtk_list_store_iter_set_cell (GtkListStore *list_store,
g_return_if_fail (iter != NULL); g_return_if_fail (iter != NULL);
g_return_if_fail (column >= 0 && column < list_store->n_columns); g_return_if_fail (column >= 0 && column < list_store->n_columns);
prev = list = G_SLIST (iter)->data; prev = list = G_SLIST (iter->tree_node)->data;
while (list != NULL) while (list != NULL)
{ {
if (column == 0) if (column == 0)
{ {
gtk_tree_data_list_value_to_iter (list, value); _gtk_tree_data_list_value_to_node (list, value);
return; return;
} }
@ -396,123 +423,235 @@ gtk_list_store_iter_set_cell (GtkListStore *list_store,
list = list->next; list = list->next;
} }
if (G_SLIST (iter)->data == NULL) if (G_SLIST (iter->tree_node)->data == NULL)
{ {
G_SLIST (iter)->data = list = gtk_tree_data_list_alloc (); G_SLIST (iter->tree_node)->data = list = _gtk_tree_data_list_alloc ();
list->next = NULL; list->next = NULL;
} }
else else
{ {
list = prev->next = gtk_tree_data_list_alloc (); list = prev->next = _gtk_tree_data_list_alloc ();
list->next = NULL; list->next = NULL;
} }
while (column != 0) while (column != 0)
{ {
list->next = gtk_tree_data_list_alloc (); list->next = _gtk_tree_data_list_alloc ();
list = list->next; list = list->next;
list->next = NULL; list->next = NULL;
column --; column --;
} }
gtk_tree_data_list_value_to_iter (list, value); _gtk_tree_data_list_value_to_node (list, value);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"changed",
NULL, iter);
} }
void void
gtk_list_store_iter_remove (GtkListStore *list_store, gtk_list_store_remove (GtkListStore *list_store,
GtkTreeIter iter) GtkTreeIter *iter)
{ {
/* FIXME: implement */ GtkTreePath *path;
g_warning ("Remember to implement this function\n");
g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
if (G_SLIST (iter->tree_node)->data)
_gtk_tree_data_list_free ((GtkTreeDataList *) G_SLIST (iter->tree_node)->data,
list_store->column_headers);
path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter);
list_store->root = g_slist_remove_link (G_SLIST (list_store->root),
G_SLIST (iter->tree_node));
list_store->stamp ++;
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"deleted",
path);
gtk_tree_path_free (path);
} }
GtkTreeIter void
gtk_list_store_iter_insert (GtkListStore *list_store, gtk_list_store_insert (GtkListStore *list_store,
gint position, GtkTreeIter *iter,
GtkTreeIter iter) gint position)
{ {
GSList *list; GSList *list;
GtkTreePath *path;
g_return_val_if_fail (list_store != NULL, iter); g_return_if_fail (list_store != NULL);
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), iter); g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_val_if_fail (iter != NULL, iter); g_return_if_fail (iter != NULL);
g_return_val_if_fail (position < 0, iter); g_return_if_fail (position < 0);
g_return_val_if_fail (G_SLIST (iter)->next == NULL, iter);
if (position == 0) if (position == 0)
{ {
gtk_list_store_iter_prepend (list_store, iter); gtk_list_store_prepend (list_store, iter);
return iter; return;
} }
list = g_slist_nth (G_SLIST (list_store->root), position); iter->stamp = list_store->stamp;
iter->tree_node = g_slist_alloc ();
list = g_slist_nth (G_SLIST (list_store->root), position - 1);
if (list) if (list)
{ {
G_SLIST (iter)->next = list->next; G_SLIST (iter->tree_node)->next = list->next;
list->next = G_SLIST (iter)->next; list->next = G_SLIST (iter->tree_node)->next;
}
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, position);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"inserted",
path, iter);
gtk_tree_path_free (path);
}
void
gtk_list_store_insert_before (GtkListStore *list_store,
GtkTreeIter *iter,
GtkTreeIter *sibling)
{
GtkTreePath *path;
GSList *list, *prev;
gint i = 0;
g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter != NULL);
g_return_if_fail (G_SLIST (iter)->next == NULL);
if (sibling == NULL)
{
gtk_list_store_append (list_store, iter);
return;
} }
return iter; iter->stamp = list_store->stamp;
} iter->tree_node = g_slist_alloc ();
prev = list = list_store->root;
GtkTreeIter while (list && list != sibling->tree_node)
gtk_list_store_iter_insert_before (GtkListStore *list_store, {
GtkTreeIter sibling, prev = list;
GtkTreeIter iter) list = list->next;
{ i++;
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); if (prev)
{
/* FIXME: This is all wrong. This is actually insert_after */ prev->next = iter->tree_node;
if (sibling == NULL) }
return gtk_list_store_iter_prepend (list_store, iter);
G_SLIST (iter)->next = G_SLIST (sibling)->next;
G_SLIST (sibling)->next = G_SLIST (iter);
return iter;
}
GtkTreeIter
gtk_list_store_iter_prepend (GtkListStore *list_store,
GtkTreeIter iter)
{
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 (iter)->next = G_SLIST (list_store->root);
list_store->root = iter;
return iter;
}
GtkTreeIter
gtk_list_store_iter_append (GtkListStore *list_store,
GtkTreeIter iter)
{
GSList *list;
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 = iter;
else else
list->next = G_SLIST (iter); {
G_SLIST (iter->tree_node)->next = list_store->root;
list_store->root = iter->tree_node;
}
return iter; path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"inserted",
path, iter);
gtk_tree_path_free (path);
} }
GtkTreeIter void
gtk_list_store_iter_get_root (GtkListStore *list_store) gtk_list_store_insert_after (GtkListStore *list_store,
GtkTreeIter *iter,
GtkTreeIter *sibling)
{ {
g_return_val_if_fail (list_store != NULL, NULL); GtkTreePath *path;
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), NULL); GSList *list;
gint i = 0;
return (GtkTreeIter *) list_store->root; g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter == NULL);
if (sibling)
g_return_if_fail (sibling->stamp == list_store->stamp);
if (sibling == NULL)
{
gtk_list_store_prepend (list_store, iter);
return;
}
for (list = list_store->root; list && list != sibling->tree_node; list = list->next)
i++;
g_return_if_fail (list != NULL);
iter->stamp = list_store->stamp;
iter->tree_node = g_slist_alloc ();
G_SLIST (iter->tree_node)->next = G_SLIST (sibling->tree_node)->next;
G_SLIST (sibling)->next = G_SLIST (iter);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"inserted",
path, iter);
gtk_tree_path_free (path);
}
void
gtk_list_store_prepend (GtkListStore *list_store,
GtkTreeIter *iter)
{
GtkTreePath *path;
g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter != NULL);
iter->stamp = list_store->stamp;
iter->tree_node = g_slist_alloc ();
G_SLIST (iter->tree_node)->next = G_SLIST (list_store->root);
list_store->root = iter->tree_node;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, 0);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"inserted",
path, iter);
gtk_tree_path_free (path);
}
void
gtk_list_store_append (GtkListStore *list_store,
GtkTreeIter *iter)
{
GtkTreePath *path;
GSList *list, *prev;
gint i = 0;
g_return_if_fail (list_store != NULL);
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter != NULL);
g_return_if_fail (G_SLIST (iter)->next == NULL);
iter->stamp = list_store->stamp;
iter->tree_node = g_slist_alloc ();
prev = list = list_store->root;
while (list)
{
prev = list;
list = list->next;
i++;
}
if (prev)
prev->next = iter->tree_node;
else
list_store->root = iter->tree_node;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_signal_emit_by_name (GTK_OBJECT (list_store),
"inserted",
path, iter);
gtk_tree_path_free (path);
} }
#endif

77
gtk/gtkliststore.h
View File

@ -52,45 +52,48 @@ struct _GtkListStoreClass
/* signals */ /* signals */
/* Will be moved into the GtkTreeModelIface eventually */ /* Will be moved into the GtkTreeModelIface eventually */
void (* changed) (GtkTreeModel *tree_model, void (* changed) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeIter *iter); GtkTreeIter *iter);
void (* inserted) (GtkTreeModel *tree_model, void (* inserted) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeIter *iter); GtkTreeIter *iter);
void (* child_toggled) (GtkTreeModel *tree_model, void (* child_toggled) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeIter *iter); GtkTreeIter *iter);
void (* deleted) (GtkTreeModel *tree_model, void (* deleted) (GtkTreeModel *tree_model,
GtkTreePath *path); GtkTreePath *path);
}; };
GtkType gtk_list_store_get_type (void);
GtkObject *gtk_list_store_new (void); GtkType gtk_list_store_get_type (void);
GtkObject *gtk_list_store_new_with_types (gint n_columns, GtkListStore *gtk_list_store_new (void);
...); GtkListStore *gtk_list_store_new_with_types (gint n_columns,
void gtk_list_store_set_n_columns (GtkListStore *store, ...);
gint n_columns); void gtk_list_store_set_n_columns (GtkListStore *store,
void gtk_list_store_set_column_type (GtkListStore *store, gint n_columns);
gint column, void gtk_list_store_set_column_type (GtkListStore *store,
GType type); gint column,
GtkTreeIter *gtk_list_store_node_new (void); GType type);
void gtk_list_store_node_set_cell (GtkListStore *store, void gtk_list_store_set_cell (GtkListStore *store,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value); GValue *value);
void gtk_list_store_node_remove (GtkListStore *store, void gtk_list_store_remove (GtkListStore *store,
GtkTreeIter *iter); GtkTreeIter *iter);
GtkTreeIter *gtk_list_store_node_insert (GtkListStore *store, void gtk_list_store_insert (GtkListStore *store,
gint position, GtkTreeIter *iter,
GtkTreeIter *iter); gint position);
GtkTreeIter *gtk_list_store_node_insert_before (GtkListStore *store, void gtk_list_store_insert_before (GtkListStore *store,
GtkTreeIter sibling, GtkTreeIter *iter,
GtkTreeIter *iter); GtkTreeIter *sibling);
GtkTreeIter *gtk_list_store_node_prepend (GtkListStore *store, void gtk_list_store_insert_after (GtkListStore *store,
GtkTreeIter *iter); GtkTreeIter *iter,
GtkTreeIter *gtk_list_store_node_append (GtkListStore *store, GtkTreeIter *sibling);
GtkTreeIter *iter); void gtk_list_store_prepend (GtkListStore *store,
GtkTreeIter *iter);
void gtk_list_store_append (GtkListStore *store,
GtkTreeIter *iter);

3
gtk/gtkmarshal.list
View File

@ -22,12 +22,15 @@
# BOOL deprecated alias for BOOLEAN # BOOL deprecated alias for BOOLEAN
BOOLEAN:POINTER BOOLEAN:POINTER
BOOLEAN:POINTER,POINTER
BOOLEAN:POINTER,INT,INT BOOLEAN:POINTER,INT,INT
BOOLEAN:POINTER,INT,INT,UINT BOOLEAN:POINTER,INT,INT,UINT
BOOLEAN:POINTER,POINTER,INT
BOOLEAN:POINTER,POINTER,INT,INT BOOLEAN:POINTER,POINTER,INT,INT
BOOLEAN:POINTER,STRING,STRING,POINTER BOOLEAN:POINTER,STRING,STRING,POINTER
BOOLEAN:VOID BOOLEAN:VOID
ENUM:ENUM ENUM:ENUM
INT:INT
INT:OBJECT,BOXED,POINTER INT:OBJECT,BOXED,POINTER
INT:POINTER INT:POINTER
INT:POINTER,CHAR,CHAR INT:POINTER,CHAR,CHAR

3
gtk/gtkmarshalers.list
View File

@ -22,12 +22,15 @@
# BOOL deprecated alias for BOOLEAN # BOOL deprecated alias for BOOLEAN
BOOLEAN:POINTER BOOLEAN:POINTER
BOOLEAN:POINTER,POINTER
BOOLEAN:POINTER,INT,INT BOOLEAN:POINTER,INT,INT
BOOLEAN:POINTER,INT,INT,UINT BOOLEAN:POINTER,INT,INT,UINT
BOOLEAN:POINTER,POINTER,INT
BOOLEAN:POINTER,POINTER,INT,INT BOOLEAN:POINTER,POINTER,INT,INT
BOOLEAN:POINTER,STRING,STRING,POINTER BOOLEAN:POINTER,STRING,STRING,POINTER
BOOLEAN:VOID BOOLEAN:VOID
ENUM:ENUM ENUM:ENUM
INT:INT
INT:OBJECT,BOXED,POINTER INT:OBJECT,BOXED,POINTER
INT:POINTER INT:POINTER
INT:POINTER,CHAR,CHAR INT:POINTER,CHAR,CHAR

322
gtk/gtkmodelsimple.c
View File

@ -16,26 +16,26 @@
* Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA. * Boston, MA 02111-1307, USA.
*/ */
#if 0
#include "gtkmodelsimple.h" #include "gtkmodelsimple.h"
#include "gtksignal.h" #include "gtksignal.h"
enum { enum {
NODE_CHANGED, CHANGED,
NODE_INSERTED, INSERTED,
NODE_CHILD_TOGGLED, CHILD_TOGGLED,
NODE_DELETED, DELETED,
GET_N_COLUMNS, GET_N_COLUMNS,
GET_NODE, GET_COLUMN_TYPE,
GET_ITER,
GET_PATH, GET_PATH,
NODE_GET_VALUE, GET_VALUE,
NODE_COPY, ITER_NEXT,
NODE_NEXT, ITER_CHILDREN,
NODE_CHILDREN, ITER_HAS_CHILD,
NODE_HAS_CHILD, ITER_N_CHILDREN,
NODE_N_CHILDREN, ITER_NTH_CHILD,
NODE_NTH_CHILD, ITER_PARENT,
NODE_PARENT,
LAST_SIGNAL LAST_SIGNAL
}; };
@ -43,27 +43,34 @@ static void gtk_model_simple_init (GtkModelSimple *
static void gtk_model_simple_class_init (GtkModelSimpleClass *class); static void gtk_model_simple_class_init (GtkModelSimpleClass *class);
static void gtk_model_simple_tree_model_init (GtkTreeModelIface *iface); static void gtk_model_simple_tree_model_init (GtkTreeModelIface *iface);
static gint gtk_real_model_simple_get_n_columns (GtkTreeModel *tree_model); static gint gtk_real_model_simple_get_n_columns (GtkTreeModel *tree_model);
static GtkTreeNode gtk_real_model_simple_get_node (GtkTreeModel *tree_model, static GType gtk_real_model_simple_get_column_type (GtkTreeModel *tree_model,
gint index);
static gboolean gtk_real_model_simple_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path); GtkTreePath *path);
static GtkTreePath *gtk_real_model_simple_get_path (GtkTreeModel *tree_model, static GtkTreePath *gtk_real_model_simple_get_path (GtkTreeModel *tree_model,
GtkTreeNode node); GtkTreeIter *iter);
static void gtk_real_model_simple_node_get_value (GtkTreeModel *tree_model, static void gtk_real_model_simple_get_value (GtkTreeModel *tree_model,
GtkTreeNode node, GtkTreeIter *iter,
gint column, gint column,
GValue *value); GValue *value);
static gboolean gtk_real_model_simple_node_next (GtkTreeModel *tree_model, static gboolean gtk_real_model_simple_iter_next (GtkTreeModel *tree_model,
GtkTreeNode *node); GtkTreeIter *iter);
static GtkTreeNode gtk_real_model_simple_node_children (GtkTreeModel *tree_model, static gboolean gtk_real_model_simple_iter_children (GtkTreeModel *tree_model,
GtkTreeNode node); GtkTreeIter *iter,
static gboolean gtk_real_model_simple_node_has_child (GtkTreeModel *tree_model, GtkTreeIter *parent);
GtkTreeNode node); static gboolean gtk_real_model_simple_iter_has_child (GtkTreeModel *tree_model,
static gint gtk_real_model_simple_node_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter);
GtkTreeNode node); static gint gtk_real_model_simple_iter_n_children (GtkTreeModel *tree_model,
static GtkTreeNode gtk_real_model_simple_node_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter);
GtkTreeNode node, static gboolean gtk_real_model_simple_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
gint n); gint n);
static GtkTreeNode gtk_real_model_simple_node_parent (GtkTreeModel *tree_model, static gboolean gtk_real_model_simple_iter_parent (GtkTreeModel *tree_model,
GtkTreeNode node); GtkTreeIter *iter,
GtkTreeIter *child);
@ -106,10 +113,14 @@ gtk_model_simple_get_type (void)
return model_simple_type; return model_simple_type;
} }
GtkObject * GtkModelSimple *
gtk_model_simple_new (void) gtk_model_simple_new (void)
{ {
return GTK_OBJECT (gtk_type_new (GTK_TYPE_MODEL_SIMPLE)); GtkModelSimple *retval;
retval = GTK_MODEL_SIMPLE (gtk_type_new (GTK_TYPE_MODEL_SIMPLE));
return retval;
} }
static void static void
@ -119,38 +130,38 @@ gtk_model_simple_class_init (GtkModelSimpleClass *class)
object_class = (GtkObjectClass*) class; object_class = (GtkObjectClass*) class;
model_simple_signals[NODE_CHANGED] = model_simple_signals[CHANGED] =
gtk_signal_new ("node_changed", gtk_signal_new ("changed",
GTK_RUN_FIRST, GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkModelSimpleClass, node_changed), GTK_SIGNAL_OFFSET (GtkModelSimpleClass, changed),
gtk_marshal_VOID__POINTER_POINTER, gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER, GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_INSERTED] = model_simple_signals[INSERTED] =
gtk_signal_new ("node_inserted", gtk_signal_new ("inserted",
GTK_RUN_FIRST, GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkModelSimpleClass, node_inserted), GTK_SIGNAL_OFFSET (GtkModelSimpleClass, inserted),
gtk_marshal_VOID__POINTER_POINTER, gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER, GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_CHILD_TOGGLED] = model_simple_signals[CHILD_TOGGLED] =
gtk_signal_new ("node_child_toggled", gtk_signal_new ("child_toggled",
GTK_RUN_FIRST, GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkModelSimpleClass, node_child_toggled), GTK_SIGNAL_OFFSET (GtkModelSimpleClass, child_toggled),
gtk_marshal_VOID__POINTER_POINTER, gtk_marshal_VOID__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER, GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_DELETED] = model_simple_signals[DELETED] =
gtk_signal_new ("node_deleted", gtk_signal_new ("deleted",
GTK_RUN_FIRST, GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkModelSimpleClass, node_deleted), GTK_SIGNAL_OFFSET (GtkModelSimpleClass, deleted),
gtk_marshal_VOID__POINTER, gtk_marshal_VOID__POINTER,
GTK_TYPE_NONE, 1, GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
@ -162,13 +173,22 @@ gtk_model_simple_class_init (GtkModelSimpleClass *class)
0, 0,
gtk_marshal_INT__VOID, gtk_marshal_INT__VOID,
GTK_TYPE_INT, 0); GTK_TYPE_INT, 0);
model_simple_signals[GET_NODE] = model_simple_signals[GET_COLUMN_TYPE] =
gtk_signal_new ("get_node", gtk_signal_new ("get_column_type",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER, gtk_marshal_INT__INT,
GTK_TYPE_POINTER, 1, GTK_TYPE_INT, 1,
GTK_TYPE_INT);
model_simple_signals[GET_ITER] =
gtk_signal_new ("get_iter",
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
0,
gtk_marshal_BOOLEAN__POINTER_POINTER,
GTK_TYPE_BOOL, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[GET_PATH] = model_simple_signals[GET_PATH] =
gtk_signal_new ("get_path", gtk_signal_new ("get_path",
@ -178,8 +198,8 @@ gtk_model_simple_class_init (GtkModelSimpleClass *class)
gtk_marshal_POINTER__POINTER, gtk_marshal_POINTER__POINTER,
GTK_TYPE_POINTER, 1, GTK_TYPE_POINTER, 1,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_GET_VALUE] = model_simple_signals[GET_VALUE] =
gtk_signal_new ("node_get_value", gtk_signal_new ("get_value",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
@ -188,54 +208,56 @@ gtk_model_simple_class_init (GtkModelSimpleClass *class)
GTK_TYPE_POINTER, GTK_TYPE_POINTER,
GTK_TYPE_INT, GTK_TYPE_INT,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_NEXT] = model_simple_signals[ITER_NEXT] =
gtk_signal_new ("node_next", gtk_signal_new ("iter_next",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_BOOLEAN__POINTER, gtk_marshal_BOOLEAN__POINTER,
GTK_TYPE_BOOL, 1, GTK_TYPE_BOOL, 1,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_CHILDREN] = model_simple_signals[ITER_CHILDREN] =
gtk_signal_new ("node_children", gtk_signal_new ("iter_children",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER, gtk_marshal_BOOLEAN__POINTER_POINTER,
GTK_TYPE_POINTER, 1, GTK_TYPE_POINTER, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_HAS_CHILD] = model_simple_signals[ITER_HAS_CHILD] =
gtk_signal_new ("node_has_child", gtk_signal_new ("iter_has_child",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER, gtk_marshal_BOOLEAN__POINTER,
GTK_TYPE_POINTER, 1, GTK_TYPE_BOOL, 1,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_N_CHILDREN] = model_simple_signals[ITER_N_CHILDREN] =
gtk_signal_new ("node_n_children", gtk_signal_new ("iter_n_children",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER, gtk_marshal_INT__POINTER,
GTK_TYPE_POINTER, 1, GTK_TYPE_INT, 1,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_NTH_CHILD] = model_simple_signals[ITER_NTH_CHILD] =
gtk_signal_new ("node_nth_child", gtk_signal_new ("node_nth_child",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER_INT, gtk_marshal_BOOLEAN__POINTER_POINTER_INT,
GTK_TYPE_POINTER, 2, GTK_TYPE_BOOL, 2,
GTK_TYPE_POINTER, GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
model_simple_signals[NODE_PARENT] = model_simple_signals[ITER_PARENT] =
gtk_signal_new ("node_parent", gtk_signal_new ("node_parent",
GTK_RUN_LAST, GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class), GTK_CLASS_TYPE (object_class),
0, 0,
gtk_marshal_POINTER__POINTER, gtk_marshal_BOOLEAN__POINTER_POINTER,
GTK_TYPE_POINTER, 1, GTK_TYPE_BOOL, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER); GTK_TYPE_POINTER);
gtk_object_class_add_signals (object_class, model_simple_signals, LAST_SIGNAL); gtk_object_class_add_signals (object_class, model_simple_signals, LAST_SIGNAL);
@ -245,21 +267,23 @@ static void
gtk_model_simple_tree_model_init (GtkTreeModelIface *iface) gtk_model_simple_tree_model_init (GtkTreeModelIface *iface)
{ {
iface->get_n_columns = gtk_real_model_simple_get_n_columns; iface->get_n_columns = gtk_real_model_simple_get_n_columns;
iface->get_node = gtk_real_model_simple_get_node; iface->get_column_type = gtk_real_model_simple_get_column_type;
iface->get_iter = gtk_real_model_simple_get_iter;
iface->get_path = gtk_real_model_simple_get_path; iface->get_path = gtk_real_model_simple_get_path;
iface->node_get_value = gtk_real_model_simple_node_get_value; iface->get_value = gtk_real_model_simple_get_value;
iface->node_next = gtk_real_model_simple_node_next; iface->iter_next = gtk_real_model_simple_iter_next;
iface->node_children = gtk_real_model_simple_node_children; iface->iter_children = gtk_real_model_simple_iter_children;
iface->node_has_child = gtk_real_model_simple_node_has_child; iface->iter_has_child = gtk_real_model_simple_iter_has_child;
iface->node_n_children = gtk_real_model_simple_node_n_children; iface->iter_n_children = gtk_real_model_simple_iter_n_children;
iface->node_nth_child = gtk_real_model_simple_node_nth_child; iface->iter_nth_child = gtk_real_model_simple_iter_nth_child;
iface->node_parent = gtk_real_model_simple_node_parent; iface->iter_parent = gtk_real_model_simple_iter_parent;
} }
static void static void
gtk_model_simple_init (GtkModelSimple *model_simple) gtk_model_simple_init (GtkModelSimple *model_simple)
{ {
model_simple->stamp = 1;
} }
static gint static gint
@ -272,150 +296,164 @@ gtk_real_model_simple_get_n_columns (GtkTreeModel *tree_model)
return retval; return retval;
} }
static GtkTreeNode static GType
gtk_real_model_simple_get_node (GtkTreeModel *tree_model, gtk_real_model_simple_get_column_type (GtkTreeModel *tree_model,
gint index)
{
GType retval = G_TYPE_INVALID;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_COLUMN_TYPE], index, &retval);
return retval;
}
static gboolean
gtk_real_model_simple_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path) GtkTreePath *path)
{ {
GtkTreeNode retval; gboolean retval;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_NODE], path, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_ITER], iter, path, &retval);
return retval; return retval;
} }
static GtkTreePath * static GtkTreePath *
gtk_real_model_simple_get_path (GtkTreeModel *tree_model, gtk_real_model_simple_get_path (GtkTreeModel *tree_model,
GtkTreeNode node) GtkTreeIter *iter)
{ {
GtkTreePath *retval; GtkTreePath *retval;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_PATH], node, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_PATH], iter, &retval);
return retval; return retval;
} }
static void static void
gtk_real_model_simple_node_get_value (GtkTreeModel *tree_model, gtk_real_model_simple_get_value (GtkTreeModel *tree_model,
GtkTreeNode node, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_GET_VALUE], node, column, value); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_VALUE], iter, column, value);
} }
static gboolean static gboolean
gtk_real_model_simple_node_next (GtkTreeModel *tree_model, gtk_real_model_simple_iter_next (GtkTreeModel *tree_model,
GtkTreeNode *node) GtkTreeIter *iter)
{ {
gboolean retval = FALSE; gboolean retval = FALSE;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_NEXT], node, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_NEXT], iter, &retval);
return retval;
}
static GtkTreeNode
gtk_real_model_simple_node_children (GtkTreeModel *tree_model,
GtkTreeNode node)
{
GtkTreeNode retval = NULL;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_CHILDREN], node, &retval);
return retval; return retval;
} }
static gboolean static gboolean
gtk_real_model_simple_node_has_child (GtkTreeModel *tree_model, gtk_real_model_simple_iter_children (GtkTreeModel *tree_model,
GtkTreeNode node) GtkTreeIter *iter,
GtkTreeIter *parent)
{ {
gboolean retval = FALSE; gboolean retval = FALSE;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_HAS_CHILD], node, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_CHILDREN], iter, parent, &retval);
return retval;
}
static gboolean
gtk_real_model_simple_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gboolean retval = FALSE;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_HAS_CHILD], iter, &retval);
return retval; return retval;
} }
static gint static gint
gtk_real_model_simple_node_n_children (GtkTreeModel *tree_model, gtk_real_model_simple_iter_n_children (GtkTreeModel *tree_model,
GtkTreeNode node) GtkTreeIter *iter)
{ {
gint retval = 0; gint retval = 0;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_N_CHILDREN], node, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_N_CHILDREN], iter, &retval);
return retval; return retval;
} }
static GtkTreeNode static gboolean
gtk_real_model_simple_node_nth_child (GtkTreeModel *tree_model, gtk_real_model_simple_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeNode node, GtkTreeIter *iter,
GtkTreeIter *parent,
gint n) gint n)
{ {
GtkTreeNode retval = NULL; gboolean retval = FALSE;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_NTH_CHILD], node, n, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_NTH_CHILD], iter, parent, n, &retval);
return retval; return retval;
} }
static GtkTreeNode static gboolean
gtk_real_model_simple_node_parent (GtkTreeModel *tree_model, gtk_real_model_simple_iter_parent (GtkTreeModel *tree_model,
GtkTreeNode node) GtkTreeIter *iter,
GtkTreeIter *child)
{ {
GtkTreeNode retval = NULL; gboolean retval = FALSE;
gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[NODE_PARENT], node, &retval); gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_PARENT], iter, child, &retval);
return retval; return retval;
} }
/* Public functions */ /* Public functions */
void void
gtk_model_simple_node_changed (GtkModelSimple *simple, gtk_model_simple_changed (GtkModelSimple *simple,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node) GtkTreeIter *iter)
{ {
g_return_if_fail (simple != NULL); g_return_if_fail (simple != NULL);
g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple)); g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
g_return_if_fail (path != NULL); g_return_if_fail (path != NULL);
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_changed", path, node); gtk_signal_emit_by_name (GTK_OBJECT (simple), "changed", path, iter);
} }
void void
gtk_model_simple_node_inserted (GtkModelSimple *simple, gtk_model_simple_inserted (GtkModelSimple *simple,
GtkTreePath *path,
GtkTreeIter *iter)
{
g_return_if_fail (simple != NULL);
g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
g_return_if_fail (path != NULL);
gtk_signal_emit_by_name (GTK_OBJECT (simple), "inserted", path, iter);
}
void
gtk_model_simple_child_toggled (GtkModelSimple *simple,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node) GtkTreeIter *iter)
{ {
g_return_if_fail (simple != NULL); g_return_if_fail (simple != NULL);
g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple)); g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
g_return_if_fail (path != NULL); g_return_if_fail (path != NULL);
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_inserted", path, node); gtk_signal_emit_by_name (GTK_OBJECT (simple), "child_toggled", path, iter);
} }
void void
gtk_model_simple_node_child_toggled (GtkModelSimple *simple, gtk_model_simple_iter_deleted (GtkModelSimple *simple,
GtkTreePath *path,
GtkTreeNode node)
{
g_return_if_fail (simple != NULL);
g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
g_return_if_fail (path != NULL);
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_child_toggled", path, node);
}
void
gtk_model_simple_node_deleted (GtkModelSimple *simple,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node) GtkTreeIter *iter)
{ {
g_return_if_fail (simple != NULL); g_return_if_fail (simple != NULL);
g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple)); g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
g_return_if_fail (path != NULL); g_return_if_fail (path != NULL);
gtk_signal_emit_by_name (GTK_OBJECT (simple), "node_deleted", path, node); gtk_signal_emit_by_name (GTK_OBJECT (simple), "iter_deleted", path, iter);
} }
#endif

48
gtk/gtkmodelsimple.h
View File

@ -26,7 +26,6 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#if 0
#define GTK_TYPE_MODEL_SIMPLE (gtk_model_simple_get_type ()) #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(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_MODEL_SIMPLE, GtkModelSimple))
@ -40,6 +39,8 @@ typedef struct _GtkModelSimpleClass GtkModelSimpleClass;
struct _GtkModelSimple struct _GtkModelSimple
{ {
GtkObject parent; GtkObject parent;
gint stamp;
}; };
struct _GtkModelSimpleClass struct _GtkModelSimpleClass
@ -49,37 +50,36 @@ struct _GtkModelSimpleClass
/* signals */ /* signals */
/* Will be moved into the GtkTreeModelIface eventually */ /* Will be moved into the GtkTreeModelIface eventually */
void (* changed) (GtkTreeModel *tree_model, void (* changed) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node); GtkTreeIter *iter);
void (* inserted) (GtkTreeModel *tree_model, void (* inserted) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node); GtkTreeIter *iter);
void (* child_toggled) (GtkTreeModel *tree_model, void (* child_toggled) (GtkTreeModel *tree_model,
GtkTreePath *path, GtkTreePath *path,
GtkTreeNode node); GtkTreeIter *iter);
void (* deleted) (GtkTreeModel *tree_model, void (* deleted) (GtkTreeModel *tree_model,
GtkTreePath *path); GtkTreePath *path);
}; };
GtkType gtk_model_simple_get_type (void); GtkType gtk_model_simple_get_type (void);
GtkObject *gtk_model_simple_new (void); GtkModelSimple *gtk_model_simple_new (void);
void gtk_model_simple_node_changed (GtkModelSimple *simple,
void gtk_model_simple_node_changed (GtkModelSimple *simple, GtkTreePath *path,
GtkTreePath *path, GtkTreeIter *iter);
GtkTreeNode node); void gtk_model_simple_node_inserted (GtkModelSimple *simple,
void gtk_model_simple_node_inserted (GtkModelSimple *simple, GtkTreePath *path,
GtkTreePath *path, GtkTreeIter *iter);
GtkTreeNode node); void gtk_model_simple_node_child_toggled (GtkModelSimple *simple,
void gtk_model_simple_node_child_toggled (GtkModelSimple *simple, GtkTreePath *path,
GtkTreePath *path, GtkTreeIter *iter);
GtkTreeNode node); void gtk_model_simple_node_deleted (GtkModelSimple *simple,
void gtk_model_simple_node_deleted (GtkModelSimple *simple, GtkTreePath *path,
GtkTreePath *path, GtkTreeIter *iter);
GtkTreeNode node);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

38
gtk/gtktreedatalist.c
View File

@ -68,7 +68,7 @@ gtk_tree_data_list_validate_allocator (GAllocator *allocator)
} }
void void
gtk_tree_data_list_push_allocator (GAllocator *allocator) _gtk_tree_data_list_push_allocator (GAllocator *allocator)
{ {
G_LOCK (current_allocator); G_LOCK (current_allocator);
gtk_tree_data_list_validate_allocator ( allocator ); gtk_tree_data_list_validate_allocator ( allocator );
@ -78,7 +78,7 @@ gtk_tree_data_list_push_allocator (GAllocator *allocator)
} }
void void
gtk_tree_data_list_pop_allocator (void) _gtk_tree_data_list_pop_allocator (void)
{ {
G_LOCK (current_allocator); G_LOCK (current_allocator);
if (current_allocator) if (current_allocator)
@ -94,7 +94,7 @@ gtk_tree_data_list_pop_allocator (void)
} }
GtkTreeDataList * GtkTreeDataList *
gtk_tree_data_list_alloc (void) _gtk_tree_data_list_alloc (void)
{ {
GtkTreeDataList *list; GtkTreeDataList *list;
@ -120,8 +120,28 @@ gtk_tree_data_list_alloc (void)
} }
void void
gtk_tree_data_list_free (GtkTreeDataList *list) _gtk_tree_data_list_free (GtkTreeDataList *list,
GType *column_headers)
{ {
GtkTreeDataList *tmp;
gint i = 0;
for (tmp = list; tmp; tmp = tmp->next)
{
switch (column_headers [i])
{
case G_TYPE_STRING:
g_free ((gchar *) tmp->data.v_pointer);
break;
case G_TYPE_OBJECT:
g_object_unref (G_OBJECT (tmp->data.v_pointer));
break;
default:
break;
}
i++;
}
G_LOCK (current_allocator); G_LOCK (current_allocator);
list->next = current_allocator->free_nodes; list->next = current_allocator->free_nodes;
current_allocator->free_nodes = list; current_allocator->free_nodes = list;
@ -129,9 +149,9 @@ gtk_tree_data_list_free (GtkTreeDataList *list)
} }
void void
gtk_tree_data_list_node_to_value (GtkTreeDataList *list, _gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
GType type, GType type,
GValue *value) GValue *value)
{ {
g_value_init (value, type); g_value_init (value, type);
@ -171,8 +191,8 @@ gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
} }
void void
gtk_tree_data_list_value_to_node (GtkTreeDataList *list, _gtk_tree_data_list_value_to_node (GtkTreeDataList *list,
GValue *value) GValue *value)
{ {
switch (value->g_type) switch (value->g_type)
{ {

20
gtk/gtktreedatalist.h
View File

@ -39,17 +39,17 @@ struct _GtkTreeDataList
} data; } data;
}; };
/* FIXME: s/gtk/_gtk/g to make internal */ void _gtk_tree_data_list_push_allocator (GAllocator *allocator);
void gtk_tree_data_list_push_allocator (GAllocator *allocator); void _gtk_tree_data_list_pop_allocator (void);
void gtk_tree_data_list_pop_allocator (void); GtkTreeDataList *_gtk_tree_data_list_alloc (void);
GtkTreeDataList *gtk_tree_data_list_alloc (void); void _gtk_tree_data_list_free (GtkTreeDataList *list,
void gtk_tree_data_list_free (GtkTreeDataList *list); GType *column_headers);
void _gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
GType type,
GValue *value);
void _gtk_tree_data_list_value_to_node (GtkTreeDataList *list,
GValue *value);
void gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
GType type,
GValue *value);
void gtk_tree_data_list_value_to_node (GtkTreeDataList *list,
GValue *value);
#endif /* __GTK_TREE_DATA_LIST_H__ */ #endif /* __GTK_TREE_DATA_LIST_H__ */

72
gtk/gtktreemodel.c
View File

@ -392,6 +392,8 @@ gtk_tree_path_down (GtkTreePath *path)
gint gint
gtk_tree_model_get_n_columns (GtkTreeModel *tree_model) gtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
{ {
g_return_val_if_fail (tree_model != NULL, 0);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), 0);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_n_columns != NULL, 0); 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); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_n_columns) (tree_model);
@ -418,10 +420,14 @@ gtk_tree_model_get_iter (GtkTreeModel *tree_model,
gint *indices; gint *indices;
gint depth, i; gint depth, i;
g_return_val_if_fail (tree_model != NULL, FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (path != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
if (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_iter != NULL) 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); 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); indices = gtk_tree_path_get_indices (path);
depth = gtk_tree_path_get_depth (path); depth = gtk_tree_path_get_depth (path);
@ -440,31 +446,6 @@ gtk_tree_model_get_iter (GtkTreeModel *tree_model,
return TRUE; 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: * gtk_tree_model_get_path:
* @tree_model: A #GtkTreeModel. * @tree_model: A #GtkTreeModel.
@ -479,13 +460,16 @@ GtkTreePath *
gtk_tree_model_get_path (GtkTreeModel *tree_model, gtk_tree_model_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
g_return_val_if_fail (tree_model != NULL, NULL);
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), NULL);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_path != NULL, NULL); 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, iter); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_path) (tree_model, iter);
} }
/** /**
* gtk_tree_model_iter_get_value: * gtk_tree_model_get_value:
* @tree_model: A #GtkTreeModel. * @tree_model: A #GtkTreeModel.
* @iter: The #GtkTreeIter. * @iter: The #GtkTreeIter.
* @column: The column to lookup the value at. * @column: The column to lookup the value at.
@ -495,14 +479,18 @@ gtk_tree_model_get_path (GtkTreeModel *tree_model,
* #g_value_unset needs to be called on it. * #g_value_unset needs to be called on it.
**/ **/
void void
gtk_tree_model_iter_get_value (GtkTreeModel *tree_model, gtk_tree_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
g_return_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_get_value != NULL); g_return_if_fail (tree_model != NULL);
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (value != NULL);
g_return_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->get_value != NULL);
(* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_get_value) (tree_model, iter, column, value); (* GTK_TREE_MODEL_GET_IFACE (tree_model)->get_value) (tree_model, iter, column, value);
} }
/** /**
@ -519,6 +507,9 @@ gboolean
gtk_tree_model_iter_next (GtkTreeModel *tree_model, gtk_tree_model_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
g_return_val_if_fail (tree_model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_next != NULL, FALSE); 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); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_next) (tree_model, iter);
@ -541,6 +532,9 @@ gtk_tree_model_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent) GtkTreeIter *parent)
{ {
g_return_val_if_fail (tree_model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_children != NULL, FALSE); 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); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_children) (tree_model, iter, parent);
@ -559,6 +553,9 @@ gboolean
gtk_tree_model_iter_has_child (GtkTreeModel *tree_model, gtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
g_return_val_if_fail (tree_model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_has_child != NULL, FALSE); 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); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_has_child) (tree_model, iter);
@ -577,7 +574,10 @@ gint
gtk_tree_model_iter_n_children (GtkTreeModel *tree_model, gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children != NULL, -1); g_return_val_if_fail (tree_model != NULL, 0);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), 0);
g_return_val_if_fail (iter != NULL, 0);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children != NULL, 0);
return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children) (tree_model, iter); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_n_children) (tree_model, iter);
} }
@ -602,6 +602,10 @@ gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *parent, GtkTreeIter *parent,
gint n) gint n)
{ {
g_return_val_if_fail (tree_model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (n >= 0, FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_nth_child != NULL, FALSE); 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); return (* GTK_TREE_MODEL_GET_IFACE (tree_model)->iter_nth_child) (tree_model, iter, parent, n);

12
gtk/gtktreemodel.h
View File

@ -71,11 +71,9 @@ struct _GtkTreeModelIface
gboolean (* get_iter) (GtkTreeModel *tree_model, gboolean (* get_iter) (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreePath *path); GtkTreePath *path);
gboolean (* iter_invalid) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreePath *(* get_path) (GtkTreeModel *tree_model, GtkTreePath *(* get_path) (GtkTreeModel *tree_model,
GtkTreeIter *iter); GtkTreeIter *iter);
void (* iter_get_value) (GtkTreeModel *tree_model, void (* get_value) (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value); GValue *value);
@ -83,7 +81,7 @@ struct _GtkTreeModelIface
GtkTreeIter *iter); GtkTreeIter *iter);
gboolean (* iter_children) (GtkTreeModel *tree_model, gboolean (* iter_children) (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *child); GtkTreeIter *parent);
gboolean (* iter_has_child) (GtkTreeModel *tree_model, gboolean (* iter_has_child) (GtkTreeModel *tree_model,
GtkTreeIter *iter); GtkTreeIter *iter);
gint (* iter_n_children) (GtkTreeModel *tree_model, gint (* iter_n_children) (GtkTreeModel *tree_model,
@ -94,7 +92,7 @@ struct _GtkTreeModelIface
gint n); gint n);
gboolean (* iter_parent) (GtkTreeModel *tree_model, gboolean (* iter_parent) (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent); GtkTreeIter *child);
}; };
@ -133,11 +131,9 @@ GType gtk_tree_model_get_column_type (GtkTreeModel *tree_model,
gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model, gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreePath *path); GtkTreePath *path);
gboolean gtk_tree_model_iter_invalid (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreePath *gtk_tree_model_get_path (GtkTreeModel *tree_model, GtkTreePath *gtk_tree_model_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter); GtkTreeIter *iter);
void gtk_tree_model_iter_get_value (GtkTreeModel *tree_model, void gtk_tree_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value); GValue *value);

138
gtk/gtktreestore.c
View File

@ -43,7 +43,7 @@ static void gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
static gint gtk_tree_store_get_n_columns (GtkTreeModel *tree_model); static gint gtk_tree_store_get_n_columns (GtkTreeModel *tree_model);
static GtkTreePath *gtk_tree_store_get_path (GtkTreeModel *tree_model, static GtkTreePath *gtk_tree_store_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter); GtkTreeIter *iter);
static void gtk_tree_store_iter_get_value (GtkTreeModel *tree_model, static void gtk_tree_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value); GValue *value);
@ -152,7 +152,7 @@ gtk_tree_store_tree_model_init (GtkTreeModelIface *iface)
{ {
iface->get_n_columns = gtk_tree_store_get_n_columns; iface->get_n_columns = gtk_tree_store_get_n_columns;
iface->get_path = gtk_tree_store_get_path; iface->get_path = gtk_tree_store_get_path;
iface->iter_get_value = gtk_tree_store_iter_get_value; iface->get_value = gtk_tree_store_get_value;
iface->iter_next = gtk_tree_store_iter_next; iface->iter_next = gtk_tree_store_iter_next;
iface->iter_children = gtk_tree_store_iter_children; iface->iter_children = gtk_tree_store_iter_children;
iface->iter_has_child = gtk_tree_store_iter_has_child; iface->iter_has_child = gtk_tree_store_iter_has_child;
@ -312,10 +312,10 @@ gtk_tree_store_get_path (GtkTreeModel *tree_model,
static void static void
gtk_tree_store_iter_get_value (GtkTreeModel *tree_model, gtk_tree_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
GtkTreeDataList *list; GtkTreeDataList *list;
gint tmp_column = column; gint tmp_column = column;
@ -333,9 +333,9 @@ gtk_tree_store_iter_get_value (GtkTreeModel *tree_model,
if (list) if (list)
{ {
gtk_tree_data_list_node_to_value (list, _gtk_tree_data_list_node_to_value (list,
GTK_TREE_STORE (tree_model)->column_headers[column], GTK_TREE_STORE (tree_model)->column_headers[column],
value); value);
} }
else else
{ {
@ -452,10 +452,10 @@ gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
* manipulations on it's own. * manipulations on it's own.
*/ */
void void
gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store, gtk_tree_store_set_cell (GtkTreeStore *tree_store,
GtkTreeIter *iter, GtkTreeIter *iter,
gint column, gint column,
GValue *value) GValue *value)
{ {
GtkTreeDataList *list; GtkTreeDataList *list;
GtkTreeDataList *prev; GtkTreeDataList *prev;
@ -470,7 +470,7 @@ gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store,
{ {
if (column == 0) if (column == 0)
{ {
gtk_tree_data_list_value_to_node (list, value); _gtk_tree_data_list_value_to_node (list, value);
return; return;
} }
@ -481,29 +481,32 @@ gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store,
if (G_NODE (iter->tree_node)->data == NULL) if (G_NODE (iter->tree_node)->data == NULL)
{ {
G_NODE (iter->tree_node)->data = list = gtk_tree_data_list_alloc (); G_NODE (iter->tree_node)->data = list = _gtk_tree_data_list_alloc ();
list->next = NULL; list->next = NULL;
} }
else else
{ {
list = prev->next = gtk_tree_data_list_alloc (); list = prev->next = _gtk_tree_data_list_alloc ();
list->next = NULL; list->next = NULL;
} }
while (column != 0) while (column != 0)
{ {
list->next = gtk_tree_data_list_alloc (); list->next = _gtk_tree_data_list_alloc ();
list = list->next; list = list->next;
list->next = NULL; list->next = NULL;
column --; column --;
} }
gtk_tree_data_list_value_to_node (list, value); _gtk_tree_data_list_value_to_node (list, value);
gtk_signal_emit_by_name (GTK_OBJECT (tree_store),
"changed",
NULL, iter);
} }
void void
gtk_tree_store_iter_setv (GtkTreeStore *tree_store, gtk_tree_store_setv (GtkTreeStore *tree_store,
GtkTreeIter *iter, GtkTreeIter *iter,
va_list var_args) va_list var_args)
{ {
gint column; gint column;
@ -535,10 +538,10 @@ gtk_tree_store_iter_setv (GtkTreeStore *tree_store,
break; break;
} }
gtk_tree_store_iter_set_cell (tree_store, gtk_tree_store_set_cell (tree_store,
iter, iter,
column, column,
&value); &value);
g_value_unset (&value); g_value_unset (&value);
@ -547,23 +550,23 @@ gtk_tree_store_iter_setv (GtkTreeStore *tree_store,
} }
void void
gtk_tree_store_iter_set (GtkTreeStore *tree_store, gtk_tree_store_set (GtkTreeStore *tree_store,
GtkTreeIter *iter, GtkTreeIter *iter,
...) ...)
{ {
va_list var_args; va_list var_args;
g_return_if_fail (GTK_IS_TREE_STORE (tree_store)); g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
va_start (var_args, iter); va_start (var_args, iter);
gtk_tree_store_iter_setv (tree_store, iter, var_args); gtk_tree_store_setv (tree_store, iter, var_args);
va_end (var_args); va_end (var_args);
} }
void void
gtk_tree_store_iter_getv (GtkTreeStore *tree_store, gtk_tree_store_getv (GtkTreeStore *tree_store,
GtkTreeIter *iter, GtkTreeIter *iter,
va_list var_args) va_list var_args)
{ {
gint column; gint column;
@ -582,7 +585,7 @@ gtk_tree_store_iter_getv (GtkTreeStore *tree_store,
break; break;
} }
gtk_tree_store_iter_get_value (GTK_TREE_MODEL (tree_store), iter, column, &value); gtk_tree_store_get_value (GTK_TREE_MODEL (tree_store), iter, column, &value);
G_VALUE_LCOPY (&value, var_args, &error); G_VALUE_LCOPY (&value, var_args, &error);
if (error) if (error)
@ -603,24 +606,25 @@ gtk_tree_store_iter_getv (GtkTreeStore *tree_store,
} }
void void
gtk_tree_store_iter_get (GtkTreeStore *tree_store, gtk_tree_store_get (GtkTreeStore *tree_store,
GtkTreeIter *iter, GtkTreeIter *iter,
...) ...)
{ {
va_list var_args; va_list var_args;
g_return_if_fail (GTK_IS_TREE_STORE (tree_store)); g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
va_start (var_args, iter); va_start (var_args, iter);
gtk_tree_store_iter_getv (tree_store, iter, var_args); gtk_tree_store_getv (tree_store, iter, var_args);
va_end (var_args); va_end (var_args);
} }
void void
gtk_tree_store_iter_remove (GtkTreeStore *model, gtk_tree_store_remove (GtkTreeStore *model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
GtkTreePath *path; GtkTreePath *path;
GNode *parent; GNode *parent;
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
@ -628,8 +632,14 @@ gtk_tree_store_iter_remove (GtkTreeStore *model,
parent = G_NODE (iter->tree_node)->parent; parent = G_NODE (iter->tree_node)->parent;
if (G_NODE (iter->tree_node)->data)
_gtk_tree_data_list_free ((GtkTreeDataList *) G_NODE (iter->tree_node)->data,
model->column_headers);
path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter); path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
g_node_destroy (G_NODE (iter->tree_node)); g_node_destroy (G_NODE (iter->tree_node));
model->stamp++;
gtk_signal_emit_by_name (GTK_OBJECT (model), gtk_signal_emit_by_name (GTK_OBJECT (model),
"deleted", "deleted",
path); path);
@ -645,10 +655,10 @@ gtk_tree_store_iter_remove (GtkTreeStore *model,
} }
void void
gtk_tree_store_iter_insert (GtkTreeStore *model, gtk_tree_store_insert (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent, GtkTreeIter *parent,
gint position) gint position)
{ {
GtkTreePath *path; GtkTreePath *path;
@ -670,10 +680,10 @@ gtk_tree_store_iter_insert (GtkTreeStore *model,
} }
void void
gtk_tree_store_iter_insert_before (GtkTreeStore *model, gtk_tree_store_insert_before (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent, GtkTreeIter *parent,
GtkTreeIter *sibling) GtkTreeIter *sibling)
{ {
GtkTreePath *path; GtkTreePath *path;
GNode *parent_node = NULL; GNode *parent_node = NULL;
@ -708,10 +718,10 @@ gtk_tree_store_iter_insert_before (GtkTreeStore *model,
} }
void void
gtk_tree_store_iter_insert_after (GtkTreeStore *model, gtk_tree_store_insert_after (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent, GtkTreeIter *parent,
GtkTreeIter *sibling) GtkTreeIter *sibling)
{ {
GtkTreePath *path; GtkTreePath *path;
GNode *parent_node; GNode *parent_node;
@ -746,9 +756,9 @@ gtk_tree_store_iter_insert_after (GtkTreeStore *model,
} }
void void
gtk_tree_store_iter_prepend (GtkTreeStore *model, gtk_tree_store_prepend (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent) GtkTreeIter *parent)
{ {
GNode *parent_node; GNode *parent_node;
@ -793,14 +803,14 @@ gtk_tree_store_iter_prepend (GtkTreeStore *model,
} }
else else
{ {
gtk_tree_store_iter_insert_after (model, iter, parent, NULL); gtk_tree_store_insert_after (model, iter, parent, NULL);
} }
} }
void void
gtk_tree_store_iter_append (GtkTreeStore *model, gtk_tree_store_append (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent) GtkTreeIter *parent)
{ {
GNode *parent_node; GNode *parent_node;
@ -845,13 +855,13 @@ gtk_tree_store_iter_append (GtkTreeStore *model,
} }
else else
{ {
gtk_tree_store_iter_insert_before (model, iter, parent, NULL); gtk_tree_store_insert_before (model, iter, parent, NULL);
} }
} }
void void
gtk_tree_store_get_root (GtkTreeStore *model, gtk_tree_store_get_root_iter (GtkTreeStore *model,
GtkTreeIter *iter) GtkTreeIter *iter)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (GTK_IS_TREE_STORE (model)); g_return_if_fail (GTK_IS_TREE_STORE (model));
@ -863,9 +873,9 @@ gtk_tree_store_get_root (GtkTreeStore *model,
gboolean gboolean
gtk_tree_store_iter_is_ancestor (GtkTreeStore *model, gtk_tree_store_is_ancestor (GtkTreeStore *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *descendant) GtkTreeIter *descendant)
{ {
g_return_val_if_fail (model != NULL, FALSE); g_return_val_if_fail (model != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_STORE (model), FALSE); g_return_val_if_fail (GTK_IS_TREE_STORE (model), FALSE);

105
gtk/gtktreestore.h
View File

@ -66,58 +66,59 @@ struct _GtkTreeStoreClass
}; };
GtkType gtk_tree_store_get_type (void); GtkType gtk_tree_store_get_type (void);
GtkTreeStore *gtk_tree_store_new (void); GtkTreeStore *gtk_tree_store_new (void);
GtkTreeStore *gtk_tree_store_new_with_values (gint n_columns,
...); 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_n_columns (GtkTreeStore *tree_store,
void gtk_tree_store_set_column_type (GtkTreeStore *store, gint n_columns);
gint column, void gtk_tree_store_set_column_type (GtkTreeStore *store,
GType type); gint column,
void gtk_tree_store_iter_set_cell (GtkTreeStore *tree_store, GType type);
GtkTreeIter *iter, void gtk_tree_store_set_cell (GtkTreeStore *tree_store,
gint column, GtkTreeIter *iter,
GValue *value); gint column,
void gtk_tree_store_iter_set (GtkTreeStore *tree_store, GValue *value);
GtkTreeIter *iter, void gtk_tree_store_set (GtkTreeStore *tree_store,
...); GtkTreeIter *iter,
void gtk_tree_store_iter_setv (GtkTreeStore *tree_store, ...);
GtkTreeIter *iter, void gtk_tree_store_setv (GtkTreeStore *tree_store,
va_list var_args); GtkTreeIter *iter,
void gtk_tree_store_iter_get (GtkTreeStore *tree_store, va_list var_args);
GtkTreeIter *iter, void gtk_tree_store_get (GtkTreeStore *tree_store,
...); GtkTreeIter *iter,
void gtk_tree_store_iter_getv (GtkTreeStore *tree_store, ...);
GtkTreeIter *iter, void gtk_tree_store_getv (GtkTreeStore *tree_store,
va_list var_args); GtkTreeIter *iter,
void gtk_tree_store_iter_remove (GtkTreeStore *tree_store, va_list var_args);
GtkTreeIter *iter); void gtk_tree_store_remove (GtkTreeStore *tree_store,
void gtk_tree_store_iter_insert (GtkTreeStore *tree_store, GtkTreeIter *iter);
GtkTreeIter *iter, void gtk_tree_store_insert (GtkTreeStore *tree_store,
GtkTreeIter *parent, GtkTreeIter *iter,
gint position); GtkTreeIter *parent,
void gtk_tree_store_iter_insert_before (GtkTreeStore *tree_store, gint position);
GtkTreeIter *iter, void gtk_tree_store_insert_before (GtkTreeStore *tree_store,
GtkTreeIter *parent, GtkTreeIter *iter,
GtkTreeIter *sibling); GtkTreeIter *parent,
void gtk_tree_store_iter_insert_after (GtkTreeStore *tree_store, GtkTreeIter *sibling);
GtkTreeIter *iter, void gtk_tree_store_insert_after (GtkTreeStore *tree_store,
GtkTreeIter *parent, GtkTreeIter *iter,
GtkTreeIter *sibling); GtkTreeIter *parent,
void gtk_tree_store_iter_prepend (GtkTreeStore *tree_store, GtkTreeIter *sibling);
GtkTreeIter *iter, void gtk_tree_store_prepend (GtkTreeStore *tree_store,
GtkTreeIter *parent); GtkTreeIter *iter,
void gtk_tree_store_iter_append (GtkTreeStore *tree_store, GtkTreeIter *parent);
GtkTreeIter *iter, void gtk_tree_store_append (GtkTreeStore *tree_store,
GtkTreeIter *parent); GtkTreeIter *iter,
void gtk_tree_store_get_root (GtkTreeStore *tree_store, GtkTreeIter *parent);
GtkTreeIter *iter); void gtk_tree_store_get_root_iter (GtkTreeStore *tree_store,
gboolean gtk_tree_store_iter_is_ancestor (GtkTreeStore *tree_store, GtkTreeIter *iter);
GtkTreeIter *iter, gboolean gtk_tree_store_is_ancestor (GtkTreeStore *tree_store,
GtkTreeIter *descendant); GtkTreeIter *iter,
gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store, GtkTreeIter *descendant);
GtkTreeIter *iter); gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
GtkTreeIter *iter);
#ifdef __cplusplus #ifdef __cplusplus

16
gtk/gtktreeview.c
View File

@ -1917,7 +1917,7 @@ gtk_tree_view_changed (GtkTreeModel *model,
gint height; gint height;
gboolean dirty_marked; gboolean dirty_marked;
g_return_if_fail (path != NULL || node != NULL); g_return_if_fail (path != NULL || iter != NULL);
if (path == NULL) if (path == NULL)
path = gtk_tree_model_get_path (model, iter); path = gtk_tree_model_get_path (model, iter);
@ -2067,7 +2067,7 @@ gtk_tree_view_child_toggled (GtkTreeModel *model,
GtkRBTree *tree; GtkRBTree *tree;
GtkRBNode *node; GtkRBNode *node;
g_return_if_fail (path != NULL || node != NULL); g_return_if_fail (path != NULL || iter != NULL);
if (iter) if (iter)
real_iter = *iter; real_iter = *iter;
@ -2237,9 +2237,6 @@ gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkRBNode *temp = NULL; GtkRBNode *temp = NULL;
gint max_height; gint max_height;
if (gtk_tree_model_iter_invalid (tree_view->priv->model, iter))
return;
do do
{ {
max_height = 0; max_height = 0;
@ -2285,10 +2282,6 @@ gtk_tree_view_calc_size (GtkTreeView *tree_view,
gint max_height; gint max_height;
gint i; gint i;
/* FIXME: Make this function robust against internal inconsistencies! */
if (gtk_tree_model_iter_invalid (tree_view->priv->model, iter))
return;
TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL); TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
while (temp->left != tree->nil) while (temp->left != tree->nil)
@ -2399,11 +2392,6 @@ gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
GtkTreeIter child; GtkTreeIter child;
gboolean is_all_dirty; gboolean is_all_dirty;
/* FIXME: Make this function robust against internal inconsistencies! */
if (gtk_tree_model_iter_invalid (tree_view->priv->model,
iter))
return;
TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL); TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
while (temp->left != tree->nil) while (temp->left != tree->nil)

7
gtk/gtktreeviewcolumn.c
View File

@ -336,10 +336,9 @@ gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column,
while (list && list->next) while (list && list->next)
{ {
gtk_tree_model_iter_get_value (tree_model, gtk_tree_model_get_value (tree_model, iter,
iter, GPOINTER_TO_INT (list->next->data),
GPOINTER_TO_INT (list->next->data), &value);
&value);
g_object_set_param (cell, (gchar *) list->data, &value); g_object_set_param (cell, (gchar *) list->data, &value);
g_value_unset (&value); g_value_unset (&value);
list = list->next->next; list = list->next->next;

87
gtk/treestoretest.c
View File

@ -1,7 +1,7 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <stdlib.h> #include <stdlib.h>
GtkObject *model; GtkTreeStore *model;
static void static void
selection_changed (GtkTreeSelection *selection, selection_changed (GtkTreeSelection *selection,
@ -21,7 +21,7 @@ node_set (GtkTreeIter *iter)
gchar *str; gchar *str;
str = g_strdup_printf ("FOO: %d", i++); str = g_strdup_printf ("FOO: %d", i++);
gtk_tree_store_iter_set (GTK_TREE_STORE (model), iter, 0, str, -1); gtk_tree_store_set (model, iter, 0, str, -1);
g_free (str); g_free (str);
} }
@ -33,8 +33,7 @@ iter_remove (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_remove (GTK_TREE_STORE (model), gtk_tree_store_remove (model, &selected);
&selected);
} }
} }
@ -49,17 +48,17 @@ iter_insert (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert (GTK_TREE_STORE (model), gtk_tree_store_insert (model,
&iter, &iter,
&selected, &selected,
atoi (gtk_entry_get_text (GTK_ENTRY (entry)))); atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
} }
else else
{ {
gtk_tree_store_iter_insert (GTK_TREE_STORE (model), gtk_tree_store_insert (model,
&iter, &iter,
NULL, NULL,
atoi (gtk_entry_get_text (GTK_ENTRY (entry)))); atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
} }
node_set (&iter); node_set (&iter);
@ -74,17 +73,17 @@ iter_insert_before (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model), gtk_tree_store_insert_before (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model), gtk_tree_store_insert_before (model,
&iter, &iter,
NULL, NULL,
NULL); NULL);
} }
node_set (&iter); node_set (&iter);
@ -99,17 +98,17 @@ iter_insert_after (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model), gtk_tree_store_insert_after (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model), gtk_tree_store_insert_after (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
node_set (&iter); node_set (&iter);
@ -124,15 +123,15 @@ iter_prepend (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_prepend (GTK_TREE_STORE (model), gtk_tree_store_prepend (model,
&iter, &iter,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_prepend (GTK_TREE_STORE (model), gtk_tree_store_prepend (model,
&iter, &iter,
NULL); NULL);
} }
node_set (&iter); node_set (&iter);
@ -147,15 +146,11 @@ iter_append (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), gtk_tree_store_append (model, &iter, &selected);
&iter,
&selected);
} }
else else
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), gtk_tree_store_append (model, &iter, NULL);
&iter,
NULL);
} }
node_set (&iter); node_set (&iter);
@ -194,7 +189,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL);
/* buttons */ /* buttons */
button = gtk_button_new_with_label ("gtk_tree_store_iter_remove"); button = gtk_button_new_with_label ("gtk_tree_store_remove");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed", "selection_changed",
@ -203,7 +198,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert"); button = gtk_button_new_with_label ("gtk_tree_store_insert");
hbox = gtk_hbox_new (FALSE, 8); hbox = gtk_hbox_new (FALSE, 8);
entry = gtk_entry_new (); entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
@ -213,7 +208,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_before"); button = gtk_button_new_with_label ("gtk_tree_store_insert_before");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
@ -222,7 +217,7 @@ make_window ()
button); button);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_after"); button = gtk_button_new_with_label ("gtk_tree_store_insert_after");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
@ -231,11 +226,11 @@ make_window ()
button); button);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_prepend"); button = gtk_button_new_with_label ("gtk_tree_store_prepend");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_iter_append"); button = gtk_button_new_with_label ("gtk_tree_store_append");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view);

87
tests/treestoretest.c
View File

@ -1,7 +1,7 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <stdlib.h> #include <stdlib.h>
GtkObject *model; GtkTreeStore *model;
static void static void
selection_changed (GtkTreeSelection *selection, selection_changed (GtkTreeSelection *selection,
@ -21,7 +21,7 @@ node_set (GtkTreeIter *iter)
gchar *str; gchar *str;
str = g_strdup_printf ("FOO: %d", i++); str = g_strdup_printf ("FOO: %d", i++);
gtk_tree_store_iter_set (GTK_TREE_STORE (model), iter, 0, str, -1); gtk_tree_store_set (model, iter, 0, str, -1);
g_free (str); g_free (str);
} }
@ -33,8 +33,7 @@ iter_remove (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_remove (GTK_TREE_STORE (model), gtk_tree_store_remove (model, &selected);
&selected);
} }
} }
@ -49,17 +48,17 @@ iter_insert (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert (GTK_TREE_STORE (model), gtk_tree_store_insert (model,
&iter, &iter,
&selected, &selected,
atoi (gtk_entry_get_text (GTK_ENTRY (entry)))); atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
} }
else else
{ {
gtk_tree_store_iter_insert (GTK_TREE_STORE (model), gtk_tree_store_insert (model,
&iter, &iter,
NULL, NULL,
atoi (gtk_entry_get_text (GTK_ENTRY (entry)))); atoi (gtk_entry_get_text (GTK_ENTRY (entry))));
} }
node_set (&iter); node_set (&iter);
@ -74,17 +73,17 @@ iter_insert_before (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model), gtk_tree_store_insert_before (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_insert_before (GTK_TREE_STORE (model), gtk_tree_store_insert_before (model,
&iter, &iter,
NULL, NULL,
NULL); NULL);
} }
node_set (&iter); node_set (&iter);
@ -99,17 +98,17 @@ iter_insert_after (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model), gtk_tree_store_insert_after (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_insert_after (GTK_TREE_STORE (model), gtk_tree_store_insert_after (model,
&iter, &iter,
NULL, NULL,
&selected); &selected);
} }
node_set (&iter); node_set (&iter);
@ -124,15 +123,15 @@ iter_prepend (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_prepend (GTK_TREE_STORE (model), gtk_tree_store_prepend (model,
&iter, &iter,
&selected); &selected);
} }
else else
{ {
gtk_tree_store_iter_prepend (GTK_TREE_STORE (model), gtk_tree_store_prepend (model,
&iter, &iter,
NULL); NULL);
} }
node_set (&iter); node_set (&iter);
@ -147,15 +146,11 @@ iter_append (GtkWidget *button, GtkTreeView *tree_view)
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&selected)) &selected))
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), gtk_tree_store_append (model, &iter, &selected);
&iter,
&selected);
} }
else else
{ {
gtk_tree_store_iter_append (GTK_TREE_STORE (model), gtk_tree_store_append (model, &iter, NULL);
&iter,
NULL);
} }
node_set (&iter); node_set (&iter);
@ -194,7 +189,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_main_quit, NULL);
/* buttons */ /* buttons */
button = gtk_button_new_with_label ("gtk_tree_store_iter_remove"); button = gtk_button_new_with_label ("gtk_tree_store_remove");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
"selection_changed", "selection_changed",
@ -203,7 +198,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_remove, tree_view);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert"); button = gtk_button_new_with_label ("gtk_tree_store_insert");
hbox = gtk_hbox_new (FALSE, 8); hbox = gtk_hbox_new (FALSE, 8);
entry = gtk_entry_new (); entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
@ -213,7 +208,7 @@ make_window ()
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert, tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_before"); button = gtk_button_new_with_label ("gtk_tree_store_insert_before");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_before, tree_view);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
@ -222,7 +217,7 @@ make_window ()
button); button);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_insert_after"); button = gtk_button_new_with_label ("gtk_tree_store_insert_after");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_insert_after, tree_view);
gtk_signal_connect (GTK_OBJECT (selection), gtk_signal_connect (GTK_OBJECT (selection),
@ -231,11 +226,11 @@ make_window ()
button); button);
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_iter_prepend"); button = gtk_button_new_with_label ("gtk_tree_store_prepend");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_prepend, tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_iter_append"); button = gtk_button_new_with_label ("gtk_tree_store_append");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view); gtk_signal_connect (GTK_OBJECT (button), "clicked", iter_append, tree_view);