static void history_item_update_cb (GlobalHistory *gh, HistoryItem *item, HistoryDialog *dialog) { GtkTreeIter *host_iter, *iter; HistoryItem *host; host = global_history_get_host_from_site (dialog->priv->gh, item); host_iter = history_dialog_find_host_iter (dialog, host); if (host_iter) { iter = history_dialog_find_site_iter (dialog, host_iter, item); if (iter) { history_dialog_update_host_item (dialog, host, host_iter); history_dialog_update_url_item (dialog, item, iter); gtk_tree_iter_free (iter); } gtk_tree_iter_free (host_iter); } }
static void log_changed_cb (LogviewLog *log, gpointer user_data) { LogviewLoglist *list = user_data; LogviewLog *active; GtkTreeIter *iter; active = logview_manager_get_active_log (list->priv->manager); if (log == active) { g_object_unref (active); return; } iter = logview_loglist_find_log (list, log); if (!iter) { return; } /* make the log bold in the list */ gtk_tree_store_set (list->priv->model, iter, LOG_WEIGHT, PANGO_WEIGHT_BOLD, LOG_WEIGHT_SET, TRUE, -1); gtk_tree_iter_free (iter); }
static void history_dialog_fill_view (HistoryDialog *dialog) { GList *list, *l; GtkTreeIter *iter; list = global_history_get_host_list (dialog->priv->gh); for (l = list; l != NULL; l = l->next) { GList *urls; HistoryItem *item = (HistoryItem *)(l->data); urls = global_history_get_urls_list (dialog->priv->gh, item, &dialog->priv->filter); if (urls) { iter = history_dialog_add_host_item (dialog, item); history_dialog_add_url_items (dialog, urls, iter); g_list_free (urls); if (iter) { gtk_tree_iter_free (iter); } } } g_list_free (list); }
static void history_item_add_cb (GlobalHistory *gh, HistoryItem *item, HistoryDialog *dialog) { GtkTreeIter *iter; HistoryItem *host; GList *urls_list; gboolean empty_list; host = global_history_get_host_from_site (dialog->priv->gh, item); /* ignore urls that doesnt match current filter */ urls_list = global_history_get_urls_list (dialog->priv->gh, host, &dialog->priv->filter); empty_list = !g_list_find (urls_list, item); g_list_free (urls_list); if (empty_list) return; iter = history_dialog_find_host_iter (dialog, host); if (!iter) { iter = history_dialog_add_host_item (dialog, host); } history_dialog_add_url_item (dialog, item, iter); if (iter) { gtk_tree_iter_free (iter); } }
static void manager_log_closed_cb (LogviewManager *manager, LogviewLog *log, gpointer user_data) { LogviewLoglist *list = user_data; GtkTreeIter *iter; gboolean res; iter = logview_loglist_find_log (list, log); if (!iter) { return; } g_signal_handlers_disconnect_by_func (log, log_changed_cb, list); res = gtk_tree_store_remove (list->priv->model, iter); if (res) { GtkTreeSelection *selection; /* iter now points to the next valid row */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); gtk_tree_selection_select_iter (selection, iter); } else { /* FIXME: what shall we do here? */ } gtk_tree_iter_free (iter); }
static void handle_channel_deletes (ReaderEngine *engine, gint sub) { gchar *query; const gchar *subject; GtkTreeIter *iter; TrackerSparqlCursor *cursor; ReaderEnginePrivate *priv; priv = reader_engine_get_instance_private (engine); query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub); cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL); tracker_sparql_cursor_next (cursor, NULL, NULL); subject = tracker_sparql_cursor_get_string (cursor, 0, NULL); if (find_in_model (GTK_TREE_MODEL (priv->data), GD_MAIN_COLUMN_ID, subject, &iter)) { remove_channel_data (GTK_TREE_MODEL (priv->data), iter); gtk_list_store_remove (priv->data, iter); gtk_tree_iter_free (iter); } g_free (query); g_object_unref (cursor); }
/** * ag_chart_edit_country_changed_cb: * @country: the #GtkSearchEntry for country search * @chart_edit: the #AgChartEdit in which the event happens * * This function is called whenever the text in the country search entry is * changed. */ static void ag_chart_edit_country_changed_cb(GtkSearchEntry *country, AgChartEdit *chart_edit) { struct cc_search search; GET_PRIV(chart_edit); search.target = gtk_entry_get_text(GTK_ENTRY(country)); search.ret_iter = NULL; gtk_tree_model_foreach( country_list, (GtkTreeModelForeachFunc)ag_chart_edit_find_country, &search ); g_free(priv->selected_country); if (search.ret_iter != NULL) { g_debug("Country (entry-changed): %s", search.ret_code); gtk_tree_iter_free(search.ret_iter); priv->selected_country = search.ret_code; } else { priv->selected_country = NULL; } }
static void filter_result_callback_data_free (FilterResultCallbackData *data) { g_object_unref (data->self); g_object_unref (data->account); gtk_tree_iter_free (data->iter); g_slice_free (FilterResultCallbackData, data); }
static void fill_ppds_list (PpPPDSelectionDialog *dialog) { GtkTreeSelection *selection; GtkListStore *store; GtkTreePath *path; GtkTreeView *treeview; GtkTreeIter iter; GtkTreeIter *preselect_iter = NULL; GtkWidget *widget; gint i; widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "ppd-spinner"); gtk_widget_hide (widget); gtk_spinner_stop (GTK_SPINNER (widget)); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "progress-label"); gtk_widget_hide (widget); treeview = (GtkTreeView*) gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview"); if (dialog->list) { store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); for (i = 0; i < dialog->list->num_of_manufacturers; i++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, PPD_MANUFACTURERS_NAMES_COLUMN, dialog->list->manufacturers[i]->manufacturer_name, PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, dialog->list->manufacturers[i]->manufacturer_display_name, -1); if (g_strcmp0 (dialog->manufacturer, dialog->list->manufacturers[i]->manufacturer_display_name) == 0) { preselect_iter = gtk_tree_iter_copy (&iter); } } gtk_tree_view_set_model (treeview, GTK_TREE_MODEL (store)); if (preselect_iter && (selection = gtk_tree_view_get_selection (treeview)) != NULL) { gtk_tree_selection_select_iter (selection, preselect_iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), preselect_iter); gtk_tree_view_scroll_to_cell (treeview, path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free (path); gtk_tree_iter_free (preselect_iter); } g_object_unref (store); } }
/** * Move account in list depending on direction and selected account */ static void account_move(gboolean move_up, gpointer data) { // Get view, model and selection of account GtkTreeView *tree_view = GTK_TREE_VIEW(data); GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view); // Find selected iteration and create a copy GtkTreeIter iter; gtk_tree_selection_get_selected(selection, &model, &iter); GtkTreeIter *iter_copy; iter_copy = gtk_tree_iter_copy(&iter); // Find path of iteration gchar *path = gtk_tree_model_get_string_from_iter(model, &iter); // The first real account in the list can't move up because of the IP2IP account // It can still move down though if (g_strcmp0(path, "1") == 0 && move_up) return; GtkTreePath *tree_path = gtk_tree_path_new_from_string(path); gint *indices = gtk_tree_path_get_indices(tree_path); const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */ // Depending on button direction get new path if (move_up) gtk_tree_path_prev(tree_path); else gtk_tree_path_next(tree_path); gtk_tree_model_get_iter(model, &iter, tree_path); // Swap iterations if valid if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter)) gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy); // Scroll to new position gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0); // Free resources gtk_tree_path_free(tree_path); gtk_tree_iter_free(iter_copy); g_free(path); // Perpetuate changes in account queue if (move_up) account_list_move_up(pos); else account_list_move_down(pos); // Set the order in the configuration file gchar *ordered_account_list = account_list_get_ordered_list(); dbus_set_accounts_order(ordered_account_list); g_free(ordered_account_list); }
static void status_icon_info_delete (gpointer data) { g_return_if_fail (data != NULL); StatusIconInfo *info = (StatusIconInfo*) data; gtk_tree_iter_free (info->iter); delete info; }
static void pass_channels (ReaderEngine *engine, TrackerSparqlCursor *cursor) { const gchar *subject; const gchar *title; const gchar *url; gint64 unread; GtkTreeModel *model; GtkTreeIter *iter; GtkTreeIter iter2; GtkTreeStore *items_model; GdkPixbuf *icon; ReaderEnginePrivate *priv; if (cursor != NULL) { priv = reader_engine_get_instance_private (engine); model = GTK_TREE_MODEL (priv->data); while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { subject = tracker_sparql_cursor_get_string (cursor, 0, NULL); title = tracker_sparql_cursor_get_string (cursor, 1, NULL); unread = tracker_sparql_cursor_get_integer (cursor, 2); url = tracker_sparql_cursor_get_string (cursor, 4, NULL); if (find_in_model (model, GD_MAIN_COLUMN_ID, subject, &iter)) { gtk_list_store_set (GTK_LIST_STORE (model), iter, GD_MAIN_COLUMN_PRIMARY_TEXT, title, EXTRA_COLUMN_UNREADS, unread, -1); gtk_tree_iter_free (iter); } else { items_model = gtk_tree_store_new (ITEM_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING); g_signal_connect (items_model, "row-changed", G_CALLBACK (model_item_changed), engine); icon = get_icon_for_channel (tracker_sparql_cursor_get_string (cursor, 3, NULL)); gtk_list_store_append (GTK_LIST_STORE (model), &iter2); gtk_list_store_set (GTK_LIST_STORE (model), &iter2, GD_MAIN_COLUMN_ID, subject, GD_MAIN_COLUMN_PRIMARY_TEXT, title, GD_MAIN_COLUMN_ICON, icon, EXTRA_COLUMN_UNREADS, unread, EXTRA_COLUMN_URL, url, EXTRA_COLUMN_FEEDS_MODEL, items_model, -1); } collect_items (engine, subject, NULL); } g_object_unref (cursor); } }
static void codec_moved_cb (GtkWidget *widget, gpointer data) { CodecsBox *self = NULL; GtkTreeIter iter; GtkTreeIter *iter2 = NULL; GtkTreeModel *model = NULL; GtkTreeSelection *selection = NULL; GtkTreePath *tree_path = NULL; std::list<std::string> list; gchar *path_str = NULL; self = CODECS_BOX (data); model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list)); if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), NULL, &iter)) return; /* Update the tree view */ iter2 = gtk_tree_iter_copy (&iter); path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model), &iter); tree_path = gtk_tree_path_new_from_string (path_str); if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"), "up")) gtk_tree_path_prev (tree_path); else gtk_tree_path_next (tree_path); gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path); if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter) && gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2)) gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2); /* Scroll to the new position */ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list), tree_path, NULL, FALSE, 0, 0); gtk_tree_path_free (tree_path); gtk_tree_iter_free (iter2); g_free (path_str); /* Update the key */ list = codecs_box_to_list (self); if (self->priv->type == Ekiga::Call::Audio) self->priv->audio_settings->set_string_list ("media-list", list); else if (self->priv->type == Ekiga::Call::Video) self->priv->video_settings->set_string_list ("media-list", list); }
static void update_openfiles_dialog (GsmTreeView *tree) { ProcInfo *info; GtkTreeModel *model; glibtop_open_files_entry *openfiles; glibtop_proc_open_files procmap; GHashTable *new_maps; guint i; pid_t pid = GPOINTER_TO_UINT(static_cast<pid_t*>(g_object_get_data (G_OBJECT (tree), "selected_info"))); info = GsmApplication::get()->processes.find(pid); if (!info) return; model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree)); openfiles = glibtop_get_proc_open_files (&procmap, info->pid); if (!openfiles) return; new_maps = static_cast<GHashTable *>(g_hash_table_new_full (g_str_hash, compare_open_files, NULL, NULL)); for (i=0; i < procmap.number; i++) g_hash_table_insert (new_maps, openfiles + i, openfiles + i); gtk_tree_model_foreach (model, classify_openfiles, new_maps); g_hash_table_foreach (new_maps, add_new_files, model); while (old_maps) { GtkTreeIter *iter = static_cast<GtkTreeIter*>(old_maps->data); glibtop_open_files_entry *openfiles = NULL; gtk_tree_model_get (model, iter, COL_OPENFILE_STRUCT, &openfiles, -1); gtk_list_store_remove (GTK_LIST_STORE (model), iter); gtk_tree_iter_free (iter); g_free (openfiles); old_maps = g_list_next (old_maps); } g_hash_table_destroy (new_maps); g_free (openfiles); }
void __new_req_populate_ca_treeview (GtkTreeView *treeview) { GtkCellRenderer * renderer = NULL; __NewReqWindowRefreshModelAddCaUserData pdata; guint column_number; new_req_ca_list_model = gtk_tree_store_new (NEW_REQ_CA_MODEL_COLUMN_NUMBER, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); pdata.new_model = new_req_ca_list_model; pdata.last_parent_iter = NULL; pdata.last_ca_iter = NULL; ca_file_foreach_ca (__new_req_window_refresh_model_add_ca, &pdata); if (pdata.last_parent_iter) gtk_tree_iter_free (pdata.last_parent_iter); if (pdata.last_ca_iter) gtk_tree_iter_free (pdata.last_ca_iter); g_dataset_destroy (new_req_ca_list_model); renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new()); column_number = gtk_tree_view_insert_column_with_attributes (treeview, -1, _("Subject"), renderer, "markup", NEW_REQ_CA_MODEL_COLUMN_SUBJECT, NULL); gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(new_req_ca_list_model)); gtk_tree_view_expand_all (treeview); return; }
static void gimp_int_store_finalize (GObject *object) { GimpIntStore *store = GIMP_INT_STORE (object); if (store->empty_iter) { gtk_tree_iter_free (store->empty_iter); store->empty_iter = NULL; } G_OBJECT_CLASS (parent_class)->finalize (object); }
static void photos_organize_collection_model_object_removed (PhotosBaseManager *manager, GObject *object, gpointer user_data) { PhotosOrganizeCollectionModel *self = PHOTOS_ORGANIZE_COLLECTION_MODEL (user_data); GtkTreeIter *iter; iter = photos_organize_collection_model_find_collection_iter (self, PHOTOS_BASE_ITEM (object)); if (iter == NULL) return; gtk_list_store_remove (GTK_LIST_STORE (self), iter); gtk_tree_iter_free (iter); }
static void ipreferences_merge(IAnjutaPreferences* ipref, AnjutaPreferences* prefs, GError** e) { /* Add preferences */ SourceviewPlugin* plugin = ANJUTA_PLUGIN_SOURCEVIEW (ipref); GtkCellRenderer* renderer_name = gtk_cell_renderer_text_new (); GtkCellRenderer* renderer_desc = gtk_cell_renderer_text_new (); GtkTreeIter* iter = NULL; GError* error = NULL; builder = gtk_builder_new (); if (!gtk_builder_add_from_file(builder, PREFS_GLADE, &error)) { DEBUG_PRINT ("Could load sourceview preferences: %s", error->message); g_error_free (error); return; } anjuta_preferences_add_from_builder (prefs, builder, plugin->settings, "Editor", _("GtkSourceView Editor"), ICON_FILE); plugin->check_font = GTK_WIDGET (gtk_builder_get_object (builder, FONT_USE_THEME_BUTTON)); g_signal_connect(G_OBJECT(plugin->check_font), "toggled", G_CALLBACK(on_font_check_toggled), builder); on_font_check_toggled (GTK_TOGGLE_BUTTON (plugin->check_font), builder); /* Init styles combo */ plugin->combo_styles = GTK_WIDGET (gtk_builder_get_object (builder, COMBO_STYLES)); gtk_combo_box_set_model (GTK_COMBO_BOX (plugin->combo_styles), create_style_model(plugin->settings, &iter)); g_signal_connect (plugin->combo_styles, "changed", G_CALLBACK (on_style_changed), plugin); gtk_cell_layout_clear (GTK_CELL_LAYOUT(plugin->combo_styles)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name, TRUE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name, "text", COLUMN_NAME); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc, "text", COLUMN_DESC); g_object_set (renderer_desc, "style", PANGO_STYLE_ITALIC, NULL); if (iter) { gtk_combo_box_set_active_iter (GTK_COMBO_BOX (plugin->combo_styles), iter); gtk_tree_iter_free (iter); } }
static void history_item_remove_cb (GlobalHistory *gh, HistoryItem *item, HistoryDialog *dialog) { GtkTreeIter *host_iter, *iter; HistoryItem *host; GList *urls_list; gboolean remove_parent; host = global_history_get_host_from_site (dialog->priv->gh, item); urls_list = global_history_get_urls_list (dialog->priv->gh, host, &dialog->priv->filter); remove_parent = (g_list_length (urls_list) == 1); g_list_free (urls_list); host_iter = history_dialog_find_host_iter (dialog, host); if (host_iter) { iter = history_dialog_find_site_iter (dialog, host_iter, item); if (iter) { history_dialog_remove_item (dialog, item, iter); gtk_tree_iter_free (iter); } if (remove_parent) { history_dialog_remove_item (dialog, item, iter); } gtk_tree_iter_free (host_iter); } }
void logview_loglist_update_lines (LogviewLoglist *loglist, LogviewLog *log) { GSList *days; GtkTreeIter *parent; g_assert (LOGVIEW_IS_LOGLIST (loglist)); g_assert (LOGVIEW_IS_LOG (log)); days = logview_log_get_days_for_cached_lines (log); parent = logview_loglist_find_log (loglist, log); update_days_and_lines_for_log (loglist, parent, days); gtk_tree_iter_free (parent); }
static void history_dialog_add_url_item (HistoryDialog *dialog, HistoryItem *item, GtkTreeIter *parent_iter) { GtkTreeIter iter; GtkTreeIter *tmp; gtk_tree_store_insert (GTK_TREE_STORE (dialog->priv->model), &iter, parent_iter, 0); tmp = gtk_tree_iter_copy (&iter); history_dialog_update_url_item (dialog, item, tmp); gtk_tree_iter_free (tmp); }
static void gimp_int_store_row_inserted (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter) { GimpIntStore *store = GIMP_INT_STORE (model); if (parent_iface->row_inserted) parent_iface->row_inserted (model, path, iter); if (store->empty_iter && memcmp (iter, store->empty_iter, sizeof (GtkTreeIter))) { gtk_list_store_remove (GTK_LIST_STORE (store), store->empty_iter); gtk_tree_iter_free (store->empty_iter); store->empty_iter = NULL; } }
static void xfce_cell_renderer_pixbuf_on_demand_finalize(GObject *object) { XfceCellRendererPixbufOnDemand *aXfceCellRendererPixbufOnDemand; XfceCellRendererPixbufOnDemandPrivate *priv; g_return_if_fail(object != NULL); g_return_if_fail(IS_XFCE_CELL_RENDERER_PIXBUF_ON_DEMAND(object)); aXfceCellRendererPixbufOnDemand = XFCE_CELL_RENDERER_PIXBUF_ON_DEMAND(object); priv = aXfceCellRendererPixbufOnDemand->priv; if (priv->iter) { gtk_tree_iter_free (priv->iter); priv->iter = NULL; } if (priv->pixbuf) { g_object_unref (G_OBJECT (priv->pixbuf)); priv->pixbuf = NULL; } if (priv->fallback_pixbuf) { g_object_unref (G_OBJECT (priv->fallback_pixbuf)); priv->fallback_pixbuf = NULL; } if (priv->path) { g_free (priv->path); priv->path = NULL; } #if 0 if (priv->dummypix) { g_object_unref (G_OBJECT (priv->dummypix)); priv->dummypix = NULL; } #endif if (G_OBJECT_CLASS(parent_class)->finalize) (* G_OBJECT_CLASS(parent_class)->finalize)(object); g_free(priv); }
static void manager_active_changed_cb (LogviewManager *manager, LogviewLog *log, LogviewLog *old_log, gpointer user_data) { LogviewLoglist *list = user_data; GtkTreeIter * iter, sel_iter; GtkTreeSelection * selection; if (list->priv->selection && gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->model), &sel_iter, list->priv->selection)) { Day *day; iter = gtk_tree_iter_copy (&sel_iter); gtk_tree_model_get (GTK_TREE_MODEL (list->priv->model), iter, LOG_DAY, &day, -1); if (day) { g_signal_emit (list, signals[DAY_SELECTED], 0, day, NULL); } gtk_tree_path_free (list->priv->selection); list->priv->selection = NULL; } else { iter = logview_loglist_find_log (list, log); } if (!iter) { return; } selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); g_signal_handlers_block_by_func (selection, tree_selection_changed_cb, list); gtk_tree_selection_select_iter (selection, iter); g_signal_handlers_unblock_by_func (selection, tree_selection_changed_cb, list); gtk_tree_iter_free (iter); }
static void photos_organize_collection_model_fetch_collection_state_executed (GHashTable *collection_state, gpointer user_data) { PhotosOrganizeCollectionModel *self = PHOTOS_ORGANIZE_COLLECTION_MODEL (user_data); GHashTableIter collection_state_iter; const gchar *idx; gpointer value; photos_organize_collection_model_remove_placeholder (self); g_hash_table_iter_init (&collection_state_iter, collection_state); while (g_hash_table_iter_next (&collection_state_iter, (gpointer) &idx, (gpointer) &value)) { GtkTreeIter *iter; PhotosBaseItem *collection; gint state = GPOINTER_TO_INT (value); if (state & PHOTOS_COLLECTION_STATE_HIDDEN) continue; collection = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (self->priv->manager, idx)); iter = photos_organize_collection_model_find_collection_iter (self, collection); if (iter == NULL) { GtkTreeIter tmp; gtk_list_store_append (GTK_LIST_STORE (self), &tmp); iter = gtk_tree_iter_copy (&tmp); } gtk_list_store_set (GTK_LIST_STORE (self), iter, PHOTOS_ORGANIZE_MODEL_ID, idx, PHOTOS_ORGANIZE_MODEL_NAME, photos_base_item_get_name (collection), PHOTOS_ORGANIZE_MODEL_STATE, state, -1); gtk_tree_iter_free (iter); } g_object_unref (self); }
gTreeRow::~gTreeRow() { GList *iter=NULL; if (tree->onRemove) (*tree->onRemove)(tree, _key); if (dataiter) gtk_tree_iter_free(dataiter); if (data) iter=g_list_first(data); while (iter) { delete (gTreeCell*)iter->data; iter=g_list_next(iter); } if (data) g_list_free(data); //fprintf(stderr, "free key: (%p) %s\n", _key, _key); g_free(_key); }
char *gTreeRow::parent() { GtkTreeIter *iter = gtk_tree_iter_copy(dataiter); char *key; //GtkTreePath* path; if (!gtk_tree_model_iter_parent(GTK_TREE_MODEL(tree->store), iter, dataiter)) key = NULL; else key = tree->iterToKey(iter); gtk_tree_iter_free(iter); return key; /*path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree->store), dataiter); if (!path) return NULL; if (!gtk_tree_path_up(path)) return NULL; return tree->pathToKey(path);*/ }
static void device_changed (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *_iter, gpointer data) { GtkTreeIter iter, *default_iter; gboolean powered, cont; default_iter = NULL; num_adapters_present = num_adapters_powered = 0; cont = gtk_tree_model_get_iter_first (model, &iter); while (cont) { gboolean is_default; num_adapters_present++; gtk_tree_model_get (model, &iter, BLUETOOTH_COLUMN_DEFAULT, &is_default, BLUETOOTH_COLUMN_POWERED, &powered, -1); if (powered) num_adapters_powered++; if (is_default && powered) default_iter = gtk_tree_iter_copy (&iter); cont = gtk_tree_model_iter_next (model, &iter); } update_discoverability (default_iter); update_icon_visibility (); update_menu_items (); update_device_list (default_iter); if (default_iter != NULL) gtk_tree_iter_free (default_iter); }
static void on_down_clicked( GtkButton *button, BaseWindow *window ) { GtkTreeView *treeview; GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter_selected; GtkTreeIter *iter_next; GtkTreePath *path_next; treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW )); selection = gtk_tree_view_get_selection( treeview ); if( gtk_tree_selection_get_selected( selection, &model, &iter_selected )){ iter_next = gtk_tree_iter_copy( &iter_selected ); if( gtk_tree_model_iter_next( model, iter_next )){ path_next = gtk_tree_model_get_path( model, iter_next ); gtk_list_store_move_after( GTK_LIST_STORE( model ), &iter_selected, iter_next ); gtk_tree_selection_unselect_all( selection ); gtk_tree_selection_select_path( selection, path_next ); gtk_tree_path_free( path_next ); } gtk_tree_iter_free( iter_next ); } }
static gboolean repair_dialog_on_idle_update(GtkDialog* dialog) { GtkTreeIter iter; GtkTreeIter* parent_iter; char* name; char* display_name; char* new_name; GFile* file; GFileType ftype; UpdateContext* context; gint n; int i; context = repair_dialog_get_update_context(dialog); if (context == NULL) { return FALSE; } for (i = 0; i < 500; i++) { if (context->file_stack == NULL) { repair_dialog_set_update_context(dialog, NULL); repair_dialog_on_update_end(dialog, context->success_all); update_context_free(context); return FALSE; } file = context->file_stack->data; if (context->enum_stack != NULL) { GFileInfo* info; GFileEnumerator* e; parent_iter = context->iter_stack->data; e = context->enum_stack->data; info = g_file_enumerator_next_file(e, NULL, NULL); if (info != NULL) { const char* name_const; name_const = g_file_info_get_name(info); display_name = get_display_name(name_const); new_name = get_new_name(name_const, context->encoding); file_list_model_append(context->store, &iter, parent_iter, NULL, name_const, display_name, new_name); if (new_name == NULL) context->success_all = FALSE; ftype = g_file_info_get_file_type(info); if (ftype == G_FILE_TYPE_DIRECTORY) { GFile* child; GFileEnumerator* child_e; GtkTreeIter* tmp_iter; tmp_iter = gtk_tree_iter_copy(&iter); child = g_file_get_child(file, name_const); child_e = g_file_enumerate_children(child, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); update_context_push(context, child, tmp_iter, child_e); } g_object_unref(info); g_free(display_name); g_free(new_name); n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(context->store), parent_iter); if (n == 1) { GtkTreePath* path; path = gtk_tree_model_get_path(GTK_TREE_MODEL(context->store), parent_iter); gtk_tree_view_expand_row(context->treeview, path, FALSE); gtk_tree_path_free(path); } } else { g_object_unref(file); gtk_tree_iter_free(parent_iter); g_object_unref(e); update_context_pop(context); } } else { context->file_stack = g_slist_delete_link(context->file_stack, context->file_stack); name = g_file_get_basename(file); display_name = get_display_name(name); new_name = get_new_name(name, context->encoding); file_list_model_append(context->store, &iter, NULL, file, name, display_name, new_name); if (new_name == NULL) context->success_all = FALSE; if (context->include_subdir) { ftype = g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL); if (ftype == G_FILE_TYPE_DIRECTORY) { GtkTreeIter* tmp_iter; GFileEnumerator* e; tmp_iter = gtk_tree_iter_copy(&iter); e = g_file_enumerate_children(file, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); update_context_push(context, file, tmp_iter, e); } } g_free(name); g_free(display_name); g_free(new_name); } } return TRUE; }