static void
select_or_unselect_range(GtkTreeSelection *selection,
guint from, guint to,
gboolean select)
{
if (from == to)
return;
GtkTreePath *pathfrom = gtk_tree_path_new();
gtk_tree_path_append_index(pathfrom, from);
if (from+1 == to) {
if (select)
gtk_tree_selection_select_path(selection, pathfrom);
else
gtk_tree_selection_unselect_path(selection, pathfrom);
}
else {
GtkTreePath *pathto = gtk_tree_path_new();
gtk_tree_path_append_index(pathto, to);
if (select)
gtk_tree_selection_select_range(selection, pathfrom, pathto);
else
gtk_tree_selection_unselect_range(selection, pathfrom, pathto);
gtk_tree_path_free(pathto);
}
gtk_tree_path_free(pathfrom);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE path;
GtkTreePath* widget;
if (argc == 1) {
path = argv[0];
if (TYPE(path) == T_STRING){
widget = gtk_tree_path_new_from_string(RVAL2CSTR(path));
} else {
widget = gtk_tree_path_new();
gtk_tree_path_append_index(widget, NUM2INT(path));
}
if (widget == NULL)
rb_raise(rb_eArgError, "Invalid path %s was passed.", RVAL2CSTR(path));
} else {
int i;
widget = gtk_tree_path_new();
for (i = 0; i < argc; i++)
gtk_tree_path_append_index(widget, NUM2INT(argv[i]));
}
G_INITIALIZE(self, widget);
return Qnil;
}
static void
update_length (BtSequenceGridModel * model, gulong old_length,
gulong new_length)
{
GtkTreePath *path;
glong i;
GST_INFO ("resize length : %lu -> %lu", old_length, new_length);
if (old_length < new_length) {
GtkTreeIter iter;
// trigger row-inserted
iter.stamp = model->priv->stamp;
for (i = old_length; i < new_length; i++) {
iter.user_data = GUINT_TO_POINTER (i);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
}
} else if (old_length > new_length) {
// trigger row-deleted
for (i = old_length - 1; i >= new_length; i--) {
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
gtk_tree_path_free (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 void
on_sequence_pattern_usage_changed (BtSequence * sequence, BtPattern * pattern,
gpointer user_data)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (user_data);
BtMachine *machine;
g_object_get (pattern, "machine", &machine, NULL);
if (machine) {
if (machine == model->priv->machine) {
GSequence *seq = model->priv->seq;
GtkTreeIter iter;
GtkTreePath *path;
// find the item by pattern
iter.stamp = model->priv->stamp;
iter.user_data = g_sequence_lookup (seq, pattern, model_item_cmp, NULL);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path,
g_sequence_iter_get_position (iter.user_data));
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
}
g_object_unref (machine);
}
}
static void
bt_pattern_list_model_add (BtPatternListModel * model, BtCmdPattern * pattern)
{
GSequence *seq = model->priv->seq;
GtkTreePath *path;
GtkTreeIter iter;
gint position;
// check if pattern is internal
if (model->priv->skip_internal) {
if (!BT_IS_PATTERN (pattern)) {
GST_INFO ("not adding internal pattern to model");
return;
}
}
GST_INFO ("add pattern to model");
// insert new entry
iter.stamp = model->priv->stamp;
iter.user_data =
g_sequence_insert_sorted (seq, pattern, model_item_cmp, NULL);
position = g_sequence_iter_get_position (iter.user_data);
g_signal_connect_object (pattern, "notify::name",
G_CALLBACK (on_pattern_name_changed), (gpointer) model, 0);
// signal to the view/app
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, position);
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
GST_DEBUG ("inserted pattern %p at position %d", pattern, position);
}
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 *
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;
}
/*
* get the top or bottom visible row in the connection list
* returns TOP row if (int top) is > 0 and list is not empty
* returns BOTTOM row if (int top) is 0 and visible area is full
*/
static void gtkui_connection_list_row(int top, struct row_pairs *pair) {
GtkTreeIter iter; /* points to a specific row */
GtkTreePath *path = NULL; /* for finding the first visible row */
GtkTreeModel *model = NULL; /* points to the list data */
GdkRectangle rect; /* holds coordinates of visible rows */
int wx = 0, wy = 0; /* for converting tree view coords to widget coords */
void *row = NULL;
if(!ls_conns || !pair)
return;
/* in case we don't get a row */
pair->conn = NULL;
model = GTK_TREE_MODEL (ls_conns);
if(gtk_tree_model_get_iter_first(model, &iter)) {
gtk_tree_view_get_visible_rect(GTK_TREE_VIEW(treeview), &rect);
/* get the first visible row */
gtk_tree_view_tree_to_widget_coords(GTK_TREE_VIEW(treeview), rect.x, (top)?rect.y:rect.height, &wx, &wy);
path = gtk_tree_path_new();
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), wx+2, (top)?wy+2:wy-2, &path, NULL, NULL, NULL)) {
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get (model, &iter, 9, &row, -1);
pair->iter = iter;
pair->conn = row;
}
if(path)
gtk_tree_path_free(path);
}
return;
}
void GtkCatalogModel_change_record(GtkCatalogModel * custom_list, gint recordIndex) {
GtkTreeIter iter;
GtkTreePath *path;
CatalogRecord record;
g_return_if_fail (GTKCATALOGMODEL_IS_LIST(custom_list));
g_return_if_fail (recordIndex < CatalogDB_getRecordCount(custom_list->catalogDB));
CatalogRecord_init(&record);
CatalogDB_readRecord(custom_list->catalogDB, recordIndex, &record);
if (CatalogRecord_edit(&record)) {
CatalogDB_writeRecord(custom_list->catalogDB, recordIndex, &record);
/* inform the tree view and other interested objects
* (e.g. tree row references) that we have inserted
* a new row, and where it was inserted */
path = gtk_tree_path_new();
gtk_tree_path_append_index(path, recordIndex);
GtkCatalogModel_get_iter(GTK_TREE_MODEL(custom_list), &iter, path);
gtk_tree_model_row_changed(GTK_TREE_MODEL(custom_list), path, &iter);
gtk_tree_path_free(path);
}
CatalogRecord_finalize(&record);
}
void ptk_file_list_sort ( PtkFileList* list )
{
GHashTable* old_order;
gint *new_order;
GtkTreePath *path;
GList* l;
int i;
if( list->n_files <=1 )
return;
old_order = g_hash_table_new( g_direct_hash, g_direct_equal );
/* save old order */
for( i = 0, l = list->files; l; l = l->next, ++i )
g_hash_table_insert( old_order, l, GINT_TO_POINTER(i) );
/* sort the list */
list->files = g_list_sort_with_data( list->files,
ptk_file_list_compare, list );
/* save new order */
new_order = g_new( int, list->n_files );
for( i = 0, l = list->files; l; l = l->next, ++i )
new_order[i] = GPOINTER_TO_INT( g_hash_table_lookup( old_order, l ) );
g_hash_table_destroy( old_order );
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list),
path, NULL, new_order);
gtk_tree_path_free (path);
g_free( new_order );
}
bool gbase_list_change_record(GBaseList *self, const gchar *value, unsigned int row, unsigned int col) {
g_return_val_if_fail(GBASE_IS_LIST(self), false);
g_return_val_if_fail(col < BASE_COL_COUNT, false);
bool ret = false;
GtkTreePath *path = gtk_tree_path_new();
gtk_tree_path_append_index(path, row);
GtkTreeIter iter;
gbase_list_get_iter(GTK_TREE_MODEL(self), &iter, path);
base_entry_t *entry = base_iter_value(USER_DATA_2_BASE_ITER(iter.user_data));
if (entry && base_entry_change(self->base_ctx, entry, value, col)) {
gtk_tree_model_row_changed(GTK_TREE_MODEL(self), path, &iter);
if (row == 0 && entry->number.len && entry->name.len && entry->fname.len) {
base_prepend_placeholder(self->base_ctx);
gbase_list_row_prepended(self);
ret = true;
}
}
gtk_tree_path_free(path);
return ret;
}
static GtkTreePath *
egg_column_model_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
EggColumnModel *column_model = (EggColumnModel *) tree_model;
GtkTreePath *path;
gint i = 0;
GList *list;
g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), NULL);
g_return_val_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, NULL);
for (list = column_model->columns; list; list = list->next)
{
if (list == (GList *)iter->user_data)
break;
i++;
}
if (list == NULL)
return NULL;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
return path;
}
void
custom_list_append (CustomList * custom_list, chanlistrow * newrecord)
{
GtkTreeIter iter;
GtkTreePath *path;
gulong newsize;
guint pos;
if (custom_list->num_rows >= custom_list->num_alloc)
{
custom_list->num_alloc += 64;
newsize = custom_list->num_alloc * sizeof (chanlistrow *);
custom_list->rows = g_realloc (custom_list->rows, newsize);
}
/* TODO: Binary search insert? */
pos = custom_list->num_rows;
custom_list->rows[pos] = newrecord;
custom_list->num_rows++;
newrecord->pos = pos;
/* inform the tree view and other interested objects
* (e.g. tree row references) that we have inserted
* a new row, and where it was inserted */
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, newrecord->pos);
/* custom_list_get_iter(GTK_TREE_MODEL(custom_list), &iter, path);*/
iter.user_data = newrecord;
gtk_tree_model_row_inserted (GTK_TREE_MODEL (custom_list), path, &iter);
gtk_tree_path_free (path);
}
static void
on_pattern_name_changed (BtPattern * pattern, GParamSpec * arg,
gpointer user_data)
{
BtSequenceGridModel *model = BT_SEQUENCE_GRID_MODEL (user_data);
BtCmdPattern *that_pattern;
GtkTreePath *path;
GtkTreeIter iter;
gulong i, j;
gulong length = model->priv->length;
gulong tracks = model->priv->tracks;
iter.stamp = model->priv->stamp;
// find all affected rows and signal updates
// FIXME(ensonic): skip tracks with wrong machine (do a first run and build a list of tracks)
for (i = 0; i < length; i++) {
for (j = 0; j < tracks; j++) {
if ((that_pattern =
bt_sequence_get_pattern (model->priv->sequence, i, j))) {
if (that_pattern == (BtCmdPattern *) pattern) {
iter.user_data = GUINT_TO_POINTER (i);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
g_object_unref (that_pattern);
break;
} else {
g_object_unref (that_pattern);
}
}
}
}
}
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;
}
void
nemo_list_model_file_changed (NemoListModel *model, NemoFile *file,
NemoDirectory *directory)
{
FileEntry *parent_file_entry;
GtkTreeIter iter;
GtkTreePath *path, *parent_path;
GSequenceIter *ptr;
int pos_before, pos_after, length, i, old;
int *new_order;
gboolean has_iter;
GSequence *files;
ptr = lookup_file (model, file, directory);
if (!ptr) {
return;
}
pos_before = g_sequence_iter_get_position (ptr);
g_sequence_sort_changed (ptr, nemo_list_model_file_entry_compare_func, model);
pos_after = g_sequence_iter_get_position (ptr);
if (pos_before != pos_after) {
/* The file moved, we need to send rows_reordered */
parent_file_entry = ((FileEntry *)g_sequence_get (ptr))->parent;
if (parent_file_entry == NULL) {
has_iter = FALSE;
parent_path = gtk_tree_path_new ();
files = model->details->files;
} else {
has_iter = TRUE;
nemo_list_model_ptr_to_iter (model, parent_file_entry->ptr, &iter);
parent_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
files = parent_file_entry->files;
}
length = g_sequence_get_length (files);
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0, old = 0; i < length; ++i) {
if (i == pos_after) {
new_order[i] = pos_before;
} else {
if (old == pos_before)
old++;
new_order[i] = old++;
}
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
parent_path, has_iter ? &iter : NULL, new_order);
gtk_tree_path_free (parent_path);
g_free (new_order);
}
static void sp_font_selector_family_select_row(GtkTreeSelection *selection,
SPFontSelector *fsel)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkListStore *store;
GtkTreePath *path;
GList *list=0;
if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return;
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_model_get (model, &iter, 1, &list, -1);
fsel->familyidx = gtk_tree_path_get_indices (path)[0];
fsel->styleidx = 0;
store = gtk_list_store_new (1, G_TYPE_STRING);
for ( ; list ; list = list->next )
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, (char*)list->data, -1);
}
gtk_tree_view_set_model (GTK_TREE_VIEW (fsel->style_treeview), GTK_TREE_MODEL (store));
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, 0);
gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->style_treeview)), path);
gtk_tree_path_free (path);
}
/**
* return the path of the selected transaction
* according line_in_transaction
*
* \param line_in_transaction
*
* \return a newly allocated GtkTreePath
* */
GtkTreePath *transaction_list_select_get_path ( gint line_in_transaction )
{
CustomRecord *record;
GtkTreePath *path;
CustomList *custom_list;
custom_list = transaction_model_get_model ();
g_return_val_if_fail ( custom_list != NULL, NULL );
record = custom_list -> selected_row;
if (!record)
return NULL;
/* if not child, go to the first row */
if (!record -> mother_row)
record = record -> transaction_records[line_in_transaction];
/* if something is wrong in line_in_transaction, it's possible we are not
* on the same transaction */
if (! record ||
record -> transaction_pointer != custom_list -> selected_row -> transaction_pointer)
return NULL;
path = gtk_tree_path_new ();
if (record -> mother_row)
/* it's a child, need to get the path of the mother */
gtk_tree_path_append_index (path, record -> mother_row -> filtered_pos);
gtk_tree_path_append_index (path, record -> filtered_pos);
return path;
}
/**
* unselect the current selection of the custom list
*
* \param
*
* \return
* */
void transaction_list_select_unselect (void)
{
CustomRecord *record = NULL;
GtkTreePath *path;
GtkTreeIter iter;
gint i;
CustomList *custom_list;
custom_list = transaction_model_get_model ();
g_return_if_fail ( custom_list != NULL );
g_return_if_fail ( custom_list -> selected_row != NULL );
iter.stamp = custom_list->stamp;
/* get the selected row */
record = custom_list -> selected_row;
if (record)
{
/* si l'opération n'est pas visible on sort */
if ( ( record -> mother_row && record -> mother_row -> filtered_pos == -1 )
||
record -> filtered_pos == -1 )
{
custom_list -> selected_row = NULL;
return;
}
/* get the path of the row */
path = gtk_tree_path_new ();
if (record -> mother_row)
/* it's a child, need to get the path of the mother */
gtk_tree_path_append_index (path, record -> mother_row -> filtered_pos);
gtk_tree_path_append_index (path, record -> filtered_pos);
for (i=0 ; i < custom_list -> nb_rows_by_transaction ; i++)
{
record -> row_bg = record -> row_bg_save;
record -> row_bg_save = NULL;
/* inform the world that the row has changed */
iter.user_data = record;
gtk_tree_model_row_changed(GTK_TREE_MODEL(custom_list), path, &iter);
/* if the selection was a child, we stop now, only 1 line */
if (record -> mother_row)
break;
/* go to the next row of the transaction */
record = custom_list -> visibles_rows [record -> filtered_pos + 1];
gtk_tree_path_next (path);
}
gtk_tree_path_free (path);
}
custom_list -> selected_row = NULL;
}
/*
* converts a tree iter into a tree path (ie. the
* physical position of that row in the list).
*/
static GtkTreePath *gbase_list_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter) {
g_return_val_if_fail(GBASE_IS_LIST(tree_model), NULL);
g_return_val_if_fail(iter != NULL, NULL);
GtkTreePath *path = gtk_tree_path_new();
gtk_tree_path_append_index(path, base_iter_index(USER_DATA_2_BASE_ITER(iter->user_data)));
return path;
}
static void
on_pattern_name_changed (BtPattern * pattern, GParamSpec * arg,
gpointer user_data)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (user_data);
GSequence *seq = model->priv->seq;
GtkTreePath *path;
GtkTreeIter iter;
gint pos1, pos2 = -1, len;
// find the item by pattern (cannot use model_item_cmp, as id has changed)
iter.stamp = model->priv->stamp;
len = g_sequence_get_length (seq);
for (pos1 = 0; pos1 < len; pos1++) {
iter.user_data = g_sequence_get_iter_at_pos (seq, pos1);
if (g_sequence_get (iter.user_data) == pattern) {
g_sequence_sort_changed (iter.user_data, model_item_cmp, NULL);
pos2 = g_sequence_iter_get_position (iter.user_data);
break;
}
}
if (G_UNLIKELY (pos2 == -1))
return;
GST_DEBUG ("pos %d -> %d", pos1, pos2);
// signal updates
if (pos1 != pos2) {
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, pos1);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
gtk_tree_path_free (path);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, pos2);
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
} else {
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, pos2);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
}
}
static GtkTreePath *
fm_tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter)
{
FMTreeModel *tree_model;
TreeNode *node, *parent, *cnode;
GtkTreePath *path;
GtkTreeIter parent_iter;
int i;
g_return_val_if_fail (FM_IS_TREE_MODEL (model), NULL);
tree_model = FM_TREE_MODEL (model);
g_return_val_if_fail (iter_is_valid (tree_model, iter), NULL);
node = iter->user_data;
if (node == NULL) {
parent = iter->user_data2;
if (parent == NULL) {
return gtk_tree_path_new ();
}
} else {
parent = node->parent;
if (parent == NULL) {
i = 0;
for (cnode = tree_model->details->root_node; cnode != node; cnode = cnode->next) {
i++;
}
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
return path;
}
}
parent_iter.stamp = iter->stamp;
parent_iter.user_data = parent;
parent_iter.user_data2 = NULL;
parent_iter.user_data3 = NULL;
path = fm_tree_model_get_path (model, &parent_iter);
gtk_tree_path_append_index (path, tree_node_get_child_index (parent, node));
return path;
}
static void gbase_list_row_prepended(GBaseList *self) {
GtkTreePath *path = gtk_tree_path_new();
gtk_tree_path_append_index(path, 0); // base_prepend() inserts at head => position 0
GtkTreeIter iter;
gbase_list_get_iter(GTK_TREE_MODEL(self), &iter, path);
gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path, &iter);
gtk_tree_path_free(path);
}
static void
row_deleted (EDateTimeList *date_time_list,
gint n)
{
GtkTreePath *path;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, n);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (date_time_list), path);
gtk_tree_path_free (path);
}
static void
fm_list_model_sort (FMListModel *model)
{
GtkTreePath *path;
path = gtk_tree_path_new ();
fm_list_model_sort_file_entries (model, model->details->files, path);
gtk_tree_path_free (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;
}
void XAP_UnixDialog_Language::_populateWindowData()
{
GtkListStore *model;
GtkTreeIter iter;
model = gtk_list_store_new (2,
G_TYPE_STRING,
G_TYPE_INT);
for (UT_uint32 i = 0; i < m_iLangCount; i++)
{
// Add a new row to the model
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
0, m_ppLanguages[i],
1, i,
-1);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(m_pLanguageList), reinterpret_cast<GtkTreeModel *>(model));
g_object_unref (model);
// now select first item in box
gtk_widget_grab_focus (m_pLanguageList);
if (m_pLanguage) {
gint foundAt = -1;
for (UT_uint32 i = 0; i < m_iLangCount; i++)
{
if (!g_ascii_strcasecmp(m_pLanguage, m_ppLanguages[i])) {
foundAt = i;
break;
}
}
if (foundAt != -1) {
GtkTreePath* path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, foundAt);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_pLanguageList),
path,
gtk_tree_view_get_column (GTK_TREE_VIEW(m_pLanguageList), 0),
FALSE);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(m_pLanguageList),
path, NULL, TRUE, 0.5, 0.0);
gtk_widget_grab_focus (m_pLanguageList);
gtk_tree_path_free (path);
}
}
}
static GtkTreePath *
custom_list_get_path (GtkTreeModel * tree_model, GtkTreeIter * iter)
{
GtkTreePath *path;
chanlistrow *record;
record = (chanlistrow *) iter->user_data;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, record->pos);
return path;
}
static GtkTreePath *
proto_hier_tree_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter)
{
ProtoHierTreeModel *model;
GtkTreePath *path;
int pos;
int p_id;
void *cookie;
g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), NULL);
model = (ProtoHierTreeModel *) tree_model;
g_return_val_if_fail(iter != NULL, NULL);
g_return_val_if_fail(iter->stamp == model->stamp, FALSE);
p_id = proto_get_data_protocol(iter->user_data);
path = gtk_tree_path_new();
/* protocol */
{
int id;
/* XXX, assuming that protocols can't be disabled! */
pos = 0;
for (id = proto_get_first_protocol(&cookie); id != p_id && id != -1; id = proto_get_next_protocol(&cookie)) {
protocol_t *p = find_protocol_by_id(id);
if (!proto_is_protocol_enabled(p))
continue;
pos++;
}
gtk_tree_path_append_index(path, pos);
}
/* field */
if (iter->user_data2 != NULL) {
header_field_info *hfinfo;
pos = 0;
for (hfinfo = proto_get_first_protocol_field(p_id, &cookie); hfinfo && hfinfo != iter->user_data3; hfinfo = proto_get_next_protocol_field(&cookie)) {
if (hfinfo->same_name_prev_id != -1)
continue;
pos++;
}
gtk_tree_path_append_index(path, pos);
}
return path;
}
