Beispiel #1
0
RemminaFTPTask*
remmina_ftp_client_get_waiting_task(RemminaFTPClient *client)
{
	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
	GtkTreePath *path;
	GtkTreeIter iter;
	RemminaFTPTask task;

	if (!gtk_tree_model_get_iter_first(priv->task_list_model, &iter))
		return NULL;

	while (1)
	{
		gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, &task.type,
				REMMINA_FTP_TASK_COLUMN_NAME, &task.name, REMMINA_FTP_TASK_COLUMN_SIZE, &task.size,
				REMMINA_FTP_TASK_COLUMN_TASKID, &task.taskid, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &task.tasktype,
				REMMINA_FTP_TASK_COLUMN_REMOTEDIR, &task.remotedir, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
				&task.localdir, REMMINA_FTP_TASK_COLUMN_STATUS, &task.status, REMMINA_FTP_TASK_COLUMN_DONESIZE,
				&task.donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &task.tooltip, -1);
		if (task.status == REMMINA_FTP_TASK_STATUS_WAIT)
		{
			path = gtk_tree_model_get_path(priv->task_list_model, &iter);
			task.rowref = gtk_tree_row_reference_new(priv->task_list_model, path);
			gtk_tree_path_free(path);
			return (RemminaFTPTask*) g_memdup(&task, sizeof(RemminaFTPTask));
		}
		if (!gtk_tree_model_iter_next(priv->task_list_model, &iter))
			break;
	}

	return NULL;
}
Beispiel #2
0
GtkTreePath *
gbf_project_model_get_project_root (GbfProjectModel *model)
{
	GtkTreePath *path = NULL;
	
	g_return_val_if_fail (GBF_IS_PROJECT_MODEL (model), NULL);

	if (model->priv->root == NULL)
	{
		GtkTreeIter iter;
		gboolean valid;

		/* Search root group */
		for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, NULL); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter))
		{
			GbfTreeData *data;
			
			gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
	   			 GBF_PROJECT_MODEL_COLUMN_DATA, &data,
		    		-1);

			if (data->type == GBF_TREE_NODE_ROOT)
			{
				path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
				model->priv->root = gtk_tree_row_reference_new (GTK_TREE_MODEL (model), path);
			}
		}
	}
	else
	{
		path = gtk_tree_row_reference_get_path (model->priv->root);
	}
	
	return path;
}
Beispiel #3
0
/*
 * add empty row
 */
