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);
}
Example #2
0
/**
 * 接收文件函数.
 *@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);
		}
	}
}
Example #4
0
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;
}
Example #5
0
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);
	}
}
Example #6
0
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;
}
Example #8
0
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);
	}
}
Example #9
0
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 );
	}
}
Example #12
0
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)));
	}
}
Example #15
0
// 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);
}
Example #16
0
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);
}
Example #17
0
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;
}
Example #18
0
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);
	}
}
Example #19
0
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);
  }
}
Example #20
0
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);
    }
}
Example #21
0
/* ****************************************************************************
 * 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);
}
Example #22
0
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;
}
Example #23
0
/* 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;
}
Example #24
0
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;
}
Example #25
0
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;
}
Example #26
0
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;
}
Example #27
0
/****************************************************************
  Make itree to go forward one step
*****************************************************************/
void itree_next(ITree *it)
{
  it->end = !gtk_tree_model_iter_next(it->model, &it->it);
}
Example #28
0
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);
    }
}