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;
}