static void add_empty_row(void)
{
	GtkTreeIter empty;
	GtkTreePath *path;

	if (empty_row)
		gtk_tree_row_reference_free(empty_row);
	
	gtk_tree_store_prepend (store, &empty, NULL);
	gtk_tree_store_set (store, &empty,
		W_NAME, "",
		W_VALUE, "",
		W_TYPE, "",
		W_LAST_VISIBLE, "",
		W_INTERNAL, "",
		W_EXPRESSION, "",
		W_STUB, 0,
		W_CHANGED, 0,
		W_VT, VT_NONE,
		-1);

	/* save reference */
	path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &empty);
	empty_row = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path);
	gtk_tree_path_free(path);
}
static VALUE
treerowref_initialize(int argc, VALUE *argv, VALUE self)
{
  VALUE proxy, model, path;
  GtkTreeRowReference* ref;
    
  if (argc == 3){
    rb_scan_args(argc, argv, "3", &proxy, &model, &path);
    G_CHILD_SET(self, id_proxy, proxy);
    ref = gtk_tree_row_reference_new_proxy(RVAL2GOBJ(proxy),
                                           GTK_TREE_MODEL(RVAL2GOBJ(model)), 
                                           RVAL2GTKTREEPATH(path));
  } else {
    rb_scan_args(argc, argv, "2", &model, &path);
    ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(RVAL2GOBJ(model)), 
                                     RVAL2GTKTREEPATH(path));
  }
  if (ref == NULL)
      rb_raise(rb_eArgError, "Invalid arguments were passed.");

  G_CHILD_SET(self, id_model, model);
  G_CHILD_SET(self, id_path, path);
  
  G_INITIALIZE(self, ref);
  return Qnil;
}
Beispiel #5
0
static DmaVariablePacket *
dma_variable_packet_new(GtkTreeModel *model,
                     GtkTreeIter *iter,
					 DmaDebuggerQueue *debugger,
					 DmaVariableData *data,
					 guint from)
{
	GtkTreePath *path;
						 
	g_return_val_if_fail (model, NULL);
	g_return_val_if_fail (iter, NULL);

	DmaVariablePacket *pack = g_new (DmaVariablePacket, 1);

	pack->data = data;
	pack->from = from;
	pack->model = GTK_TREE_MODEL (model);
	path = gtk_tree_model_get_path(model, iter); 
	pack->reference = gtk_tree_row_reference_new (model, path);
	gtk_tree_path_free (path);
	pack->debugger = debugger;
	pack->next = data->packet;
	data->packet = pack;

	return pack;
}
Beispiel #6
0
gboolean
gtk_cell_view_get_size_of_row (GtkCellView    *cell_view,
                               GtkTreePath    *path,
                               GtkRequisition *requisition)
{
  GtkTreeRowReference *tmp;
  GtkRequisition req;

  g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE);
  g_return_val_if_fail (path != NULL, FALSE);
  g_return_val_if_fail (requisition != NULL, FALSE);

  tmp = cell_view->priv->displayed_row;
  cell_view->priv->displayed_row =
    gtk_tree_row_reference_new (cell_view->priv->model, path);

  gtk_cell_view_size_request (GTK_WIDGET (cell_view), requisition);

  gtk_tree_row_reference_free (cell_view->priv->displayed_row);
  cell_view->priv->displayed_row = tmp;

  /* restore actual size info */
  gtk_cell_view_size_request (GTK_WIDGET (cell_view), &req);

  return TRUE;
}
Beispiel #7
0
/**
 * gtk_cell_view_get_size_of_row:
 * @cell_view: a #GtkCellView
 * @path: a #GtkTreePath 
 * @requisition: (out): return location for the size 
 *
 * Sets @requisition to the size needed by @cell_view to display 
 * the model row pointed to by @path.
 * 
 * Return value: %TRUE
 *
 * Since: 2.6
 * 
 * Deprecated: 3.0: Combo box formerly used this to calculate the
 * sizes for cellviews, now you can achieve this by either using
 * the #GtkCellView:fit-model property or by setting the currently
 * displayed row of the #GtkCellView and using gtk_widget_get_preferred_size().
 */
