void UzblTreeTab::RebuildTree() { int i = 0; for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* cuz = (UzblInstance*)l->data; cuz->SetNum(i); cuz->SetPNum(-1); cuz->ClearChildren(); cuz->SetRowRef(NULL); i++; } for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* cuz = (UzblInstance*)l->data; if (cuz->GetParent() != NULL) { cuz->SetPNum(cuz->GetParent()->GetNum()); cuz->GetParent()->AddChild(cuz); } } totaltabs = i; if (currenttab >= totaltabs) currenttab = totaltabs-1; if (currenttab < 0) currenttab = 0; gtk_tree_store_clear(tabmodel); for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* iuz = ((UzblInstance*)l->data); GtkTreeIter iter; if (iuz->GetParent() != NULL) { GtkTreeIter piter; GtkTreeRowReference* pr = iuz->GetParent()->GetRowRef(); GtkTreePath* pp = gtk_tree_row_reference_get_path(pr); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &piter, pp); gtk_tree_store_append(tabmodel, &iter, &piter); } else { gtk_tree_store_append(tabmodel, &iter, NULL); } GtkTreePath* p = gtk_tree_model_get_path(GTK_TREE_MODEL(tabmodel), &iter); GtkTreeRowReference* ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(tabmodel), p); iuz->SetRowRef(ref); } gtk_tree_view_expand_all(tabtree); GtkTreeIter siter; UzblInstance* suz = (UzblInstance*)g_list_nth(uzblinstances, currenttab)->data; GtkTreeRowReference* sr = suz->GetRowRef(); GtkTreePath* sp = gtk_tree_row_reference_get_path(sr); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &siter, sp); GtkTreeSelection* sel = gtk_tree_view_get_selection(tabtree); gtk_tree_selection_select_iter(sel, &siter); }
void tabu_playlist_remove_selection (TabuPlaylist *playlist) { GtkTreeModel *store; GtkTreeIter iter; GtkTreePath *path; GList *selected; GList *references = NULL; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (TABU_PLAYLIST (playlist)->tree_view)); selected = gtk_tree_selection_get_selected_rows ( selection, &store ); while (selected != NULL) { references = g_list_append ( references, gtk_tree_row_reference_new (store, selected->data)); selected = g_list_next ( selected ); } references = g_list_first (references); while (references != NULL) { path = gtk_tree_row_reference_get_path (references->data); if (tabu_backend_is_playing()) { GtkTreePath *song_path = gtk_tree_row_reference_get_path (TABU_PLAYLIST (playlist)->reference); if (!strcmp(gtk_tree_path_to_string(path),gtk_tree_path_to_string(song_path))) { tabu_backend_stop(); TABU_PLAYLIST(playlist)->reference = NULL; } } /* ok, now remove the song from the playlist */ if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path)) { gtk_list_store_remove (GTK_LIST_STORE (store), &iter ); } gtk_tree_path_free (path); references = g_list_next ( references ); } g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free (references); g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected); }
void list_remove_selection(void) { GList *rows = gtk_tree_selection_get_selected_rows(gui.treeselection, &gui.treemodel); for (GList *i = rows; i != NULL; i = i->next) { GtkTreePath *path = i->data; GtkTreeRowReference *ref = gtk_tree_row_reference_new(gui.treemodel, i->data); i->data = ref; gtk_tree_path_free(path); } for (GList *i = rows; i != NULL; i = i->next) { GtkTreeRowReference *ref = i->data; GtkTreePath *path = gtk_tree_row_reference_get_path(ref); GtkTreeIter iter; if (gtk_tree_model_get_iter(gui.treemodel, &iter, path)) gtk_list_store_remove(gui.liststore, &iter); gtk_tree_path_free(path); gtk_tree_row_reference_free(ref); } g_list_free(rows); if (list_count_rows() == 0) { gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbutton_clear), false); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_treeview_clear), false); gtk_widget_set_sensitive(GTK_WIDGET(gui.button_hash), false); } }
GtkTreePath * gbf_project_model_get_project_root (GbfProjectModel *model) { GtkTreePath *path = NULL; g_return_val_if_fail (GBF_IS_PROJECT_MODEL (model), NULL); if (model->priv->root == NULL) { GtkTreeIter iter; gboolean valid; /* Search root group */ for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, NULL); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)) { GbfTreeData *data; gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1); if (data->type == GBF_TREE_NODE_ROOT) { path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); model->priv->root = gtk_tree_row_reference_new (GTK_TREE_MODEL (model), path); } } } else { path = gtk_tree_row_reference_get_path (model->priv->root); } return path; }
void UzblTreeTab::GotoTab(int i) { currenttab = i; if (currenttab < 0) currenttab = totaltabs -1; if (currenttab >= totaltabs) currenttab = 0; GtkTreeIter iter; UzblInstance* uz = (UzblInstance*)g_list_nth(uzblinstances, currenttab)->data; GtkTreeRowReference* r = uz->GetRowRef(); GtkTreePath* p = gtk_tree_row_reference_get_path(r); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &iter, p); int page = gtk_notebook_page_num(notebook, GTK_WIDGET(uz->GetSocket())); if (page == -1) { CloseTab(uz, false); return; } gtk_notebook_set_current_page(notebook, page); GtkTreeSelection* sel = gtk_tree_view_get_selection(tabtree); gtk_tree_selection_select_iter(sel, &iter); }
static void gtk_cell_view_set_cell_data (GtkCellView *cell_view) { GtkTreeIter iter; GtkTreePath *path; g_return_if_fail (cell_view->priv->displayed_row != NULL); path = gtk_tree_row_reference_get_path (cell_view->priv->displayed_row); if (!path) return; gtk_tree_model_get_iter (cell_view->priv->model, &iter, path); gtk_tree_path_free (path); gtk_cell_area_apply_attributes (cell_view->priv->area, cell_view->priv->model, &iter, FALSE, FALSE); if (cell_view->priv->draw_sensitive) { GList *l, *cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (cell_view->priv->area)); for (l = cells; l; l = l->next) { GObject *renderer = l->data; g_object_set (renderer, "sensitive", TRUE, NULL); } g_list_free (cells); } }
static void key_store_row_add (CryptUIKeyStore *ckstore, const gchar *key, GtkTreeIter *iter) { GtkTreePath *path; GtkTreeRowReference *ref; /* Do we already have a row for this key? */ ref = (GtkTreeRowReference*)g_hash_table_lookup (ckstore->priv->rows, key); if (ref != NULL) { /* If so return the previous reference */ path = gtk_tree_row_reference_get_path (ref); if (path != NULL) { gtk_tree_model_get_iter (GTK_TREE_MODEL (ckstore->priv->store), iter, path); return; } } gtk_tree_store_append (GTK_TREE_STORE (ckstore->priv->store), iter, NULL); path = gtk_tree_model_get_path (GTK_TREE_MODEL (ckstore->priv->store), iter); ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (ckstore->priv->store), path); gtk_tree_path_free (path); g_hash_table_replace (ckstore->priv->rows, (gchar*)key, ref); gtk_tree_store_set (GTK_TREE_STORE (ckstore->priv->store), iter, CRYPTUI_KEY_STORE_KEY, key, -1); }
GList* seahorse_object_model_get_rows_for_object (SeahorseObjectModel *self, GObject *object) { SeahorseObjectModelPrivate *pv = SEAHORSE_OBJECT_MODEL_GET_PRIVATE (self); GList *rows = NULL; SeahorseObjectRow *skrow; GtkTreeIter *iter; GtkTreePath *path; guint i; g_return_val_if_fail (SEAHORSE_IS_OBJECT_MODEL (self), NULL); g_return_val_if_fail (G_IS_OBJECT (object), NULL); skrow = (SeahorseObjectRow*)g_hash_table_lookup (pv->rows, object); if (!skrow) return NULL; for (i = 0; i < skrow->refs->len; i++) { path = gtk_tree_row_reference_get_path (g_ptr_array_index (skrow->refs, i)); if (path) { iter = g_new0(GtkTreeIter, 1); gtk_tree_model_get_iter (GTK_TREE_MODEL (self), iter, path); rows = g_list_prepend (rows, iter); gtk_tree_path_free (path); } } return rows; }
void ui_update_entry(struct playlist *playlist, struct playlist_entry *entry) { struct playlist_ui_ctx *playlist_ctx = get_playlist_ui_ctx(playlist); struct entry_ui_ctx *ctx = get_entry_ui_ctx(entry); if (ctx->rowref == NULL) return; lock_ui(); GtkTreePath *path = gtk_tree_row_reference_get_path(ctx->rowref); GtkTreeIter iter; gtk_tree_model_get_iter(GTK_TREE_MODEL(playlist_ctx->store), &iter, path); gtk_tree_path_free(path); char *name = get_display_name(get_entry_song(entry)); char buf[32]; unsigned int length = get_song_length(get_entry_song(entry)); if (length == -1) strcpy(buf, "-"); else sprintf(buf, "%d:%02d", length / (1000 * 60), (length / 1000) % 60); gtk_list_store_set(playlist_ctx->store, &iter, COL_NAME, name, COL_LENGTH, buf, -1); free(name); unlock_ui(); }
static void on_remove_autorun_choice_clicked(GtkButton *button, GtkTreeView *view) { GtkTreeSelection *tree_sel = gtk_tree_view_get_selection(view); GtkTreeModel *model; GList *rows = gtk_tree_selection_get_selected_rows(tree_sel, &model), *l; GtkTreeIter it; /* convert paths to references */ for (l = rows; l; l = l->next) { GtkTreePath *tp = l->data; l->data = gtk_tree_row_reference_new(model, tp); gtk_tree_path_free(tp); } /* remove rows from model */ for (l = rows; l; l = l->next) { if (gtk_tree_model_get_iter(model, &it, gtk_tree_row_reference_get_path(l->data))) { char *type; gtk_tree_model_get(model, &it, 2, &type, -1); if (type) g_hash_table_remove(app_config->autorun_choices, type); g_free(type); gtk_list_store_remove(GTK_LIST_STORE(model), &it); } else g_critical("autorun_choice not found in model"); gtk_tree_row_reference_free(l->data); } g_list_free(rows); }
static void cookies_treeview_selection_changed_cb (GtkTreeSelection *selection, PdmDialog *dialog) { GaleonDialog *d = GALEON_DIALOG(dialog); GtkTreeModel *model; GValue val = {0, }; GtkTreeIter iter; GtkTreePath *path; CookieInfo *info; GList *l; GtkEntry *value_entry, *url_entry; GtkLabel *expires_label; GtkWidget *treeview = dialog->priv->cookies->treeview; gchar *url, *scheme; value_entry = GTK_ENTRY(galeon_dialog_get_control(d, PROP_COOKIES_VALUE_ENTRY)); url_entry = GTK_ENTRY(galeon_dialog_get_control(d, PROP_COOKIES_URL_ENTRY)); expires_label = GTK_LABEL(galeon_dialog_get_control(d, PROP_COOKIES_EXPIRES_LABEL)); model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); l = gul_gui_treeview_get_selection_refs(GTK_TREE_VIEW(treeview)); if (l == NULL || l->next != NULL) { gtk_entry_set_text(value_entry, ""); gtk_entry_set_text(url_entry, ""); gtk_label_set_text(expires_label, ""); gul_gui_treeview_free_selection_refs(l); return; } path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)l->data); gul_gui_treeview_free_selection_refs(l); gtk_tree_model_get_iter(model, &iter, path); gtk_tree_path_free(path); gtk_tree_model_get_value (model, &iter, COL_COOKIES_DATA, &val); info = (CookieInfo *)g_value_get_pointer (&val); if (info->secure) scheme = "https://"; else scheme = "http://"; if (info->domain[0] == '.') url = g_strconcat(scheme, "*", info->domain, info->path, NULL); else url = g_strconcat(scheme, info->domain, info->path, NULL); gtk_entry_set_text(value_entry, info->value); gtk_label_set_text(expires_label, info->expire); gtk_entry_set_text(url_entry, url); g_free(url); }
void dh_book_tree_show_uri (DhBookTree *tree, const gchar *uri) { #if 0 GtkTreeSelection *selection; GtkTreeRowReference *row; GtkTreePath *path; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); /* FIXME: Hmm .. */ row = g_hash_table_lookup (tree->priv->node_rows, book_node); g_return_if_fail (row != NULL); path = gtk_tree_row_reference_get_path (row); g_return_if_fail (path != NULL); g_signal_handlers_block_by_func (selection, book_tree_selection_changed_cb, tree); gtk_tree_selection_select_path (selection, path); gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), path, NULL, 0); g_signal_handlers_unblock_by_func (selection, book_tree_selection_changed_cb, tree); gtk_tree_path_free (path); #endif }
/** * glista_remindhandler_remind: * @reminder The reminder to handle * @error A pointer to fill with an error, if any * * Remind the user about a task. * * Returns: TRUE on success, FALSE otherwise */ G_MODULE_EXPORT gboolean glista_remindhandler_remind(GlistaReminder *reminder, GError **error) { GtkWidget *dialog; GtkWindow *mainwindow; GtkTreeIter iter; GtkTreePath *path; gchar *item_text; mainwindow = GTK_WINDOW(glista_get_widget("glista_main_window")); // Get the task as text // TODO: Concat the category ? path = gtk_tree_row_reference_get_path(reminder->item_ref); gtk_tree_model_get_iter(GL_ITEMSTM, &iter, path); gtk_tree_model_get(GL_ITEMSTM, &iter, GL_COLUMN_TEXT, &item_text, -1); dialog = gtk_message_dialog_new(mainwindow, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, _("Glista Reminder")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", item_text); g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog); gtk_widget_show(dialog); return TRUE; }
static void async_get_favicon_cb (GObject *source, GAsyncResult *result, gpointer user_data) { GtkTreeIter iter; GtkTreePath *path; IconLoadData *data = (IconLoadData *) user_data; GdkPixbuf *favicon = webkit_favicon_database_get_favicon_pixbuf_finish (webkit_get_favicon_database (), result, NULL); if (favicon) { /* The completion model might have changed its contents */ if (gtk_tree_row_reference_valid (data->row_reference)) { path = gtk_tree_row_reference_get_path (data->row_reference); gtk_tree_model_get_iter (GTK_TREE_MODEL (data->model), &iter, path); gtk_tree_path_free (path); gtk_list_store_set (data->model, &iter, EPHY_HOSTS_STORE_COLUMN_FAVICON, favicon, -1); } g_object_unref (favicon); } g_object_unref (data->model); gtk_tree_row_reference_free (data->row_reference); g_slice_free (IconLoadData, data); }
static void drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx, GtkSelectionData *data, guint info, guint time, AccountsWindow *dialog) { if (data->target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) { GtkTreeRowReference *ref; GtkTreePath *source_row; GtkTreeIter iter; PurpleAccount *account = NULL; GValue val = {0}; ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row"); source_row = gtk_tree_row_reference_get_path(ref); if (source_row == NULL) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, source_row); gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter, COLUMN_DATA, &val); dialog->drag_iter = iter; account = g_value_get_pointer(&val); gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE), 8, (void *)&account, sizeof(account)); gtk_tree_path_free(source_row); } }
static void gimp_scale_combo_box_mru_add (GimpScaleComboBox *combo_box, GtkTreeIter *iter) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); GtkTreePath *path = gtk_tree_model_get_path (model, iter); GList *list; gboolean found; for (list = combo_box->mru, found = FALSE; list && !found; list = list->next) { GtkTreePath *this = gtk_tree_row_reference_get_path (list->data); if (gtk_tree_path_compare (this, path) == 0) { if (list->prev) { combo_box->mru = g_list_remove_link (combo_box->mru, list); combo_box->mru = g_list_concat (list, combo_box->mru); } found = TRUE; } gtk_tree_path_free (this); } if (! found) combo_box->mru = g_list_prepend (combo_box->mru, gtk_tree_row_reference_new (model, path)); gtk_tree_path_free (path); }
static void gimp_scale_combo_box_mru_remove_last (GimpScaleComboBox *combo_box) { GtkTreeModel *model; GtkTreePath *path; GList *last; GtkTreeIter iter; if (! combo_box->mru) return; model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); last = g_list_last (combo_box->mru); path = gtk_tree_row_reference_get_path (last->data); if (gtk_tree_model_get_iter (model, &iter, path)) { gtk_list_store_remove (GTK_LIST_STORE (model), &iter); gtk_tree_row_reference_free (last->data); combo_box->mru = g_list_delete_link (combo_box->mru, last); } gtk_tree_path_free (path); }
static void free_service(struct Service *s) { GtkTreeIter iter; GtkTreePath *path; if (current_service == s) { current_service = NULL; if (service_resolver) { avahi_s_service_resolver_free(service_resolver); service_resolver = NULL; } gtk_label_set_text(info_label, "<i>Service removed</i>"); } s->service_type->services = g_list_remove(s->service_type->services, s); if ((path = gtk_tree_row_reference_get_path(s->tree_ref))) { gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_store), &iter, path); gtk_tree_path_free(path); } gtk_tree_store_remove(tree_store, &iter); gtk_tree_row_reference_free(s->tree_ref); g_free(s->service_name); g_free(s->domain_name); g_free(s); }
void seahorse_object_model_remove_rows_for_object (SeahorseObjectModel *self, GObject *object) { SeahorseObjectModelPrivate *pv = SEAHORSE_OBJECT_MODEL_GET_PRIVATE (self); SeahorseObjectRow *skrow; GtkTreeIter iter; GtkTreePath *path; guint i; g_return_if_fail (SEAHORSE_IS_OBJECT_MODEL (self)); g_return_if_fail (G_IS_OBJECT (object)); g_return_if_fail (pv->data_column >= 0); skrow = (SeahorseObjectRow*)g_hash_table_lookup (pv->rows, object); if (!skrow) return; for (i = 0; i < skrow->refs->len; i++) { path = gtk_tree_row_reference_get_path (g_ptr_array_index (skrow->refs, i)); if (path) { gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path); gtk_tree_store_remove (GTK_TREE_STORE (self), &iter); gtk_tree_path_free (path); } } /* We no longer have rows associated with this key, then remove */ g_hash_table_remove (pv->rows, object); }
/* the function will check for a NULL row_ref of its associated path. In that * case will return FALSE */ static inline gboolean sdb_view_locals_get_iter_from_row_ref (SymbolDBViewLocals *dbvl, GtkTreeRowReference *row_ref, GtkTreeIter *OUT_iter) { GtkTreePath *path; if (row_ref == NULL) { /* no node displayed found */ return FALSE; } path = gtk_tree_row_reference_get_path (row_ref); if (path == NULL) { /*DEBUG_PRINT ("%s", "sdb_view_locals_get_iter_from_row_ref (): path is null, something " "went wrong ?!");*/ return FALSE; } if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)), OUT_iter, path) == FALSE) { gtk_tree_path_free (path); return FALSE; } gtk_tree_path_free (path); return TRUE; }
static void play_back_delete_inpfile (GtkTreeRowReference *reference) { GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gboolean valid; gchar *inpfile; model = gtk_tree_row_reference_get_model (reference); path = gtk_tree_row_reference_get_path (reference); valid = gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); g_assert (valid); gtk_tree_model_get ( model, &iter, GVA_GAME_STORE_COLUMN_INPFILE, &inpfile, -1); g_assert (inpfile != NULL); errno = 0; if (g_unlink (inpfile) == 0) gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); else g_warning ("%s: %s", inpfile, g_strerror (errno)); g_free (inpfile); }
static void attachment_button_update_cell_view (EAttachmentButton *button) { GtkCellView *cell_view; EAttachment *attachment; GtkTreeRowReference *reference; GtkTreeModel *model = NULL; GtkTreePath *path = NULL; cell_view = GTK_CELL_VIEW (button->priv->cell_view); attachment = e_attachment_button_get_attachment (button); if (attachment == NULL) goto exit; reference = e_attachment_get_reference (attachment); if (reference == NULL) goto exit; model = gtk_tree_row_reference_get_model (reference); path = gtk_tree_row_reference_get_path (reference); exit: gtk_cell_view_set_model (cell_view, model); if (model) gtk_cell_view_set_displayed_row (cell_view, path); if (path != NULL) gtk_tree_path_free (path); }
static void configure_combo_box_set_active (GtkComboBox *combo_box, const gchar *value) { GtkTreeRowReference *reference; GHashTable *index; index = g_object_get_data (G_OBJECT (combo_box), "index"); g_return_if_fail (index != NULL); reference = g_hash_table_lookup (index, value); if (reference != NULL) { GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; model = gtk_tree_row_reference_get_model (reference); path = gtk_tree_row_reference_get_path (reference); if (path == NULL) return; if (gtk_tree_model_get_iter (model, &iter, path)) gtk_combo_box_set_active_iter (combo_box, &iter); gtk_tree_path_free (path); } }
/** * glista_remindhandler_remind: * @reminder The reminder to handle * @error A pointer to fill with an error, if any * * Remind the user about a task. The dummy reminder simply prints out a * message to STDOUT. * * Returns: TRUE on success, FALSE otherwise */ G_MODULE_EXPORT gboolean glista_remindhandler_remind(GlistaReminder *reminder, GError **error) { GtkTreePath *path; GtkTreeIter iter; gchar *item_text, *time_str; struct tm *ltime; // Get reminder time into a string ltime = localtime(&(reminder->remind_at)); time_str = g_malloc0(sizeof(gchar[72])); strftime(time_str, 70, "%x %H:%M", ltime); // Get the item name path = gtk_tree_row_reference_get_path(reminder->item_ref); gtk_tree_model_get_iter(GL_ITEMSTM, &iter, path); gtk_tree_model_get(GL_ITEMSTM, &iter, GL_COLUMN_TEXT, &item_text, -1); // Remind! g_print("It's %s - don't forget: %s\n", time_str, item_text); // Free used memory g_free(time_str); return TRUE; }
static void nsgtk_download_store_update_item (struct gui_download_window *dl) { gchar *info = nsgtk_download_info_to_string(dl); char *human = human_friendly_bytesize(dl->speed); char speed[strlen(human) + SLEN("/s") + 1]; sprintf(speed, "%s/s", human); gchar *time = nsgtk_download_time_to_string(dl->time_remaining); gboolean pulse = dl->status == NSGTK_DOWNLOAD_WORKING; /* Updates iter (which is needed to set and get data) with the dl row */ gtk_tree_model_get_iter(GTK_TREE_MODEL(nsgtk_download_store), &nsgtk_download_iter, gtk_tree_row_reference_get_path(dl->row)); gtk_list_store_set(nsgtk_download_store, &nsgtk_download_iter, NSGTK_DOWNLOAD_PULSE, pulse ? dl->progress : -1, NSGTK_DOWNLOAD_PROGRESS, pulse ? 0 : dl->progress, NSGTK_DOWNLOAD_INFO, info, NSGTK_DOWNLOAD_SPEED, dl->speed == 0 ? "-" : speed, NSGTK_DOWNLOAD_REMAINING, time, NSGTK_DOWNLOAD, dl, -1); g_free(info); g_free(time); }
static void remove_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) { GtkTreeModel *model; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->compositionTreeView)); GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, &model); gint n_selected_rows = gtk_tree_selection_count_selected_rows(selection); GtkTreeRowReference **refs = (GtkTreeRowReference**) g_malloc(sizeof(GtkTreeRowReference*)*n_selected_rows); int i; // the following really needs two for loops!!! // paths change while rows are being added or removed, while references never change for (i = 0 ; i < n_selected_rows ; i++) { refs[i] = gtk_tree_row_reference_new(model, (GtkTreePath *) g_list_nth_data(selected_rows, i)); } for (i = 0 ; i < n_selected_rows ; i++) { GtkTreePath *path = gtk_tree_row_reference_get_path(refs[i]); GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, path); //delete row happens here gtk_list_store_remove(GTK_LIST_STORE(model), &iter); gtk_tree_path_free(path); gtk_tree_row_reference_free(refs[i]); } g_list_free_full(selected_rows, (GDestroyNotify) gtk_tree_path_free); g_free(refs); //the sum needs to be updated update_sum(dialog); return; }
/* * env tree view value editing cancelled (Escape pressed) */ static void on_value_editing_cancelled(GtkCellRenderer *renderer, gpointer user_data) { /* check whether escape was pressed when editing new variable value cell */ GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row); if(!gtk_tree_path_compare(being_edited_value, empty_path)) { /* if so - clear name sell */ GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, being_edited_value); gtk_list_store_set ( store, &iter, NAME, "", -1); entering_new_var = FALSE; } g_object_set (renderer_value, "editable", FALSE, NULL); gtk_tree_path_free(being_edited_value); gtk_tree_path_free(empty_path); }
static void on_item_changed (MateBG *bg, AppearanceData *data) { GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; MateWPItem *item; item = g_hash_table_find (data->wp_hash, predicate, bg); if (!item) return; model = gtk_tree_row_reference_get_model (item->rowref); path = gtk_tree_row_reference_get_path (item->rowref); if (gtk_tree_model_get_iter (model, &iter, path)) { GdkPixbuf *pixbuf; g_signal_handlers_block_by_func (bg, G_CALLBACK (on_item_changed), data); pixbuf = mate_wp_item_get_thumbnail (item, data->thumb_factory, data->thumb_width, data->thumb_height); if (pixbuf) { gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1); g_object_unref (pixbuf); } g_signal_handlers_unblock_by_func (bg, G_CALLBACK (on_item_changed), data); } }
static void each_url_get_data_binder (GaleonDragEachSelectedItemDataGet iteratee, gpointer iterator_context, gpointer data) { GtkTreeView *treeview = HISTORY_DIALOG(iterator_context)->priv->treeview; GtkTreeModel *model = HISTORY_DIALOG(iterator_context)->priv->model; GList *refs, *l; refs = gul_gui_treeview_get_selection_refs (treeview); for (l = refs; l != NULL; l = l->next) { char *url, *title; GtkTreeIter iter; GtkTreePath *path; path = gtk_tree_row_reference_get_path ((GtkTreeRowReference *)l->data); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, 0, &title, 1, &url, -1); iteratee (url, title, -1, -1, -1, -1, data); g_free (url); g_free (title); } gul_gui_treeview_free_selection_refs (refs); }
static void key_row_free (SeahorseObjectRow *skrow) { SeahorseObjectModel *self = skrow->self; GtkTreeRowReference *ref; GtkTreePath *path; GtkTreeIter iter; guint i; g_return_if_fail (self->data_column != -1); for (i = 0; i < skrow->refs->len; i++) { ref = (GtkTreeRowReference*)g_ptr_array_index (skrow->refs, i); if (ref) { path = gtk_tree_row_reference_get_path (ref); if (path) { gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path); gtk_tree_store_set (GTK_TREE_STORE (self), &iter, self->data_column, NULL, -1); gtk_tree_path_free (path); } gtk_tree_row_reference_free (ref); } } if (skrow->binding) seahorse_bind_disconnect (skrow->binding); if (skrow->object) g_object_weak_unref (G_OBJECT (skrow->object), key_destroyed, skrow->self); g_ptr_array_free (skrow->refs, TRUE); g_free (skrow); }