GList * oauth_account_manager_dialog_get_accounts (OAuthAccountManagerDialog *self) { GList *accounts; GtkTreeModel *tree_model; GtkTreeIter iter; tree_model = (GtkTreeModel *) GET_WIDGET ("accounts_liststore"); if (! gtk_tree_model_get_iter_first (tree_model, &iter)) return NULL; accounts = NULL; do { OAuthAccount *account; gtk_tree_model_get (tree_model, &iter, ACCOUNT_DATA_COLUMN, &account, -1); accounts = g_list_prepend (accounts, account); } while (gtk_tree_model_iter_next (tree_model, &iter)); return g_list_reverse (accounts); }
/** * 接收文件函数. *@param dlgpr 对话框类 * */ void DialogPeer::ReceiveFile(DialogPeer *dlgpr) { GtkWidget *widget; GtkTreeModel *model; GtkTreeIter iter; gchar *filename, *filepath; FileInfo *file; pthread_t pid; filepath = pop_save_path(GTK_WIDGET(dlgpr->grpinf->dialog)); g_free(progdt.path); progdt.path = filepath; /* 考察数据集中是否存在项 */ widget = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset), "file-to-receive-treeview-widget")); model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget)); if(!model) return; if (!gtk_tree_model_get_iter_first(model, &iter)) return; dlgpr->torcvsize = 0; /* 将选中的项投入文件数据接收类 */ do { gtk_tree_model_get(model, &iter,2, &filename, 5, &file, -1); g_free(file->filepath); file->filepath = g_strdup_printf("%s%s%s", filepath, *(filepath + 1) != '\0' ? "/" : "", filename); pthread_create(&pid, NULL, ThreadFunc(ThreadRecvFile), file); pthread_detach(pid); g_free(filename); dlgpr->torcvsize += file->filesize; } while (gtk_tree_model_iter_next(model, &iter)); dlgpr->rcvdsize = 0; dlgpr->timerrcv = g_timeout_add(300, GSourceFunc(UpdataEnclosureRcvUI), dlgpr); }
static void e_tz_map_set_location_text (ETzMap *tzmap, const gchar *name) { GtkWidget *location_combo; GtkTreeModel *model; GtkTreeIter iter; gboolean valid; gchar *location; location_combo = gst_dialog_get_widget (tzmap->tool->main_dialog, "location_combo"); model = gtk_combo_box_get_model (GTK_COMBO_BOX (location_combo)); valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter); while (valid) { gtk_tree_model_get (model, &iter, 0, &location, -1); if (strcmp (location, name) == 0) { gtk_combo_box_set_active_iter (GTK_COMBO_BOX (location_combo), &iter); valid = FALSE; } else { valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter); } } }
gchar* gcal_get_source_uid (GtkTreeModel *model, const gchar *name) { GtkTreeIter iter; gboolean valid; gchar *uid; uid = NULL; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gchar *name_data; gchar *uid_data; gtk_tree_model_get (model, &iter, 0, &uid_data, 1, &name_data, -1); if (g_strcmp0 (name_data, name) == 0) { uid = g_strdup (uid_data); g_free (name_data); g_free (uid_data); break; } g_free (name_data); g_free (uid_data); valid = gtk_tree_model_iter_next (model, &iter); } return uid; }
TILP_EXPORT void action_skip_clicked(GtkButton * button, gpointer user_data) { GtkTreeModel *model = GTK_TREE_MODEL(list); GtkTreeIter iter; gboolean valid; for (valid = gtk_tree_model_get_iter_first(model, &iter); valid; valid = gtk_tree_model_iter_next(model, &iter)) { FileEntry *f; VarEntry *v; int n; gtk_tree_model_get(model, &iter, COLUMN_DATA_F, &f, COLUMN_DATA_V, &v, COLUMN_DATA_N, &n, -1); if (!f->selected) continue; v->action = ACT_SKIP; gtk_list_store_set(list, &iter, COLUMN_ACTION, "skip", -1); } }
void ctk_config_stop_timer(CtkConfig *ctk_config, GSourceFunc function, gpointer data) { GtkTreeModel *model; GtkTreeIter iter; GSourceFunc func; gboolean valid; guint handle; TimerConfigProperty *timer_config; gboolean owner_enabled; gpointer model_data; model = GTK_TREE_MODEL(ctk_config->list_store); valid = gtk_tree_model_get_iter_first(model, &iter); while (valid) { gtk_tree_model_get(model, &iter, TIMER_CONFIG_COLUMN, &timer_config, OWNER_ENABLE_COLUMN, &owner_enabled, HANDLE_COLUMN, &handle, FUNCTION_COLUMN, &func, DATA_COLUMN, &model_data, -1); if ((func == function) && (model_data == data)) { /* Remove the timer if was running. */ if (timer_config->user_enabled && owner_enabled) { g_source_remove(handle); } gtk_list_store_set(ctk_config->list_store, &iter, OWNER_ENABLE_COLUMN, FALSE, -1); break; } valid = gtk_tree_model_iter_next(model, &iter); } }
gboolean bg_pictures_source_remove (BgPicturesSource *bg_source, const char *uri) { GtkTreeModel *model; GtkTreeIter iter; gboolean cont; gboolean retval; retval = FALSE; model = GTK_TREE_MODEL (bg_source_get_liststore (BG_SOURCE (bg_source))); cont = gtk_tree_model_get_iter_first (model, &iter); while (cont) { CcBackgroundItem *tmp_item; const char *tmp_uri; gtk_tree_model_get (model, &iter, 1, &tmp_item, -1); tmp_uri = cc_background_item_get_uri (tmp_item); if (g_str_equal (tmp_uri, uri)) { char *uuid; uuid = bg_pictures_source_get_unique_filename (uri); g_hash_table_insert (bg_source->priv->known_items, uuid, NULL); gtk_list_store_remove (GTK_LIST_STORE (model), &iter); retval = TRUE; break; } g_object_unref (tmp_item); cont = gtk_tree_model_iter_next (model, &iter); } return retval; }
static void ignore_clear_cb (GtkDialog *dialog, gint response) { GtkListStore *store = GTK_LIST_STORE (get_store ()); GtkTreeIter iter; gtk_widget_destroy (GTK_WIDGET (dialog)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter) && response == GTK_RESPONSE_OK) { /* remove from ignore_list */ do { char* mask = nullptr; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, MASK_COLUMN, &mask, -1); glib_string mask_ptr(mask); ignore_del (mask); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)); /* remove from GUI */ gtk_list_store_clear (store); } }
int nsp_feed_delete_item(NspFeed *feed, NspFeedItem *feed_item) { NspFeedItem *tmp_feed_item = NULL; NspApp *app = nsp_app_get(); GtkTreeIter iter; gboolean valid; int *feed_item_id = malloc(sizeof(int)); *feed_item_id = feed_item->id; feed_item->status |= NSP_FEED_ITEM_DELETED; nsp_jobs_queue(app->jobs, nsp_job_new( (NspCallback*)nsp_feed_delete_item_from_db, feed_item_id )); g_mutex_lock(feed->mutex); valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(feed->items_store), &iter); while (valid) { gtk_tree_model_get (GTK_TREE_MODEL(feed->items_store), &iter, ITEM_LIST_COL_ITEM_REF, &tmp_feed_item, -1 ); if ( tmp_feed_item != NULL && tmp_feed_item == feed_item ) { break; } valid = gtk_tree_model_iter_next (GTK_TREE_MODEL(feed->items_store), &iter); } if ( valid ) { gtk_tree_store_remove(feed->items_store, &iter); } g_mutex_unlock(feed->mutex); return 0; }
/* Called when one of the currently open displays is closed. * Remove it from our list of displays. */ static void display_closed_cb (GdkDisplay *display, gboolean is_error, ChangeDisplayInfo *info) { GtkTreeIter iter; gboolean valid; for (valid = gtk_tree_model_get_iter_first (info->display_model, &iter); valid; valid = gtk_tree_model_iter_next (info->display_model, &iter)) { GdkDisplay *tmp_display; gtk_tree_model_get (info->display_model, &iter, DISPLAY_COLUMN_DISPLAY, &tmp_display, -1); if (tmp_display == display) { gtk_list_store_remove (GTK_LIST_STORE (info->display_model), &iter); break; } } }
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 _combo_box_set_active_text(GtkComboBox *cb,gchar *text) { gboolean found=FALSE; gchar *sv=NULL; GtkTreeIter iter; GtkTreeModel *tm=gtk_combo_box_get_model(cb); if( gtk_tree_model_get_iter_first (tm,&iter) ) { do { GValue value = { 0, }; gtk_tree_model_get_value(tm,&iter,0,&value); if (G_VALUE_HOLDS_STRING (&value)) if( (sv=(gchar *)g_value_get_string(&value))!=NULL && strcmp(sv,text)==0) { gtk_combo_box_set_active_iter(cb, &iter); found=TRUE; break; } } while( gtk_tree_model_iter_next(tm,&iter) ); } return found; }
static void theme_delete_cb (GtkWidget *button, AppearanceData *data) { GtkIconView *icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")); GList *selected = gtk_icon_view_get_selected_items (icon_view); if (selected) { GtkTreePath *path = selected->data; GtkTreeModel *model = gtk_icon_view_get_model (icon_view); GtkTreeIter iter; gchar *name = NULL; if (gtk_tree_model_get_iter (model, &iter, path)) gtk_tree_model_get (model, &iter, COL_NAME, &name, -1); if (name != NULL && strcmp (name, data->theme_custom->name) && theme_delete (name, THEME_TYPE_META)) { /* remove theme from the model, too */ GtkTreeIter child; if (gtk_tree_model_iter_next (model, &iter) || theme_model_iter_last (model, &iter)) theme_select_iter (icon_view, &iter); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_sort_convert_iter_to_child_iter ( GTK_TREE_MODEL_SORT (model), &child, &iter); gtk_list_store_remove (data->theme_store, &child); } g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected); g_free (name); } }
/*! * Event-handler for editing the suggestion. */ void AP_UnixDialog_Spell::onSuggestionChanged () { UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::onSuggestionChanged()\n")); const gchar * modtext = gtk_entry_get_text(GTK_ENTRY(m_eChange)); UT_ASSERT(modtext); GtkTreeIter iter; GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions)); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)); GtkTreePath *first = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (model, &iter, first)) { gtk_tree_path_free (first); do { gchar *label = NULL; gtk_tree_model_get (model, &iter, COLUMN_SUGGESTION, &label, -1); if (g_ascii_strncasecmp (modtext, label, strlen (modtext)) == 0) { GtkTreePath *path = gtk_tree_model_get_path (model, &iter); g_signal_handler_block(G_OBJECT(selection), m_listHandlerID); gtk_tree_selection_select_path (selection, path); g_signal_handler_unblock(G_OBJECT(selection), m_listHandlerID); gtk_tree_path_free (path); return; } } while (gtk_tree_model_iter_next (model, &iter)); } else { gtk_tree_path_free (first); gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions))); } }
// reload xmp files of the selected images static void _reload_button_clicked(GtkButton *button, gpointer user_data) { dt_control_crawler_gui_t *gui = (dt_control_crawler_gui_t *)user_data; GtkTreeIter iter; gboolean valid = gtk_tree_model_get_iter_first(gui->model, &iter); while(valid) { gboolean selected; int id; gchar *xmp_path; gtk_tree_model_get(gui->model, &iter, DT_CONTROL_CRAWLER_COL_SELECTED, &selected, DT_CONTROL_CRAWLER_COL_ID, &id, DT_CONTROL_CRAWLER_COL_XMP_PATH, &xmp_path, -1); if(selected) { dt_history_load_and_apply(id, xmp_path, 0); valid = gtk_list_store_remove(GTK_LIST_STORE(gui->model), &iter); } else valid = gtk_tree_model_iter_next(gui->model, &iter); } // we also want to disable the "select all" thing _clear_select_all(gui); }
static void build_channel_list(void) { GtkTreeIter iter, iter2, iter3; unsigned int enabled; char *device, *device2; gboolean first = FALSE, iter3_valid = FALSE, loop, loop2, all = FALSE; char dev_ch[256]; loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (device_list_store), &iter); gtk_list_store_clear(channel_list_store); while (loop) { gtk_tree_model_get(GTK_TREE_MODEL (device_list_store), &iter, 0, &device, 1, &enabled, -1); if (enabled) { struct iio_device *dev; unsigned int i, nb_channels; all = true; /* is it already in the list? */ loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); if (loop2) { first = TRUE; iter3 = iter2; iter3_valid = TRUE; } while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) break; if (strcmp(device, device2) >= 0) { first = FALSE; iter3 = iter2; } g_free(device2); loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } /* it is, so skip the rest */ if (loop2) { loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); continue; } dev = get_device(device); if (!dev) continue; nb_channels = iio_device_get_channels_count(dev); for (i = 0; i < nb_channels; i++) { struct iio_channel *chn = iio_device_get_channel(dev, i); const char *name, *id, *devid; /* Must be input */ if (!is_valid_dmm_channel(chn)) continue; /* find the name */ devid = iio_device_get_id(dev); name = iio_channel_get_name(chn); id = iio_channel_get_id(chn); if (!name) name = id; if (iter3_valid) { if (first) { gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); first = FALSE; } else if(gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter3)) gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); else gtk_list_store_append(channel_list_store, &iter2); } else { gtk_list_store_append(channel_list_store, &iter2); iter3_valid = TRUE; } snprintf(dev_ch, sizeof(dev_ch), "%s:%s", device, name); gtk_list_store_set(channel_list_store, &iter2, 0, dev_ch, /* device & channel name */ 1, 0, /* On/Off */ 2, devid, /* device ID */ 3, id, /* channel ID */ -1); iter3 = iter2; } } else { loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) { loop2 = gtk_list_store_remove(channel_list_store, &iter2); continue; } loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } } loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); } gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(GTK_TREE_MODEL(channel_list_store)), 0, GTK_SORT_ASCENDING); if (all) gtk_widget_show(select_all_channels); else gtk_widget_hide(select_all_channels); }
static GList *select_from_list (GtkWindow *parent, GList *list, const gchar *title, const gchar *msg ) { GtkTreeIter iter; GtkCellRenderer *renderer; GtkWidget *view; gchar *latlon_string; int column_runner; GtkWidget *dialog = gtk_dialog_new_with_buttons (title, parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); /* When something is selected then OK */ gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) /* Default to not apply - as initially nothing is selected! */ response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); #endif GtkWidget *label = gtk_label_new ( msg ); GtkTreeStore *store = gtk_tree_store_new ( 6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN ); GList *list_runner = list; while (list_runner) { gpx_meta_data_t *gpx_meta_data = (gpx_meta_data_t *)list_runner->data; // To keep display compact three digits of precision for lat/lon should be plenty latlon_string = g_strdup_printf("(%.3f,%.3f)", gpx_meta_data->ll.lat, gpx_meta_data->ll.lon); gtk_tree_store_append(store, &iter, NULL); gtk_tree_store_set ( store, &iter, 0, gpx_meta_data->name, 1, gpx_meta_data->desc, 2, gpx_meta_data->timestamp, 3, latlon_string, 4, gpx_meta_data->vis, 5, gpx_meta_data->in_current_view, -1 ); list_runner = g_list_next ( list_runner ); g_free ( latlon_string ); } view = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new(); column_runner = 0; GtkTreeViewColumn *column; column = gtk_tree_view_column_new_with_attributes ( _("Name"), renderer, "text", column_runner, NULL); gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); column_runner++; column = gtk_tree_view_column_new_with_attributes ( _("Description"), renderer, "text", column_runner, NULL); gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); column_runner++; column = gtk_tree_view_column_new_with_attributes ( _("Time"), renderer, "text", column_runner, NULL); gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); column_runner++; column = gtk_tree_view_column_new_with_attributes ( _("Lat/Lon"), renderer, "text", column_runner, NULL); gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); column_runner++; column = gtk_tree_view_column_new_with_attributes ( _("Privacy"), renderer, "text", column_runner, NULL); // AKA Visibility gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new (); g_object_set (G_OBJECT (renderer_toggle), "activatable", FALSE, NULL); // No user action - value is just for display column_runner++; column = gtk_tree_view_column_new_with_attributes ( _("Within Current View"), renderer_toggle, "active", column_runner, NULL); gtk_tree_view_column_set_sort_column_id (column, column_runner); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store)); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE ); g_object_unref(store); GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); gtk_container_add ( GTK_CONTAINER(scrolledwindow), view ); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0); // Ensure a reasonable number of items are shown, but let the width be automatically sized gtk_widget_set_size_request ( dialog, -1, 400) ; gtk_widget_show_all ( dialog ); if ( response_w ) gtk_widget_grab_focus ( response_w ); while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT ) { // Possibily not the fastest method but we don't have thousands of entries to process... GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); GList *selected = NULL; // because we don't store the full data in the gtk model, we have to scan & look it up if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter) ) { do { if ( gtk_tree_selection_iter_is_selected ( selection, &iter ) ) { // For every selected item, // compare the name from the displayed view to every gpx entry to find the gpx this selection represents gchar* name; gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &name, -1 ); // I believe the name of these items to be always unique list_runner = list; while (list_runner) { if ( !strcmp ( ((gpx_meta_data_t*)list_runner->data)->name, name ) ) { gpx_meta_data_t *copied = copy_gpx_meta_data_t (list_runner->data); selected = g_list_prepend (selected, copied); break; } list_runner = g_list_next ( list_runner ); } } } while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter ) ); } if ( selected ) { gtk_widget_destroy ( dialog ); return selected; } a_dialog_error_msg(parent, _("Nothing was selected")); } gtk_widget_destroy ( dialog ); return NULL; }
static void source_list_changed_cb (ESourceList *source_list, ESourceComboBox *source_combo_box) { ESourceComboBoxPrivate *priv; GtkComboBox *combo_box; GtkTreeModel *model; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path; GSList *groups; GSList *sources, *s; const gchar *name; const gchar *uid; gchar *indented_name; gboolean visible = FALSE; gboolean iter_valid; priv = source_combo_box->priv; g_hash_table_remove_all (priv->uid_index); combo_box = GTK_COMBO_BOX (source_combo_box); gtk_combo_box_set_active (combo_box, -1); model = gtk_combo_box_get_model (combo_box); store = GTK_LIST_STORE (model); gtk_list_store_clear (store); for (groups = e_source_list_peek_groups (source_list); groups != NULL; groups = groups->next) { /* Only show source groups that have sources. */ if (e_source_group_peek_sources (groups->data) == NULL) continue; name = e_source_group_peek_name (groups->data); gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, COLUMN_COLOR, NULL, COLUMN_NAME, name, COLUMN_SENSITIVE, FALSE, COLUMN_SOURCE, groups->data, -1); sources = get_sorted_sources (e_source_group_peek_sources (groups->data)); for (s = sources; s != NULL; s = s->next) { const gchar *color_spec; GdkColor color; name = e_source_peek_name (s->data); indented_name = g_strconcat (" ", name, NULL); color_spec = e_source_peek_color_spec (s->data); if (color_spec != NULL) { gdk_color_parse (color_spec, &color); visible = TRUE; } gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, COLUMN_COLOR, color_spec ? &color : NULL, COLUMN_NAME, indented_name, COLUMN_SENSITIVE, TRUE, COLUMN_SOURCE, s->data, -1); uid = e_source_peek_uid (s->data); path = gtk_tree_model_get_path (model, &iter); g_hash_table_insert ( priv->uid_index, g_strdup (uid), gtk_tree_row_reference_new (model, path)); gtk_tree_path_free (path); g_free (indented_name); } g_slist_free (sources); } /* Set the visible column based on whether we've seen a color. */ iter_valid = gtk_tree_model_get_iter_first (model, &iter); while (iter_valid) { gtk_list_store_set ( store, &iter, COLUMN_VISIBLE, visible, -1); iter_valid = gtk_tree_model_iter_next (model, &iter); } }
void SetTableItemAll(int noAct, int noPat) { if (IsActReady() == false) return; GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table"); GtkListStore *store = (GtkListStore *)gtk_tree_view_get_model(table); char buf[20]; int max = actor->GetNumSprites(noAct, noPat); if (actor->matchRefHead && actor->enableRefHead) max++; int numS = gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(table)); int *selArray; if (!autoPlay) { selArray = (int *)malloc(sizeof(int)*max); GetSelectedTableItem(selArray); } gtk_list_store_clear(store); int i; for (i=0; i< actor->GetNumSprites(noAct, noPat); i++) { // colheader = {"SprNo", "SpType", "Xoffs", "Yoffs", "Mir", "AABBGGRR", "Xmag", "Ymag", "Rot"}; //spr no SNPRINTF(buf, sizeof(buf), "%d", actor->GetSprNoValue(noAct, noPat, i)); SetTableItem(buf, i, 0); //sp type SNPRINTF(buf, sizeof(buf), "%d", actor->GetSpTypeValue(noAct, noPat, i)); SetTableItem(buf, i, 1); int xo, yo; actor->GetOffsPoint(&xo, &yo, noAct, noPat, i); // xoffs SNPRINTF(buf, sizeof(buf), "%d", xo); SetTableItem(buf, i, 2); // yoffs SNPRINTF(buf, sizeof(buf), "%d", yo); SetTableItem(buf, i, 3); // mirror SNPRINTF(buf, sizeof(buf), "%d", actor->GetMirrorValue(noAct, noPat, i)); SetTableItem(buf, i, 4); // saturation SNPRINTF(buf, sizeof(buf), "%08X", actor->GetABGRValue(noAct, noPat, i)); SetTableItem(buf, i, 5); // xmag SNPRINTF(buf, sizeof(buf), "%f", actor->GetXMagValue(noAct, noPat, i)); SetTableItem(buf, i, 6); // ymag SNPRINTF(buf, sizeof(buf), "%f", actor->GetYMagValue(noAct, noPat, i)); SetTableItem(buf, i, 7); // rot SNPRINTF(buf, sizeof(buf), "%d", actor->GetRotValue(noAct, noPat, i)); SetTableItem(buf, i, 8); } if (actor->matchRefHead && actor->enableRefHead) { SetTableItem("EXT(ref head)", i, 0); int extX, extY; actor->GetExtOffsPoint(&extX, &extY, actor->curAct, actor->curPat); SNPRINTF(buf, sizeof(buf), "%d", extX); SetTableItem(buf, i, 2); SNPRINTF(buf, sizeof(buf), "%d", extY); SetTableItem(buf, i, 3); } if (!autoPlay) { GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; model = gtk_tree_view_get_model(GTK_TREE_VIEW(table)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(table)); gtk_tree_model_get_iter_first(model, &iter); int j=0; if (numS) { for (int i=0; i<max; i++, gtk_tree_model_iter_next(model, &iter)) { if (i == *(selArray+j)) { gtk_tree_selection_select_iter(selection, &iter); j++; } } } free(selArray); } }
static void dialog_info_update (GimpModuleDB *db, GimpModule *module, ModuleDialog *dialog) { GtkTreeModel *model = GTK_TREE_MODEL (dialog->list); GtkTreeIter iter; const gchar *text[NUM_INFOS] = { NULL, }; gchar *location = NULL; gboolean iter_valid; gint i; for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { GimpModule *this; gtk_tree_model_get (model, &iter, COLUMN_MODULE, &this, -1); if (this) g_object_unref (this); if (this == module) break; } if (iter_valid) dialog_list_item_update (dialog, &iter, module); /* only update the info if we're actually showing it */ if (module != dialog->selected) return; if (! module) { for (i = 0; i < NUM_INFOS; i++) gtk_label_set_text (GTK_LABEL (dialog->label[i]), NULL); gtk_label_set_text (GTK_LABEL (dialog->error_label), NULL); gtk_widget_hide (dialog->error_box); return; } if (module->on_disk) location = g_filename_display_name (module->filename); if (module->info) { text[INFO_AUTHOR] = module->info->author; text[INFO_VERSION] = module->info->version; text[INFO_DATE] = module->info->date; text[INFO_COPYRIGHT] = module->info->copyright; text[INFO_LOCATION] = module->on_disk ? location : _("Only in memory"); } else { text[INFO_LOCATION] = (module->on_disk ? location : _("No longer available")); } for (i = 0; i < NUM_INFOS; i++) gtk_label_set_text (GTK_LABEL (dialog->label[i]), text[i] ? text[i] : "--"); if (module->state == GIMP_MODULE_STATE_ERROR && module->last_module_error) { gtk_label_set_text (GTK_LABEL (dialog->error_label), module->last_module_error); gtk_widget_show (dialog->error_box); } else { gtk_label_set_text (GTK_LABEL (dialog->error_label), NULL); gtk_widget_hide (dialog->error_box); } }
/* **************************************************************************** * draw lines showing the route */ void draw_route (void) { GdkSegment *route_seg; gint destpos_x, destpos_y, curpos_x, curpos_y; gint i, j; gint t = 0; gchar t_routept[5]; GtkTreeIter iter_route; gdouble t_lon, t_lat; if (route.items < 1) return; i = (route.items + 5); route_seg = g_new0 (GdkSegment, i); if (local_config.use_database) { /* poi mode */ g_snprintf (t_routept, sizeof (t_routept), "%d", (route.pointer)); gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (route_list_tree), &iter_route, t_routept); calcxy (&curpos_x, &curpos_y, coords.current_lon, coords.current_lat, current.zoom); (route_seg)->x1 = curpos_x; (route_seg)->y1 = curpos_y; do { gtk_tree_model_get (GTK_TREE_MODEL (route_list_tree), &iter_route, ROUTE_LON, &t_lon, ROUTE_LAT, &t_lat, -1); if (t != 0) { (route_seg + t)->x1 = (route_seg + t - 1)->x2; (route_seg + t)->y1 = (route_seg + t - 1)->y2; } calcxy (&destpos_x, &destpos_y, t_lon, t_lat, current.zoom); (route_seg + t)->x2 = destpos_x; (route_seg + t)->y2 = destpos_y; t++; } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (route_list_tree), &iter_route)); } else { /* waypoints mode */ /* start beginning with actual route.pointer */ for (j = route.pointer; j < route.items; j++) { /* start drawing with current_pos */ if (j == route.pointer) { calcxy (&curpos_x, &curpos_y, coords.current_lon, coords.current_lat, current.zoom); (route_seg + t)->x1 = curpos_x; (route_seg + t)->y1 = curpos_y; } else { (route_seg + t)->x1 = (route_seg + t - 1)->x2; (route_seg + t)->y1 = (route_seg + t - 1)->y2; } calcxy (&destpos_x, &destpos_y, (routelist + j)->lon, (routelist + j)->lat, current.zoom); (route_seg + t)->x2 = destpos_x; (route_seg + t)->y2 = destpos_y; t++; } } gdk_gc_set_foreground (kontext_map, &colors.route); gdk_gc_set_background (kontext_map, &colors.white); gdk_gc_set_line_attributes (kontext_map, 4, GDK_LINE_ON_OFF_DASH, 0, 0); gdk_gc_set_dashes (kontext_map, 0, (gpointer) linestyles[local_config.style_route], 4); gdk_gc_set_function (kontext_map, GDK_COPY); gdk_draw_segments (drawable, kontext_map, (GdkSegment *) route_seg, t); g_free (route_seg); }
GtkTreePath * gbf_project_model_get_project_root_group (GbfProjectModel *model) { GtkTreePath *path = NULL; g_return_val_if_fail (GBF_IS_PROJECT_MODEL (model), NULL); if (model->priv->root_group == NULL) { GtkTreeIter root; path = gbf_project_model_get_project_root (model); if ((path != NULL) && gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &root, path)) { gboolean valid; GtkTreeIter iter; /* Search root group */ for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, &root); 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_GROUP) { path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); model->priv->root_group = gtk_tree_row_reference_new (GTK_TREE_MODEL (model), path); } } } } else { path = gtk_tree_row_reference_get_path (model->priv->root_group); } return path; }
/* Can return shortcut node if exist */ gboolean gbf_project_model_find_child_name (GbfProjectModel *model, GtkTreeIter *found, GtkTreeIter *parent, const gchar *name) { GtkTreeIter iter; gboolean valid; /* Search for direct children only */ for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, parent); valid == TRUE; 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 (gbf_tree_data_equal_name (data, name)) { *found = iter; break; } } return valid; }
gboolean gbf_project_model_find_node (GbfProjectModel *model, GtkTreeIter *found, GtkTreeIter *parent, AnjutaProjectNode *node) { GtkTreeIter iter; gboolean valid; /* Search for direct children */ for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, parent); valid == TRUE; 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 (node == gbf_tree_data_get_node (data)) { *found = iter; break; } } /* Search for children of children */ if (!valid) { for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, parent); valid == TRUE; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)) { if (gbf_project_model_find_node (model, found, &iter, node)) break; } } return valid; }
void gbf_project_model_add_target_shortcut (GbfProjectModel *model, GtkTreeIter *shortcut, GbfTreeData *target, GtkTreePath *before_path, gboolean *expanded) { AnjutaProjectNode *node; GtkTreeIter iter, sibling; GtkTreePath *root_path; GbfTreeData *data; AnjutaProjectNode *parent; gboolean valid = FALSE; if (!target) return; if (expanded != NULL) *expanded = FALSE; root_path = gbf_project_model_get_project_root (model); if ((before_path == NULL) && (target->type != GBF_TREE_NODE_SHORTCUT)) { /* Check is a proxy node is not already existing. It is used to * save the shortcut order */ 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; /* Look for current node */ gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1); if (((data->type == GBF_TREE_NODE_UNKNOWN) || (data->type == GBF_TREE_NODE_SHORTCUT)) && (g_strcmp0 (target->name, data->name) == 0)) { /* Find already existing node and replace it */ if (expanded != NULL) *expanded = data->expanded; gbf_tree_data_free (data); data = gbf_tree_data_new_shortcut (target); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, GBF_PROJECT_MODEL_COLUMN_DATA, data, -1); break; } } } if (!valid) { /* check before_path */ if ((before_path == NULL) || gtk_tree_path_get_depth (before_path) > 1 || gtk_tree_path_compare (before_path, root_path) > 0) { before_path = root_path; } /* get the tree iter for the row before which to insert the shortcut */ if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &sibling, before_path)) { gtk_tree_path_free (root_path); return; } if (target->type != GBF_TREE_NODE_SHORTCUT) { data = gbf_tree_data_new_shortcut (target); } else { data = target; } gtk_tree_store_insert_before (GTK_TREE_STORE (model), &iter, NULL, &sibling); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, GBF_PROJECT_MODEL_COLUMN_DATA, data, -1); } /* add sources */ parent = gbf_tree_data_get_node (target); for (node = anjuta_project_node_first_child (parent); node; node = anjuta_project_node_next_sibling (node)) gbf_project_model_add_node (model, node, &iter); gtk_tree_path_free (root_path); if (shortcut) *shortcut = iter; }
static gint default_sort_func (GtkTreeModel *model, GtkTreeIter *iter_a, GtkTreeIter *iter_b, gpointer user_data) { GbfTreeData *data_a, *data_b; gint retval = 0; gboolean unsorted_a, unsorted_b; gtk_tree_model_get (model, iter_a, GBF_PROJECT_MODEL_COLUMN_DATA, &data_a, -1); gtk_tree_model_get (model, iter_b, GBF_PROJECT_MODEL_COLUMN_DATA, &data_b, -1); unsorted_a = (data_a->type == GBF_TREE_NODE_SHORTCUT) || (data_a->type == GBF_TREE_NODE_UNKNOWN) || (data_a->is_shortcut); unsorted_b = (data_b->type == GBF_TREE_NODE_SHORTCUT) || (data_b->type == GBF_TREE_NODE_UNKNOWN) || (data_b->is_shortcut); if (unsorted_a && unsorted_b) { GtkTreeIter iter; gboolean valid; /* special case: the order of shortcuts is * user customizable */ for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter); valid == TRUE; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)) { GbfTreeData *data; gtk_tree_model_get (model, &iter, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1); if (data == data_a) { /* a comes first */ retval = -1; break; } else if (data == data_b) { /* b comes first */ retval = 1; break; } } } else if (unsorted_a && !unsorted_b) { retval = -1; } else if (!unsorted_a && unsorted_b) { retval = 1; } else if (data_a->type == data_b->type) { retval = strcmp (data_a->name, data_b->name); } else { /* assume a->b and check for the opposite cases */ retval = -1; retval = data_a->type < data_b->type ? -1 : 1; } return retval; }
/**************************************************************** Make itree to go forward one step *****************************************************************/ void itree_next(ITree *it) { it->end = !gtk_tree_model_iter_next(it->model, &it->it); }
static gboolean dmm_update(gpointer foo) { GtkTreeIter tree_iter; char *name, *device, *channel, tmp[128]; gboolean loop, enabled; double value; GtkTextBuffer *buf; GtkTextIter text_iter; /* start at the top every time */ buf = gtk_text_buffer_new(NULL); gtk_text_buffer_get_iter_at_offset(buf, &text_iter, 0); if (this_page == gtk_notebook_get_current_page(nbook) || plugin_detached) { loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(channel_list_store), &tree_iter); while (loop) { gtk_tree_model_get(GTK_TREE_MODEL(channel_list_store), &tree_iter, 0, &name, 1, &enabled, 2, &device, 3, &channel, -1); if (enabled) { struct iio_device *dev = get_device(device); struct iio_channel *chn = get_channel(dev, channel); if (iio_channel_find_attr(chn, "raw")) value = read_double_attr(chn, "raw"); else if (iio_channel_find_attr(chn, "processed")) value = read_double_attr(chn, "processed"); else if (iio_channel_find_attr(chn, "input")) value = read_double_attr(chn, "input"); else { sprintf(tmp, "skipping %s", name); goto dmm_update_next; } if (iio_channel_find_attr(chn, "offset")) value += read_double_attr(chn, "offset"); if (iio_channel_find_attr(chn, "scale")) value *= read_double_attr(chn, "scale"); if (!strncmp(channel, "voltage", 7)) sprintf(tmp, "%s = %f Volts\n", name, value / 1000); else if (!strncmp(channel, "temp", 4)) sprintf(tmp, "%s = %3.2f °C\n", name, value / 1000); else if (!strncmp(channel, "current", 4)) sprintf(tmp, "%s = %f Milliampere\n", name, value); else if (!strncmp(channel, "accel", 5)) sprintf(tmp, "%s = %f m/s²\n", name, value); else if (!strncmp(channel, "anglvel", 7)) sprintf(tmp, "%s = %f rad/s\n", name, value); else if (!strncmp(channel, "pressure", 8)) sprintf(tmp, "%s = %f kPa\n", name, value); else if (!strncmp(channel, "magn", 4)) sprintf(tmp, "%s = %f Gauss\n", name, value); else sprintf(tmp, "%s = %f\n", name, value); gtk_text_buffer_insert(buf, &text_iter, tmp, -1); } dmm_update_next: loop = gtk_tree_model_iter_next(GTK_TREE_MODEL(channel_list_store), &tree_iter); } gtk_text_view_set_buffer(GTK_TEXT_VIEW(dmm_results), buf); g_object_unref(buf); } return dmm_update_loop_running; }
static void response_cb (CajaOpenWithDialog *dialog, int response_id, gpointer data) { GAppInfo *application; switch (response_id) { case RESPONSE_OPEN: if (check_application (dialog)) { application = add_or_find_application (dialog); if (application) { emit_application_selected (dialog, application); g_object_unref (application); gtk_widget_destroy (GTK_WIDGET (dialog)); } } break; case RESPONSE_REMOVE: if (dialog->details->selected_app_info != NULL) { if (g_app_info_delete (dialog->details->selected_app_info)) { GtkTreeModel *model; GtkTreeIter iter; GAppInfo *info, *selected; selected = dialog->details->selected_app_info; dialog->details->selected_app_info = NULL; model = GTK_TREE_MODEL (dialog->details->program_list_store); if (gtk_tree_model_get_iter_first (model, &iter)) { do { gtk_tree_model_get (model, &iter, COLUMN_APP_INFO, &info, -1); if (g_app_info_equal (selected, info)) { gtk_list_store_remove (dialog->details->program_list_store, &iter); break; } } while (gtk_tree_model_iter_next (model, &iter)); } g_object_unref (selected); } } break; case GTK_RESPONSE_NONE: case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: gtk_widget_destroy (GTK_WIDGET (dialog)); break; default : g_assert_not_reached (); } }
static void brasero_medium_selection_medium_added_cb (BraseroMediumMonitor *monitor, BraseroMedium *medium, BraseroMediumSelection *self) { BraseroMediumSelectionPrivate *priv; gboolean add = FALSE; GtkTreeModel *model; BraseroDrive *drive; gchar *medium_name; GIcon *medium_icon; GtkTreeIter iter; priv = BRASERO_MEDIUM_SELECTION_PRIVATE (self); model = gtk_combo_box_get_model (GTK_COMBO_BOX (self)); /* Make sure it's not already in our list */ if (gtk_tree_model_get_iter_first (model, &iter)) { do { BraseroMedium *tmp; tmp = NULL; gtk_tree_model_get (model, &iter, MEDIUM_COL, &tmp, -1); if (tmp == medium) return; } while (gtk_tree_model_iter_next (model, &iter)); } /* Make sure it does fit the types of media to display */ drive = brasero_medium_get_drive (medium); if ((priv->type & BRASERO_MEDIA_TYPE_CD) == priv->type && (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD)) add = TRUE; if ((priv->type & BRASERO_MEDIA_TYPE_ANY_IN_BURNER) && (brasero_drive_can_write (drive))) { if ((priv->type & BRASERO_MEDIA_TYPE_CD)) { if (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD) add = TRUE; } else add = TRUE; } if ((priv->type & BRASERO_MEDIA_TYPE_AUDIO) && (brasero_medium_get_status (medium) & BRASERO_MEDIUM_HAS_AUDIO)) { if ((priv->type & BRASERO_MEDIA_TYPE_CD)) { if (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD) add = TRUE; } else add = TRUE; } if ((priv->type & BRASERO_MEDIA_TYPE_DATA) && (brasero_medium_get_status (medium) & BRASERO_MEDIUM_HAS_DATA)) { if ((priv->type & BRASERO_MEDIA_TYPE_CD)) { if (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD) add = TRUE; } else add = TRUE; } if (priv->type & BRASERO_MEDIA_TYPE_WRITABLE) { if (brasero_medium_can_be_written (medium)) { if ((priv->type & BRASERO_MEDIA_TYPE_CD)) { if (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD) add = TRUE; } else add = TRUE; } } if (priv->type & BRASERO_MEDIA_TYPE_REWRITABLE) { if (brasero_medium_can_be_rewritten (medium)) { if ((priv->type & BRASERO_MEDIA_TYPE_CD)) { if (brasero_medium_get_status (medium) & BRASERO_MEDIUM_CD) add = TRUE; } else add = TRUE; } } if (!add) { BraseroMedium *tmp; /* Try to get the first iter (it shouldn't fail) */ if (!gtk_tree_model_get_iter_first (model, &iter)) { brasero_medium_selection_add_no_disc_entry (self); return; } /* See if that's a real medium or not; if so, return. */ tmp = NULL; gtk_tree_model_get (model, &iter, MEDIUM_COL, &tmp, -1); if (tmp) { g_object_unref (tmp); return; } brasero_medium_selection_update_no_disc_entry (self, model, &iter); return; } /* remove warning message */ if (gtk_tree_model_get_iter_first (model, &iter)) { BraseroMedium *tmp; gtk_tree_model_get (model, &iter, MEDIUM_COL, &tmp, -1); if (!tmp) gtk_list_store_remove (GTK_LIST_STORE (model), &iter); else g_object_unref (tmp); } gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, -1, MEDIUM_COL, medium, -1); medium_name = brasero_medium_selection_get_medium_string (self, medium); medium_icon = brasero_volume_get_icon (BRASERO_VOLUME (medium)); gtk_list_store_set (GTK_LIST_STORE (model), &iter, NAME_COL, medium_name, ICON_COL, medium_icon, VISIBLE_TEXT_COL, TRUE, VISIBLE_PROGRESS_COL, FALSE, -1); g_free (medium_name); g_object_unref (medium_icon); gtk_widget_set_sensitive (GTK_WIDGET (self), TRUE); if (gtk_combo_box_get_active (GTK_COMBO_BOX (self)) == -1) { gtk_combo_box_set_active_iter (GTK_COMBO_BOX (self), &iter); brasero_medium_selection_set_current_medium (self, &iter); } }