gboolean
gtk_cell_view_get_size_of_row (GtkCellView    *cell_view,
                               GtkTreePath    *path,
                               GtkRequisition *requisition)
{
  GtkTreeRowReference *tmp;
  GtkRequisition req;

  g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE);
  g_return_val_if_fail (path != NULL, FALSE);

  tmp = cell_view->priv->displayed_row;
  cell_view->priv->displayed_row =
    gtk_tree_row_reference_new (cell_view->priv->model, path);

  gtk_widget_get_preferred_width (GTK_WIDGET (cell_view), &req.width, NULL);
  gtk_widget_get_preferred_height_for_width (GTK_WIDGET (cell_view), req.width, &req.height, NULL);

  gtk_tree_row_reference_free (cell_view->priv->displayed_row);
  cell_view->priv->displayed_row = tmp;

  if (requisition)
    *requisition = req;

  return TRUE;
}
static void
wp_props_load_wallpaper (gchar *key,
                         MateWPItem *item,
                         AppearanceData *data)
{
  GtkTreeIter iter;
  GtkTreePath *path;
  GdkPixbuf *pixbuf;

  if (item->deleted == TRUE)
    return;

  gtk_list_store_append (GTK_LIST_STORE (data->wp_model), &iter);

  pixbuf = mate_wp_item_get_thumbnail (item, data->thumb_factory,
                                        data->thumb_width,
                                        data->thumb_height);
  mate_wp_item_update_description (item);

  gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter,
                      0, pixbuf,
                      1, item,
                      -1);

  if (pixbuf != NULL)
    g_object_unref (pixbuf);

  path = gtk_tree_model_get_path (data->wp_model, &iter);
  item->rowref = gtk_tree_row_reference_new (data->wp_model, path);
  g_signal_connect (item->bg, "changed", G_CALLBACK (on_item_changed), data);
  gtk_tree_path_free (path);
}
Beispiel #9
0
static void
gimp_scale_combo_box_mru_add (GimpScaleComboBox *combo_box,
                              GtkTreeIter       *iter)
{
  GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
  GtkTreePath  *path  = gtk_tree_model_get_path (model, iter);
  GList        *list;
  gboolean      found;

  for (list = combo_box->mru, found = FALSE; list && !found; list = list->next)
    {
      GtkTreePath *this = gtk_tree_row_reference_get_path (list->data);

      if (gtk_tree_path_compare (this, path) == 0)
        {
          if (list->prev)
            {
              combo_box->mru = g_list_remove_link (combo_box->mru, list);
              combo_box->mru = g_list_concat (list, combo_box->mru);
            }

          found = TRUE;
        }

      gtk_tree_path_free (this);
    }

  if (! found)
    combo_box->mru = g_list_prepend (combo_box->mru,
                                     gtk_tree_row_reference_new (model, path));

  gtk_tree_path_free (path);
}
static void remove_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) {
  GtkTreeModel *model;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->compositionTreeView));
  GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, &model);
  gint n_selected_rows = gtk_tree_selection_count_selected_rows(selection);

  GtkTreeRowReference **refs = (GtkTreeRowReference**) g_malloc(sizeof(GtkTreeRowReference*)*n_selected_rows);
  int i;
  // the following really needs two for loops!!!
  // paths change while rows are being added or removed, while references never change
  for (i = 0 ; i < n_selected_rows ; i++) {
    refs[i] = gtk_tree_row_reference_new(model, (GtkTreePath *) g_list_nth_data(selected_rows, i));
  }
  for (i = 0 ; i < n_selected_rows ; i++) {
    GtkTreePath *path = gtk_tree_row_reference_get_path(refs[i]);
    GtkTreeIter iter;
    gtk_tree_model_get_iter(model, &iter, path);
    //delete row happens here
    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
    gtk_tree_path_free(path);
    gtk_tree_row_reference_free(refs[i]);
  }

  g_list_free_full(selected_rows, (GDestroyNotify) gtk_tree_path_free);
  g_free(refs);

  //the sum needs to be updated
  update_sum(dialog);

  return;
}
Beispiel #11
0
/* folder_new */
Folder * folder_new(AccountFolder * folder, FolderType type, char const * name,
		GtkTreeStore * store, GtkTreeIter * iter)
{
	Folder * ret;
	GtkTreePath * path;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, name);
