static GtkTreePath *
xml_tree_model_get_path (GtkTreeModel *model,
GtkTreeIter *iter)
{
g_return_val_if_fail (XML_IS_TREE_MODEL(model), NULL);
g_return_val_if_fail (iter != NULL, NULL);
xmlNodePtr node = iter->user_data;
xmlNodePtr tree = xmlDocGetRootElementN(xmlGetRoot(XML_TREE_MODEL(model)));
GtkTreePath *path = gtk_tree_path_new();
int i = 0;
while(node != tree && node != NULL) {
if(xmlPreviousElementSiblingN(node) == NULL) {
gtk_tree_path_prepend_index (path, i);
node = xmlGetParentNode (node);
i = 0;
} else {
node = xmlPreviousElementSiblingN(node);
i++;
}
}
gtk_tree_path_prepend_index (path, 0);
return path;
}
static GtkTreePath *fm_dir_tree_model_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter)
{
GList *item_list;
GList *children;
FmDirTreeItem *dir_tree_item;
GtkTreePath *path;
int i;
FmDirTreeModel *dir_tree_model = FM_DIR_TREE_MODEL (tree_model);
g_return_val_if_fail (dir_tree_model, NULL);
g_return_val_if_fail (iter->stamp == dir_tree_model->stamp, NULL);
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (iter->user_data != NULL, NULL);
item_list = (GList*)iter->user_data;
dir_tree_item = (FmDirTreeItem*)item_list->data;
// Root Item...
if (dir_tree_item->parent == NULL)
{
i = g_list_position (dir_tree_model->root_list, item_list);
path = gtk_tree_path_new_first ();
gtk_tree_path_get_indices (path)[0] = i;
}
else
{
path = gtk_tree_path_new ();
do
{
FmDirTreeItem *parent_item = (FmDirTreeItem*)dir_tree_item->parent->data;
children = parent_item->children;
i = g_list_position (children, item_list);
if (G_UNLIKELY (i == -1))
{
gtk_tree_path_free (path);
return NULL;
}
gtk_tree_path_prepend_index (path, i);
// Go One Level Up...
item_list = dir_tree_item->parent;
dir_tree_item = (FmDirTreeItem*)item_list->data;
} while (G_UNLIKELY (dir_tree_item->parent));
// We Have Reached Toplevel...
children = dir_tree_model->root_list;
i = g_list_position (children, item_list);
gtk_tree_path_prepend_index (path, i);
}
return path;
}
static GtkTreePath *
nemo_list_model_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter)
{
GtkTreePath *path;
NemoListModel *model;
GSequenceIter *ptr;
FileEntry *file_entry;
model = (NemoListModel *)tree_model;
g_return_val_if_fail (iter->stamp == model->details->stamp, NULL);
if (g_sequence_iter_is_end (iter->user_data)) {
/* FIXME is this right? */
return NULL;
}
path = gtk_tree_path_new ();
ptr = iter->user_data;
while (ptr != NULL) {
gtk_tree_path_prepend_index (path, g_sequence_iter_get_position (ptr));
file_entry = g_sequence_get (ptr);
if (file_entry->parent != NULL) {
ptr = file_entry->parent->ptr;
} else {
ptr = NULL;
}
}
return path;
}
static GtkTreePath* get_path (GtkTreeModel* tree_model,
GtkTreeIter* iter)
{
GtkTreePath* path;
UgtkNodeList* ulist;
UgetNode* node;
gint n;
g_return_val_if_fail (UGTK_IS_NODE_LIST(tree_model), NULL);
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (iter->user_data != NULL, NULL);
node = iter->user_data;
path = gtk_tree_path_new();
ulist = UGTK_NODE_LIST (tree_model);
if (ulist->root_visible == FALSE)
n = uget_node_fake_position (node->real, node);
else {
if (ulist->root == node)
n = 0;
else
n = uget_node_fake_position (node->real, node) + 1;
}
gtk_tree_path_prepend_index (path, n);
return path;
}
static GtkTreePath *_is_store_get_path(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
IsStore *self;
IsStorePrivate *priv;
GtkTreePath *path;
GSequenceIter *entry_iter;
g_return_val_if_fail(IS_IS_STORE(tree_model), NULL);
g_return_val_if_fail(iter != NULL, NULL);
self = IS_STORE(tree_model);
priv = self->priv;
g_return_val_if_fail(iter->stamp == priv->stamp, NULL);
g_assert(iter->user_data);
path = gtk_tree_path_new();
entry_iter = (GSequenceIter *)iter->user_data;
while (entry_iter != NULL) {
IsStoreEntry *entry;
gtk_tree_path_prepend_index(path,
g_sequence_iter_get_position(entry_iter));
entry = (IsStoreEntry *)g_sequence_get(entry_iter);
entry_iter = entry->parent;
}
return path;
}
static GtkTreePath *
gtk_real_model_types_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GtkTreePath *retval;
GType type;
GType parent;
g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL);
g_return_val_if_fail (iter != NULL, NULL);
type = GPOINTER_TO_INT (iter->user_data);
retval = gtk_tree_path_new ();
parent = g_type_parent (type);
while (parent != G_TYPE_INVALID)
{
GType* children = g_type_children (parent, NULL);
gint i = 0;
if (!children || children[0] == G_TYPE_INVALID)
{
g_warning ("bad iterator?");
return NULL;
}
while (children[i] != type)
++i;
gtk_tree_path_prepend_index (retval, i);
g_free (children);
type = parent;
parent = g_type_parent (parent);
}
/* The fundamental type itself is the index on the toplevel */
gtk_tree_path_prepend_index (retval, type);
return retval;
}
/*#
@method prepend_index GtkTreePath
@brief Prepends a new index to a path.
@param index The index
As a result, the depth of the path is increased.
*/
FALCON_FUNC TreePath::prepend_index( VMARG )
{
Item* i_idx = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_idx || !i_idx->isInteger() )
throw_inv_params( "I" );
#endif
MYSELF;
gtk_tree_path_prepend_index( self->getTreePath(), i_idx->asInteger() );
}
static GtkTreePath *
ast_get_path(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GtkTreePath *path;
AstNode *root = AST_NODE(tree_model);
AstNode *node = AST_NODE(iter->user_data);
path = gtk_tree_path_new();
while (node != root) {
gtk_tree_path_prepend_index(path, node->index);
node = node->parent;
}
return path;
}
static GtkTreePath *
gnc_tree_model_owner_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GncTreeModelOwner *model = GNC_TREE_MODEL_OWNER (tree_model);
GncTreeModelOwnerPrivate *priv;
GncOwner *owner;
GtkTreePath *path;
gint i;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (model), NULL);
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (iter->user_data != NULL, NULL);
g_return_val_if_fail (iter->stamp == model->stamp, NULL);
ENTER("model %p, iter %s", model, iter_to_string(iter));
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
if (priv->owner_list == NULL)
{
LEAVE("failed (1)");
return NULL;
}
owner = (GncOwner *) iter->user_data;
path = gtk_tree_path_new ();
i = g_list_index (priv->owner_list, owner);
if (i == -1)
{
gtk_tree_path_free (path);
LEAVE("failed (3)");
return NULL;
}
gtk_tree_path_prepend_index (path, i);
{
gchar *path_string = gtk_tree_path_to_string(path);
LEAVE("path (4) %s", path_string);
g_free(path_string);
}
return path;
}
static GtkTreePath *
proto_tree_model_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter)
{
ProtoTreeModel *model;
GtkTreePath *path;
proto_node *node;
g_return_val_if_fail(PROTO_IS_TREE(tree_model), NULL);
model = (ProtoTreeModel *) tree_model;
g_return_val_if_fail(iter != NULL, NULL);
g_return_val_if_fail(iter->stamp == model->stamp, NULL);
node = (proto_node *)iter->user_data;
g_return_val_if_fail(node != model->protocol_tree, NULL);
path = gtk_tree_path_new();
do {
proto_node *cur = node;
proto_node *node_i;
int pos;
node = node->parent;
pos = 0;
for (node_i = node->first_child; node_i; node_i = node_i->next) {
if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(node_i)) {
if (node_i == cur)
break;
pos++;
}
}
g_assert(node_i != NULL);
gtk_tree_path_prepend_index(path, pos);
} while (node != model->protocol_tree);
return path;
}
static GtkTreePath *
dspy_introspection_model_get_path (GtkTreeModel *model,
GtkTreeIter *iter)
{
DspyIntrospectionModel *self = (DspyIntrospectionModel *)model;
GtkTreePath *path;
DspyNode *node;
LOG_DEBUG (G_STRFUNC);
g_assert (DSPY_IS_INTROSPECTION_MODEL (self));
g_assert (iter != NULL);
node = iter->user_data;
g_assert (node != NULL);
g_assert (node->any.parent != NULL);
path = gtk_tree_path_new_first ();
g_assert (gtk_tree_path_get_depth (path) == 1);
for (; node->any.parent != NULL; node = node->any.parent)
{
gint pos = 0;
for (const GList *list = &node->any.link; list->prev; list = list->prev)
pos++;
gtk_tree_path_prepend_index (path, pos);
}
gtk_tree_path_up (path);
return g_steal_pointer (&path);
}
static VALUE
rg_prepend_index(VALUE self, VALUE index)
{
gtk_tree_path_prepend_index(_SELF(self), NUM2INT(index));
return self;
}
