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 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 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); } } }
/** * 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; }
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; }
/** * select the transaction by the record * static function * * \param record the CustomRecord to select * * \return TRUE ok, FALSE problem * */ static gboolean transaction_list_select_record ( CustomRecord *record ) { GtkTreePath *path; GtkTreeIter iter; gint i; gint selected_transaction; CustomList *custom_list; custom_list = transaction_model_get_model (); g_return_val_if_fail ( custom_list != NULL, FALSE ); g_return_val_if_fail ( record != NULL, FALSE ); /* get the transaction number */ selected_transaction = gsb_data_transaction_get_transaction_number (record -> transaction_pointer); /* record is the first row of the transaction to select */ custom_list -> selected_row = record; /* get the path of the row we want to select */ 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); /* colorize the record */ for (i=0 ; i < custom_list -> nb_rows_by_transaction ; i++) { record -> row_bg_save = record -> row_bg; record -> row_bg = gsb_rgba_get_couleur ( "couleur_selection" ); /* 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); } /** update account and other stuff */ gsb_transactions_list_selection_changed (selected_transaction); return TRUE; }
static void fm_dir_tree_model_add_place_holder_child_item (FmDirTreeModel *dir_tree_model, GList *parent_node, GtkTreePath *tree_path, gboolean emit_signal) { FmDirTreeItem *parent_item = (FmDirTreeItem*) parent_node->data; // Check if the parent node can expand... FmFileInfo *file_info = parent_item->file_info; FmPath *path = fm_file_info_get_path (file_info); TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_add_place_holder_child_item: file = %s\t emit_signal = %d\n", fm_file_info_get_name (file_info), emit_signal); // don't expand the trash can... // TODO_axl: add a can_expand flag into the file_info if (fm_path_is_trash (path) && fm_path_is_root (path)) return; TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_add_place_holder_child_item: create place holder\n\n"); FmDirTreeItem *dir_tree_item = fm_dir_tree_item_new (dir_tree_model, parent_node, NULL); parent_item->children = g_list_prepend (parent_item->children, dir_tree_item); if (!emit_signal) return; GtkTreeIter it; fm_dir_tree_model_item_to_tree_iter (dir_tree_model, parent_item->children, &it); gtk_tree_path_append_index (tree_path, 0); gtk_tree_model_row_inserted (GTK_TREE_MODEL (dir_tree_model), tree_path, &it); gtk_tree_path_up (tree_path); }
static void nemo_list_model_sort_file_entries (NemoListModel *model, GSequence *files, GtkTreePath *path) { GSequenceIter **old_order; GtkTreeIter iter; int *new_order; int length; int i; FileEntry *file_entry; gboolean has_iter; length = g_sequence_get_length (files); if (length <= 1) { return; } /* generate old order of GSequenceIter's */ old_order = g_new (GSequenceIter *, length); for (i = 0; i < length; ++i) { GSequenceIter *ptr = g_sequence_get_iter_at_pos (files, i); file_entry = g_sequence_get (ptr); if (file_entry->files != NULL) { gtk_tree_path_append_index (path, i); nemo_list_model_sort_file_entries (model, file_entry->files, path); gtk_tree_path_up (path); } old_order[i] = ptr; } /* sort */ g_sequence_sort (files, nemo_list_model_file_entry_compare_func, model); /* generate new order */ new_order = g_new (int, length); /* Note: new_order[newpos] = oldpos */ for (i = 0; i < length; ++i) { new_order[g_sequence_iter_get_position (old_order[i])] = i; } /* Let the world know about our new order */ g_assert (new_order != NULL); has_iter = FALSE; if (gtk_tree_path_get_depth (path) != 0) { gboolean get_iter_result; has_iter = TRUE; get_iter_result = gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path); g_assert (get_iter_result); } gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model), path, has_iter ? &iter : NULL, new_order); g_free (old_order); 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; }
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_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); }
/* sort using merge sort */ static void gbf_project_model_sort (GtkTreeModel *model, GtkTreePath *begin, GtkTreePath *end, GtkTreeIterCompareFunc compare_func, gpointer user_data) { GtkTreePath *half; gint depth; /* Empty list are sorted */ if (gtk_tree_path_compare (begin, end) >= 0) { return; } /* Split the list in two */ half = gtk_tree_path_copy (begin); gtk_tree_path_up (half); gtk_tree_path_append_index (half, (gtk_tree_path_get_indices_with_depth (begin, &depth)[depth -1] + gtk_tree_path_get_indices_with_depth (end, &depth)[depth - 1]) / 2); /* List with a single element are sorted too */ if (gtk_tree_path_compare (begin, half) < 0) { gbf_project_model_sort (model, begin, half, compare_func, user_data); gbf_project_model_sort (model, half, end, compare_func, user_data); gbf_project_model_merge (model, begin, half, end, compare_func, user_data); } gtk_tree_path_free (half); }
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); }
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); }
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; }
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); } } } } }
/* * 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 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); }
/*# @method append_index GtkTreePath @brief Appends a new index to a path. @param index The index. As a result, the depth of the path is increased. */ FALCON_FUNC TreePath::append_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_append_index( self->getTreePath(), i_idx->asInteger() ); }
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 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); }
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 * disasm_list_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkTreePath *path; DisasmList *disasm_list; g_return_val_if_fail (DISASM_IS_LIST(tree_model), NULL); g_return_val_if_fail (iter != NULL, NULL); g_return_val_if_fail (iter->user_data2 != NULL, NULL); disasm_list = DISASM_LIST(tree_model); path = gtk_tree_path_new(); gtk_tree_path_append_index(path, ((unsigned int)(long)(iter->user_data - disasm_list->startAddr)) / 4 + PRELINES); if(((long)iter->user_data2)!=-1) gtk_tree_path_append_index(path, ((uint32)(long)iter->user_data2)); return 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 * _dtm_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkTreePath *result; int index = 0; if (!NODE_DIAGRAM(iter) && !NODE_LAYER(iter) && !NODE_OBJECT(iter)) { /* the root path */ return gtk_tree_path_new_first (); } result = gtk_tree_path_new (); if (NODE_DIAGRAM(iter)) { GList *list = dia_open_diagrams(); gtk_tree_path_append_index (result, g_list_index (list, NODE_DIAGRAM(iter))); } if (NODE_LAYER(iter)) { g_return_val_if_fail (NODE_DIAGRAM(iter) == layer_get_parent_diagram (NODE_LAYER(iter)), NULL); index = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index >= 0 && NODE_OBJECT(iter)) { g_return_val_if_fail (NODE_LAYER(iter) == dia_object_get_parent_layer (NODE_OBJECT(iter)), NULL); index = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index < 0) { gtk_tree_path_free (result); return NULL; } return result; }
static void row_updated (EDateTimeList *date_time_list, gint n) { GtkTreePath *path; GtkTreeIter iter; path = gtk_tree_path_new (); gtk_tree_path_append_index (path, n); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (date_time_list), &iter, path)) gtk_tree_model_row_changed (GTK_TREE_MODEL (date_time_list), path, &iter); gtk_tree_path_free (path); }
GtkTreePath * pygtk_tree_path_from_pyobject(PyObject *object) { if (PyString_Check(object)) { GtkTreePath *path; path = gtk_tree_path_new_from_string(PyString_AsString(object)); return path; } else if (PyInt_Check(object)) { GtkTreePath *path; path = gtk_tree_path_new(); gtk_tree_path_append_index(path, PyInt_AsLong(object)); return path; } else if (PyTuple_Check(object)) { GtkTreePath *path; guint len, i; len = PyTuple_Size(object); if (len < 1) return NULL; path = gtk_tree_path_new(); for (i = 0; i < len; i++) { PyObject *item = PyTuple_GetItem(object, i); gint index = PyInt_AsLong(item); if (PyErr_Occurred()) { gtk_tree_path_free(path); PyErr_Clear(); return NULL; } gtk_tree_path_append_index(path, index); } return path; } return NULL; }