#endif
	if((ret = object_new(sizeof(*ret))) == NULL)
		return NULL;
	name = _get_local_name(type, name);
	ret->name = string_new(name);
	ret->store = store;
	path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), iter);
	ret->row = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path);
	gtk_tree_path_free(path);
	gtk_tree_store_set(store, iter, MFC_FOLDER, ret, MFC_NAME, name, -1);
	folder_set_type(ret, type);
	ret->messages = gtk_tree_store_new(MHC_COUNT, G_TYPE_POINTER,
			G_TYPE_POINTER, G_TYPE_POINTER, GDK_TYPE_PIXBUF,
			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT,
			G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT);
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(ret->messages),
			MHC_DATE, GTK_SORT_DESCENDING);
	ret->data = folder;
	if(ret->name == NULL)
	{
		folder_delete(ret);
		return NULL;
	}
	return ret;
}
Beispiel #12
0
/* ForEach function. Adds corresponding GtkTreeRowReference to a GList for a GtkTreePath */
void path_to_row_reference(GtkTreePath *path, GList **reference)
{
	*reference =
		g_list_append(*reference,
		gtk_tree_row_reference_new(GTK_TREE_MODEL(account_list_store),
			path));
}
void CExpressDlg::foreach_sel_files(GtkTreeModel *model, GtkTreePath *path, 
							   GtkTreeIter *iter, gpointer userdata)
{
	GList **list = ((GList**)userdata);
	GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path);
	*list = g_list_append(*list, rowref);
}
Beispiel #14
0
void notes_note_delete_selected(Notes * notes)
{
	GtkTreeSelection * treesel;
	GList * selected;
	GtkTreeModel * model = GTK_TREE_MODEL(notes->store);
	GtkTreeRowReference * reference;
	GList * s;
	GtkTreePath * path;

	if((treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(notes->view)))
			== NULL)
		return;
	if((selected = gtk_tree_selection_get_selected_rows(treesel, NULL))
			== NULL)
		return;
	if(_notes_confirm(notes->window, _("Are you sure you want to delete the"
					" selected note(s)?")) != 0)
		return;
	for(s = g_list_first(selected); s != NULL; s = g_list_next(s))
	{
		if((path = s->data) == NULL)
			continue;
		reference = gtk_tree_row_reference_new(model, path);
		s->data = reference;
		gtk_tree_path_free(path);
	}
	g_list_foreach(selected, (GFunc)_note_delete_selected_foreach, notes);
	g_list_free(selected);
}
Beispiel #15
0
static void
configure_combo_box_add (GtkComboBox *combo_box, const gchar *item,
                         const gchar *value)
{
	GtkTreeRowReference *reference;
	GtkTreeModel *model;
	GtkTreePath *path;
	GHashTable *index;
	GtkTreeIter iter;

	model = gtk_combo_box_get_model (combo_box);
	gtk_list_store_append (GTK_LIST_STORE (model), &iter);

	gtk_list_store_set (
		GTK_LIST_STORE (model), &iter,
		COLUMN_ITEM, item, COLUMN_VALUE, value, -1);

	index = g_object_get_data (G_OBJECT (combo_box), "index");
	g_return_if_fail (index != NULL);

	/* Add an entry to the tree model index. */
	path = gtk_tree_model_get_path (model, &iter);
	reference = gtk_tree_row_reference_new (model, path);
	g_return_if_fail (reference != NULL);
	g_hash_table_insert (index, g_strdup (value), reference);
	gtk_tree_path_free (path);
}
Beispiel #16
0
void wp_add(GtkWidget *cat_tree)
{
	GtkTreePath *path = NULL;
	GtkListStore *pl3_tree = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cat_tree));
	GtkTreeIter iter;
	if(!cfg_get_single_value_as_int_with_default(config, "wp-plugin", "enable", 0)) return;
	gtk_list_store_append(pl3_tree, &iter);
	gtk_list_store_set(pl3_tree, &iter,
			PL3_CAT_TYPE, plugin.id,
			PL3_CAT_TITLE, _("Wikipedia Lookup"),
			PL3_CAT_ICON_ID, "wikipedia",
			-1);
	if (wiki_ref)
	{
		gtk_tree_row_reference_free(wiki_ref);
		wiki_ref = NULL;
	}

	path = gtk_tree_model_get_path(GTK_TREE_MODEL(playlist3_get_category_tree_store()), &iter);
	if (path)
	{
		wiki_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(playlist3_get_category_tree_store()), path);
		gtk_tree_path_free(path);
	}

}
Beispiel #17
0
static void on_remove_autorun_choice_clicked(GtkButton *button, GtkTreeView *view)
{
    GtkTreeSelection *tree_sel = gtk_tree_view_get_selection(view);
    GtkTreeModel *model;
    GList *rows = gtk_tree_selection_get_selected_rows(tree_sel, &model), *l;
    GtkTreeIter it;

    /* convert paths to references */
    for (l = rows; l; l = l->next)
    {
        GtkTreePath *tp = l->data;
        l->data = gtk_tree_row_reference_new(model, tp);
        gtk_tree_path_free(tp);
    }
    /* remove rows from model */
    for (l = rows; l; l = l->next)
    {
        if (gtk_tree_model_get_iter(model, &it, gtk_tree_row_reference_get_path(l->data)))
        {
            char *type;

            gtk_tree_model_get(model, &it, 2, &type, -1);
            if (type)
                g_hash_table_remove(app_config->autorun_choices, type);
            g_free(type);
            gtk_list_store_remove(GTK_LIST_STORE(model), &it);
        }
        else
            g_critical("autorun_choice not found in model");
        gtk_tree_row_reference_free(l->data);
    }
    g_list_free(rows);
}
Beispiel #18
0
static void remove_events(GtkButton *remove, GtkTreeView *treeview) {
  GtkTreeSelection *selection;
  GtkTreeRowReference *ref;
  GtkTreeModel *model;
  GList *rows, *ptr, *references = NULL;

  selection = gtk_tree_view_get_selection(treeview);
  model = gtk_tree_view_get_model(treeview);
  rows = gtk_tree_selection_get_selected_rows(selection, &model);

  ptr = rows;
  while (ptr != NULL) {
    ref = gtk_tree_row_reference_new(model, (GtkTreePath*)ptr->data);
    references = g_list_prepend(references, gtk_tree_row_reference_copy(ref));
    gtk_tree_row_reference_free(ref);
    ptr = ptr->next;
  }

  g_list_foreach(references, (GFunc)remove_row, model);

  g_list_foreach(references, (GFunc)gtk_tree_row_reference_free, NULL);
  g_list_foreach(rows, (GFunc)gtk_tree_path_free, NULL);
  g_list_free(references);
  g_list_free(rows);
}
static void
add_one_category (GncExampleAccount *acc,
                  hierarchy_data *data)
{
    GtkTreeView *view;
    GtkListStore *store;
    GtkTreeIter iter;
    GtkTreePath* path;
    gboolean use_defaults;

    g_return_if_fail(acc != NULL);
    g_return_if_fail(data != NULL);

    view = data->categories_tree;
    store = GTK_LIST_STORE(gtk_tree_view_get_model(view));
    use_defaults = data->use_defaults && acc->start_selected;

    gtk_list_store_append(store, &iter);
    gtk_list_store_set(store, &iter,
                       COL_CHECKED, use_defaults,
                       COL_TITLE, acc->title,
                       COL_SHORT_DESCRIPTION, acc->short_description,
                       COL_LONG_DESCRIPTION, acc->long_description,
                       COL_ACCOUNT, acc,
                       -1);

    if (use_defaults)
    {
        data->category_set_changed = TRUE;
        path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
        data->initial_category = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path);
        gtk_tree_path_free(path);
    }
}
Beispiel #20
0
Datei: auth.c Projekt: laminic/cs
void cb_auth_cell_edited(GtkCellRendererText *cell, const gchar *path_string, 
						const gchar *new_text, gpointer data)
{
	GtkTreeModel *model = (GtkTreeModel *) data;
	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
	GtkTreeIter iter;
	GSList *iterator;
	GtkTreeRowReference *cur_iter;
	gboolean in = FALSE;

	cur_iter = gtk_tree_row_reference_new(model, path);	


	gint column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), "column"));

	gtk_tree_model_get_iter(model, &iter, path);

	gtk_list_store_set(GTK_LIST_STORE(model), &iter, column, new_text, -1);				

	for (iterator = upt_list; iterator; iterator = iterator->next) {
		if (cur_iter == iterator->data) {
			in = TRUE;
			break;
		}
	}
	if(!in) {
		upt_list = g_slist_append(upt_list, cur_iter);
	}

	gtk_tree_path_free(path);
}
Beispiel #21
0
void
on_tabu_playlist_row_activated_event ( GtkTreeView *view )
{
  GList *selected;
  GtkTreeModel *store;
  GtkTreeIter iter;
  gchar *uri;

  GtkTreeSelection *selection = gtk_tree_view_get_selection ( view );

  selected = gtk_tree_selection_get_selected_rows ( selection, &store );

  if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, selected->data))
  {
    gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 2, &uri, -1);

    tabu_playlist_set_song (tabu_get_playlist(), FALSE);
    TABU_PLAYLIST (tabu_get_playlist())->reference = gtk_tree_row_reference_new (store, selected->data);
    tabu_playlist_set_song (tabu_get_playlist(), TRUE);

    tabu_backend_play_uri (uri);
  }

  g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
  g_list_free (selected);
}
Beispiel #22
0
static GList *
gnac_profiles_mgr_get_selected_rows(void)
{
  GtkTreeModel *model = GTK_TREE_MODEL(
      gnac_profiles_mgr_get_object("liststore"));
  GtkTreeView *view = GTK_TREE_VIEW(
      gnac_profiles_mgr_get_widget("profile_treeview"));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(view);

  /* Convert path to GtkTreeRowReference */
  GList *next = gtk_tree_selection_get_selected_rows(selection, &model);
  GList *next_temp = next;
  GList *row_references = NULL;

  while (next) {
    row_references = g_list_prepend(row_references,
        gtk_tree_row_reference_new(model, next->data));
    next = g_list_next(next);
  }

  row_references = g_list_reverse(row_references);

  g_list_free_full(next_temp, (GDestroyNotify) gtk_tree_path_free);

  return row_references;
}
Beispiel #23
0
static void
key_store_row_add (CryptUIKeyStore *ckstore, const gchar *key, GtkTreeIter *iter)
{
    GtkTreePath *path;
    GtkTreeRowReference *ref;

    /* Do we already have a row for this key? */
    ref = (GtkTreeRowReference*)g_hash_table_lookup (ckstore->priv->rows, key);
    if (ref != NULL) {

        /* If so return the previous reference */
        path = gtk_tree_row_reference_get_path (ref);
        if (path != NULL) {
            gtk_tree_model_get_iter (GTK_TREE_MODEL (ckstore->priv->store), iter, path);
            return;
        }
    }

    gtk_tree_store_append (GTK_TREE_STORE (ckstore->priv->store), iter, NULL);
    path = gtk_tree_model_get_path (GTK_TREE_MODEL (ckstore->priv->store), iter);
    ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (ckstore->priv->store), path);
    gtk_tree_path_free (path);

    g_hash_table_replace (ckstore->priv->rows, (gchar*)key, ref);
    gtk_tree_store_set (GTK_TREE_STORE (ckstore->priv->store), iter, CRYPTUI_KEY_STORE_KEY, key, -1);
}
Beispiel #24
0
void list_remove_selection(void)
{
	GList *rows = gtk_tree_selection_get_selected_rows(gui.treeselection,
		&gui.treemodel);

	for (GList *i = rows; i != NULL; i = i->next) {
		GtkTreePath *path = i->data;
		GtkTreeRowReference *ref = gtk_tree_row_reference_new(gui.treemodel,
			i->data);
		i->data = ref;
		gtk_tree_path_free(path);
	}

	for (GList *i = rows; i != NULL; i = i->next) {
		GtkTreeRowReference *ref = i->data;
		GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
		GtkTreeIter iter;

		if (gtk_tree_model_get_iter(gui.treemodel, &iter, path))
			gtk_list_store_remove(gui.liststore, &iter);

		gtk_tree_path_free(path);
		gtk_tree_row_reference_free(ref);
	}

	g_list_free(rows);

	if (list_count_rows() == 0) {
		gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbutton_clear), false);
		gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_treeview_clear), false);
		gtk_widget_set_sensitive(GTK_WIDGET(gui.button_hash), false);
	}
}
static inline GtkTreeRowReference *
do_add_root_symbol_to_view (SymbolDBViewLocals *dbvl, const GdkPixbuf *pixbuf, 
							const gchar* symbol_name, gint symbol_id)
{
	SymbolDBViewLocalsPriv *priv;
	GtkTreeStore *store;
	GtkTreeIter child_iter;
	GtkTreePath *path;
	GtkTreeRowReference *row_ref;
	
	g_return_val_if_fail (dbvl != NULL, NULL);
	
	priv = dbvl->priv;	
	
	store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)));

	if (store == NULL)
		return NULL;
	
	gtk_tree_store_append (store, &child_iter, NULL);			
	gtk_tree_store_set (store, &child_iter,
		COLUMN_PIXBUF, pixbuf,
		COLUMN_NAME, symbol_name,
		COLUMN_SYMBOL_ID, symbol_id,
		-1);	

	path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)),
                                          &child_iter);	
	row_ref = gtk_tree_row_reference_new (
						gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)), path);
	gtk_tree_path_free (path);
	
	return row_ref;
}
static void
remote_editor_tree_selection_get_branches (GtkTreeModel *model,
					   GtkTreePath  *path,
					   GtkTreeIter  *iter,
					   GList       **branches)
{
	*branches = g_list_prepend (*branches, gtk_tree_row_reference_new (model, path));
}
static gboolean foreach_all_files(GtkTreeModel *model, GtkTreePath *path, 
										GtkTreeIter *iter, gpointer userdata)
{
	GList **list = ((GList**)userdata);
	GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path);
	*list = g_list_append(*list, rowref);
	return FALSE;
}
Beispiel #28
0
/**
@brief create a tree row reference for @a iter in @a store

@param store pointer to treestore
@param iter pointer to treeiter to be referenced

@return the reference
*/
GtkTreeRowReference *e2_tree_iter_to_ref (GtkTreeStore *store, GtkTreeIter *iter)
{
	GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
	GtkTreeRowReference *ref = gtk_tree_row_reference_new
		(GTK_TREE_MODEL (store), path);
	gtk_tree_path_free (path);
	return ref;
}
Beispiel #29
0
/* Delete button was clicked on selection */
void _nojs_preferences_on_delete_selection(NoJSPreferences *self,
											GtkButton *inButton)
{
	NoJSPreferencesPrivate	*priv=self->priv;
	GList					*rows, *row, *refs=NULL;
	GtkTreeRowReference		*ref;
	GtkTreeModel			*model=GTK_TREE_MODEL(priv->listStore);
	GtkTreeIter				iter;
	GtkTreePath				*path;
	gchar					*domain;
	gchar					*sql;
	gint					success;
	gchar					*error;

	/* Get selected rows in list and create a row reference because
	 * we will modify the model while iterating through selected rows
	 */
	rows=gtk_tree_selection_get_selected_rows(priv->listSelection, &model);
	for(row=rows; row; row=row->next)
	{
		ref=gtk_tree_row_reference_new(model, (GtkTreePath*)row->data);
		refs=g_list_prepend(refs, ref);
	}
	g_list_foreach(rows,(GFunc)gtk_tree_path_free, NULL);
	g_list_free(rows);

	/* Delete each selected row by its reference */
	for(row=refs; row; row=row->next)
	{
		/* Get domain from selected row */
		path=gtk_tree_row_reference_get_path((GtkTreeRowReference*)row->data);
		gtk_tree_model_get_iter(model, &iter, path);
		gtk_tree_model_get(model, &iter, DOMAIN_COLUMN, &domain, -1);

		/* Delete domain from database */
		sql=sqlite3_mprintf("DELETE FROM policies WHERE site='%q';", domain);
		success=sqlite3_exec(priv->database,
								sql,
								NULL,
								NULL,
								&error);
		if(success!=SQLITE_OK || error)
		{
			if(error)
			{
				g_critical(_("Failed to execute database statement: %s"), error);
				sqlite3_free(error);
			}
				else g_critical(_("Failed to execute database statement: %s"), sqlite3_errmsg(priv->database));
		}
		sqlite3_free(sql);

		/* Delete row from model */
		gtk_list_store_remove(priv->listStore, &iter);
	}
	g_list_foreach(refs,(GFunc)gtk_tree_row_reference_free, NULL);
	g_list_free(refs);
}
Beispiel #30
0
void UzblTreeTab::RebuildTree()
{    
    int i = 0;
    for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) {
        UzblInstance* cuz = (UzblInstance*)l->data;
        cuz->SetNum(i);
        cuz->SetPNum(-1);
        cuz->ClearChildren();
        cuz->SetRowRef(NULL);
        i++;
    }
    for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) {
        UzblInstance* cuz = (UzblInstance*)l->data;
        if (cuz->GetParent() != NULL) {
            cuz->SetPNum(cuz->GetParent()->GetNum());
            cuz->GetParent()->AddChild(cuz);
        }
    }
    
    totaltabs = i;
    if (currenttab >= totaltabs)
        currenttab = totaltabs-1;
    if (currenttab < 0)
        currenttab = 0;
    
    gtk_tree_store_clear(tabmodel);
    
    for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) {
        UzblInstance* iuz = ((UzblInstance*)l->data);
        GtkTreeIter iter;
        if (iuz->GetParent() != NULL) {
            GtkTreeIter piter;
            GtkTreeRowReference* pr = iuz->GetParent()->GetRowRef();
            GtkTreePath* pp = gtk_tree_row_reference_get_path(pr);
            gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &piter, pp);
            gtk_tree_store_append(tabmodel, &iter, &piter);
        }
        else {
            gtk_tree_store_append(tabmodel, &iter, NULL);
        }
        
        GtkTreePath* p = gtk_tree_model_get_path(GTK_TREE_MODEL(tabmodel), &iter);
        GtkTreeRowReference* ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(tabmodel), p);
        iuz->SetRowRef(ref);
    }
    
    gtk_tree_view_expand_all(tabtree);
    
    GtkTreeIter siter;
    UzblInstance* suz = (UzblInstance*)g_list_nth(uzblinstances, currenttab)->data;
    GtkTreeRowReference* sr = suz->GetRowRef();
    GtkTreePath* sp = gtk_tree_row_reference_get_path(sr);
    gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &siter, sp);
    
    GtkTreeSelection* sel = gtk_tree_view_get_selection(tabtree);
    gtk_tree_selection_select_iter(sel, &siter);
}