#include "gtktreeview.h"
#include "gtktreeprivate.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
if (! tree_model_type)
{
- static const GTypeInfo tree_model_info =
+ const GTypeInfo tree_model_info =
{
sizeof (GtkTreeModelIface), /* class_size */
gtk_tree_model_base_init, /* base_init */
};
tree_model_type =
- g_type_register_static (G_TYPE_INTERFACE, "GtkTreeModel",
+ g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeModel"),
&tree_model_info, 0);
g_type_interface_add_prerequisite (tree_model_type, G_TYPE_OBJECT);
GType row_deleted_params[1];
GType rows_reordered_params[3];
- row_inserted_params[0] = GTK_TYPE_TREE_PATH;
+ row_inserted_params[0] = GTK_TYPE_TREE_PATH | G_SIGNAL_TYPE_STATIC_SCOPE;
row_inserted_params[1] = GTK_TYPE_TREE_ITER;
- row_deleted_params[0] = GTK_TYPE_TREE_PATH;
+ row_deleted_params[0] = GTK_TYPE_TREE_PATH | G_SIGNAL_TYPE_STATIC_SCOPE;
- rows_reordered_params[0] = GTK_TYPE_TREE_PATH;
+ rows_reordered_params[0] = GTK_TYPE_TREE_PATH | G_SIGNAL_TYPE_STATIC_SCOPE;
rows_reordered_params[1] = GTK_TYPE_TREE_ITER;
rows_reordered_params[2] = G_TYPE_POINTER;
+ /**
+ * GtkTreeModel::row-changed:
+ * @tree_model: the #GtkTreeModel on which the signal is emitted
+ * @path: a #GtkTreePath identifying the changed row
+ * @iter: a valid #GtkTreeIter pointing to the changed row
+ *
+ * This signal is emitted when a row in the model has changed.
+ */
tree_model_signals[ROW_CHANGED] =
- g_signal_new ("row_changed",
+ g_signal_new (I_("row_changed"),
GTK_TYPE_TREE_MODEL,
- G_SIGNAL_RUN_LAST,
+ G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeModelIface, row_changed),
NULL, NULL,
_gtk_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
- GTK_TYPE_TREE_PATH,
+ GTK_TYPE_TREE_PATH | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TREE_ITER);
/* We need to get notification about structure changes
* is to keep proper ordering with respect to signal handlers
* connected normally and after.
*/
+
+ /**
+ * GtkTreeModel::row-inserted:
+ * @tree_model: the #GtkTreeModel on which the signal is emitted
+ * @path: a #GtkTreePath identifying the new row
+ * @iter: a valid #GtkTreeIter pointing to the new row
+ *
+ * This signal is emitted when a new row has been inserted in the model.
+ *
+ * Note that the row may still be empty at this point, since
+ * it is a common pattern to first insert an empty row, and
+ * then fill it with the desired values.
+ */
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, row_inserted_marshal);
tree_model_signals[ROW_INSERTED] =
- g_signal_newv ("row_inserted",
+ g_signal_newv (I_("row_inserted"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
G_TYPE_NONE, 2,
row_inserted_params);
+ /**
+ * GtkTreeModel::row-has-child-toggled:
+ * @tree_model: the #GtkTreeModel on which the signal is emitted
+ * @path: a #GtkTreePath identifying the row
+ * @iter: a valid #GtkTreeIter pointing to the row
+ *
+ * This signal is emitted when a row has gotten the first child row or lost
+ * its last child row.
+ */
tree_model_signals[ROW_HAS_CHILD_TOGGLED] =
- g_signal_new ("row_has_child_toggled",
+ g_signal_new (I_("row_has_child_toggled"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeModelIface, row_has_child_toggled),
NULL, NULL,
_gtk_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
- GTK_TYPE_TREE_PATH,
+ GTK_TYPE_TREE_PATH | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TREE_ITER);
+ /**
+ * GtkTreeModel::row-deleted:
+ * @tree_model: the #GtkTreeModel on which the signal is emitted
+ * @path: a #GtkTreePath identifying the row
+ *
+ * This signal is emitted when a row has been deleted.
+ *
+ * Note that no iterator is passed to the signal handler,
+ * since the row is already deleted.
+ *
+ * Implementations of GtkTreeModel must emit row-deleted
+ * <emphasis>before</emphasis> removing the node from its
+ * internal data structures. This is because models and
+ * views which access and monitor this model might have
+ * references on the node which need to be released in the
+ * row-deleted handler.
+ */
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, row_deleted_marshal);
tree_model_signals[ROW_DELETED] =
- g_signal_newv ("row_deleted",
+ g_signal_newv (I_("row_deleted"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
G_TYPE_NONE, 1,
row_deleted_params);
+ /**
+ * GtkTreeModel::rows-reordered:
+ * @tree_model: the #GtkTreeModel on which the signal is emitted
+ * @path: a #GtkTreePath identifying the tree node whose children
+ * have been reordered
+ * @iter: a valid #GtkTreeIter pointing to the node whose
+ *
+ * This signal is emitted when the children of a node in the #GtkTreeModel
+ * have been reordered.
+ *
+ * Note that this signal is <emphasis>not</emphasis> emitted
+ * when rows are reordered by DND, since this is implemented
+ * by removing and then reinserting the row.
+ */
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, rows_reordered_marshal);
tree_model_signals[ROWS_REORDERED] =
- g_signal_newv ("rows_reordered",
+ g_signal_newv (I_("rows_reordered"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
gtk_tree_path_new (void)
{
GtkTreePath *retval;
- retval = (GtkTreePath *) g_new (GtkTreePath, 1);
+ retval = g_new (GtkTreePath, 1);
retval->depth = 0;
retval->indices = NULL;
gchar *
gtk_tree_path_to_string (GtkTreePath *path)
{
- gchar *retval, *ptr;
- gint i;
+ gchar *retval, *ptr, *end;
+ gint i, n;
g_return_val_if_fail (path != NULL, NULL);
if (path->depth == 0)
return NULL;
- ptr = retval = (gchar *) g_new0 (char *, path->depth*8);
- g_sprintf (retval, "%d", path->indices[0]);
- while (*ptr != '\000')
+ n = path->depth * 12;
+ ptr = retval = g_new0 (gchar, n);
+ end = ptr + n;
+ g_snprintf (retval, end - ptr, "%d", path->indices[0]);
+ while (*ptr != '\000')
ptr++;
for (i = 1; i < path->depth; i++)
{
- g_sprintf (ptr, ":%d", path->indices[i]);
+ g_snprintf (ptr, end - ptr, ":%d", path->indices[i]);
while (*ptr != '\000')
ptr++;
}
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static ("GtkTreePath",
+ our_type = g_boxed_type_register_static (I_("GtkTreePath"),
(GBoxedCopyFunc) gtk_tree_path_copy,
(GBoxedFreeFunc) gtk_tree_path_free);
g_return_val_if_fail (iter != NULL, NULL);
- retval = g_new (GtkTreeIter, 1);
+ retval = g_slice_new (GtkTreeIter);
*retval = *iter;
return retval;
{
g_return_if_fail (iter != NULL);
- g_free (iter);
+ g_slice_free (GtkTreeIter, iter);
}
GType
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static ("GtkTreeIter",
+ our_type = g_boxed_type_register_static (I_("GtkTreeIter"),
(GBoxedCopyFunc) gtk_tree_iter_copy,
(GBoxedFreeFunc) gtk_tree_iter_free);
* @path: A #GtkTreePath pointing to the tree node whose children have been
* reordered
* @iter: A valid #GtkTreeIter pointing to the node whose children have been
- * reordered
+ * reordered, or %NULL if the depth of @path is 0.
* @new_order: an array of integers mapping the current position of each child
* to its old position before the re-ordering,
* i.e. @new_order<literal>[newpos] = oldpos</literal>.
* @func: A function to be called on each row
* @user_data: User data to passed to func.
*
- * Calls func on each node in model in a depth-first fashion. If func returns
- * %TRUE, then the tree ceases to be walked, and gtk_tree_model_foreach()
- * returns.
+ * Calls func on each node in model in a depth-first fashion.
+ * If @func returns %TRUE, then the tree ceases to be walked, and
+ * gtk_tree_model_foreach() returns.
**/
void
gtk_tree_model_foreach (GtkTreeModel *model,
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static ("GtkTreeRowReference",
+ our_type = g_boxed_type_register_static (I_("GtkTreeRowReference"),
(GBoxedCopyFunc) gtk_tree_row_reference_copy,
(GBoxedFreeFunc) gtk_tree_row_reference_free);
refs->list = NULL;
g_object_set_data_full (G_OBJECT (proxy),
- ROW_REF_DATA_STRING,
+ I_(ROW_REF_DATA_STRING),
refs, release_row_references);
}
if (refs->list == NULL)
{
g_object_set_data (G_OBJECT (reference->proxy),
- ROW_REF_DATA_STRING,
+ I_(ROW_REF_DATA_STRING),
NULL);
}
projects / ~andy / gtk / blobdiff