Пример #1
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);
}
Пример #2
0
void
tabu_playlist_remove_selection (TabuPlaylist *playlist)
{
  GtkTreeModel *store;
  GtkTreeIter iter;
  GtkTreePath *path;
  GList *selected;
  GList *references = NULL;
  GtkTreeSelection *selection;
  
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (TABU_PLAYLIST (playlist)->tree_view));

  selected = gtk_tree_selection_get_selected_rows ( selection, &store );
  while (selected != NULL)
  {
    references = g_list_append ( references, gtk_tree_row_reference_new (store, selected->data));
    selected = g_list_next ( selected );
  }

  references = g_list_first (references);
  while (references != NULL)
  {
    path = gtk_tree_row_reference_get_path (references->data);

    if (tabu_backend_is_playing())
    {
      GtkTreePath *song_path = gtk_tree_row_reference_get_path (TABU_PLAYLIST (playlist)->reference);
  
      if (!strcmp(gtk_tree_path_to_string(path),gtk_tree_path_to_string(song_path)))
      {
        tabu_backend_stop();        
        TABU_PLAYLIST(playlist)->reference = NULL;
      }     
    }

    /* ok, now remove the song from the playlist */
    if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
    {
      gtk_list_store_remove (GTK_LIST_STORE (store), &iter );    
    }
    
    gtk_tree_path_free (path);    
    references = g_list_next ( references );
  }

  g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
  g_list_free (references);

  g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
  g_list_free (selected);
}
Пример #3
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);
	}
}
Пример #4
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;
}
Пример #5
0
void UzblTreeTab::GotoTab(int i)
{
    currenttab = i;
    
    if (currenttab < 0)
        currenttab = totaltabs -1;
    if (currenttab >= totaltabs)
        currenttab = 0;
    
    GtkTreeIter iter;
    UzblInstance* uz = (UzblInstance*)g_list_nth(uzblinstances, currenttab)->data;
    GtkTreeRowReference* r = uz->GetRowRef();
    GtkTreePath* p = gtk_tree_row_reference_get_path(r);
    gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &iter, p);
    
    int page = gtk_notebook_page_num(notebook, GTK_WIDGET(uz->GetSocket()));
    if (page == -1) {
        CloseTab(uz, false);
        return;
    }
    
    gtk_notebook_set_current_page(notebook, page);
    GtkTreeSelection* sel = gtk_tree_view_get_selection(tabtree);
    gtk_tree_selection_select_iter(sel, &iter);
}
Пример #6
0
static void
gtk_cell_view_set_cell_data (GtkCellView *cell_view)
{
  GtkTreeIter iter;
  GtkTreePath *path;

  g_return_if_fail (cell_view->priv->displayed_row != NULL);

  path = gtk_tree_row_reference_get_path (cell_view->priv->displayed_row);
  if (!path)
    return;

  gtk_tree_model_get_iter (cell_view->priv->model, &iter, path);
  gtk_tree_path_free (path);

  gtk_cell_area_apply_attributes (cell_view->priv->area, 
				  cell_view->priv->model, 
				  &iter, FALSE, FALSE);

  if (cell_view->priv->draw_sensitive)
    {
      GList *l, *cells = 
	gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (cell_view->priv->area));

      for (l = cells; l; l = l->next)
	{
	  GObject *renderer = l->data;

	  g_object_set (renderer, "sensitive", TRUE, NULL);
	}
      g_list_free (cells);
    }
}
Пример #7
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);
}
Пример #8
0
GList*
seahorse_object_model_get_rows_for_object (SeahorseObjectModel *self,
                                           GObject *object)
{
    SeahorseObjectModelPrivate *pv = SEAHORSE_OBJECT_MODEL_GET_PRIVATE (self);
    GList *rows = NULL;
    SeahorseObjectRow *skrow;
    GtkTreeIter *iter;
    GtkTreePath *path;
    guint i;
    
    g_return_val_if_fail (SEAHORSE_IS_OBJECT_MODEL (self), NULL);
    g_return_val_if_fail (G_IS_OBJECT (object), NULL);

    skrow = (SeahorseObjectRow*)g_hash_table_lookup (pv->rows, object);
    if (!skrow) 
        return NULL;
    
    for (i = 0; i < skrow->refs->len; i++) {
        
        path = gtk_tree_row_reference_get_path (g_ptr_array_index (skrow->refs, i));
        if (path) {
            iter = g_new0(GtkTreeIter, 1);
            gtk_tree_model_get_iter (GTK_TREE_MODEL (self), iter, path);
            rows = g_list_prepend (rows, iter);
            gtk_tree_path_free (path);
        }
    }
    
    return rows;
}
Пример #9
0
void ui_update_entry(struct playlist *playlist, struct playlist_entry *entry)
{
	struct playlist_ui_ctx *playlist_ctx = get_playlist_ui_ctx(playlist);
	struct entry_ui_ctx *ctx = get_entry_ui_ctx(entry);
	if (ctx->rowref == NULL)
		return;

	lock_ui();
	GtkTreePath *path = gtk_tree_row_reference_get_path(ctx->rowref);
	GtkTreeIter iter;
	gtk_tree_model_get_iter(GTK_TREE_MODEL(playlist_ctx->store), &iter, path);
	gtk_tree_path_free(path);

	char *name = get_display_name(get_entry_song(entry));
	char buf[32];
	unsigned int length = get_song_length(get_entry_song(entry));
	if (length == -1)
		strcpy(buf, "-");
	else
		sprintf(buf, "%d:%02d", length / (1000 * 60), (length / 1000) % 60);
	gtk_list_store_set(playlist_ctx->store, &iter,
		COL_NAME, name, COL_LENGTH, buf, -1);
	free(name);
	unlock_ui();
}
Пример #10
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);
}
Пример #11
0
static void
cookies_treeview_selection_changed_cb (GtkTreeSelection *selection,
                                       PdmDialog *dialog)
{
	GaleonDialog *d = GALEON_DIALOG(dialog);
	GtkTreeModel *model;
	GValue val = {0, };
	GtkTreeIter iter;
	GtkTreePath *path;
	CookieInfo *info;
	GList *l;
	GtkEntry *value_entry, *url_entry;
	GtkLabel *expires_label;
	GtkWidget *treeview = dialog->priv->cookies->treeview;
	gchar *url, *scheme;

	value_entry = GTK_ENTRY(galeon_dialog_get_control(d, PROP_COOKIES_VALUE_ENTRY));
	url_entry = GTK_ENTRY(galeon_dialog_get_control(d, PROP_COOKIES_URL_ENTRY));
	expires_label = GTK_LABEL(galeon_dialog_get_control(d, PROP_COOKIES_EXPIRES_LABEL));

	model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));

	l = gul_gui_treeview_get_selection_refs(GTK_TREE_VIEW(treeview));

	if (l == NULL || l->next != NULL)
	{
		gtk_entry_set_text(value_entry, "");
		gtk_entry_set_text(url_entry, "");
		gtk_label_set_text(expires_label, "");

		gul_gui_treeview_free_selection_refs(l);
		return;
	}

	path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)l->data);

	gul_gui_treeview_free_selection_refs(l);

	gtk_tree_model_get_iter(model, &iter, path);
	gtk_tree_path_free(path);

	gtk_tree_model_get_value 
		(model, &iter, COL_COOKIES_DATA, &val);
	info = (CookieInfo *)g_value_get_pointer (&val);

	if (info->secure)
		scheme = "https://";
	else
		scheme = "http://";

	if (info->domain[0] == '.')
		url = g_strconcat(scheme, "*", info->domain, info->path, NULL);
	else
		url = g_strconcat(scheme, info->domain, info->path, NULL);

	gtk_entry_set_text(value_entry, info->value);
	gtk_label_set_text(expires_label, info->expire);
	gtk_entry_set_text(url_entry, url);
	g_free(url);
}
Пример #12
0
void
dh_book_tree_show_uri (DhBookTree *tree, const gchar *uri)
{
#if 0
	GtkTreeSelection    *selection;
	GtkTreeRowReference *row;
	GtkTreePath         *path;

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));

	/* FIXME: Hmm .. */
	row = g_hash_table_lookup (tree->priv->node_rows, book_node);
	g_return_if_fail (row != NULL);

	path = gtk_tree_row_reference_get_path (row);
	g_return_if_fail (path != NULL);
	
	g_signal_handlers_block_by_func
		(selection, 
		 book_tree_selection_changed_cb,
		 tree);

	gtk_tree_selection_select_path (selection, path);
	gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), path, NULL, 0);	

	g_signal_handlers_unblock_by_func
		(selection, 
		 book_tree_selection_changed_cb,
		 tree);

	gtk_tree_path_free (path);
#endif
}
Пример #13
0
/**
 * glista_remindhandler_remind:
 * @reminder     The reminder to handle
 * @error        A pointer to fill with an error, if any
 * 
 * Remind the user about a task. 
 * 
 * Returns: TRUE on success, FALSE otherwise
 */
G_MODULE_EXPORT gboolean
glista_remindhandler_remind(GlistaReminder *reminder, 
                            GError **error)
{
    GtkWidget        *dialog;
    GtkWindow        *mainwindow;
    GtkTreeIter       iter;
    GtkTreePath      *path;
    gchar            *item_text;
    
    mainwindow = GTK_WINDOW(glista_get_widget("glista_main_window"));
    
    // Get the task as text
    // TODO: Concat the category ?
    path = gtk_tree_row_reference_get_path(reminder->item_ref);
    gtk_tree_model_get_iter(GL_ITEMSTM, &iter, path);
    gtk_tree_model_get(GL_ITEMSTM, &iter, GL_COLUMN_TEXT, &item_text, -1);
    
    dialog = gtk_message_dialog_new(mainwindow, 
                                    GTK_DIALOG_DESTROY_WITH_PARENT, 
                                    GTK_MESSAGE_INFO,
                                    GTK_BUTTONS_CLOSE,
                                    _("Glista Reminder"));
                                    
    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), 
                                             "%s", item_text);
    
    g_signal_connect_swapped(dialog, "response", 
                             G_CALLBACK(gtk_widget_destroy), dialog);

    gtk_widget_show(dialog);
    
    return TRUE;
}
Пример #14
0
static void
async_get_favicon_cb (GObject *source, GAsyncResult *result, gpointer user_data)
{
  GtkTreeIter iter;
  GtkTreePath *path;
  IconLoadData *data = (IconLoadData *) user_data;
  GdkPixbuf *favicon = webkit_favicon_database_get_favicon_pixbuf_finish (webkit_get_favicon_database (),
                                                                          result, NULL);

  if (favicon) {
    /* The completion model might have changed its contents */
    if (gtk_tree_row_reference_valid (data->row_reference)) {
      path = gtk_tree_row_reference_get_path (data->row_reference);
      gtk_tree_model_get_iter (GTK_TREE_MODEL (data->model), &iter, path);
      gtk_tree_path_free (path);
      gtk_list_store_set (data->model, &iter,
                          EPHY_HOSTS_STORE_COLUMN_FAVICON, favicon, -1);
    }
    g_object_unref (favicon);
  }

  g_object_unref (data->model);
  gtk_tree_row_reference_free (data->row_reference);
  g_slice_free (IconLoadData, data);
}
Пример #15
0
static void
drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx,
  GtkSelectionData *data, guint info, guint time,
  AccountsWindow *dialog)
{
  if (data->target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) {
    GtkTreeRowReference *ref;
    GtkTreePath *source_row;
    GtkTreeIter iter;
    PurpleAccount *account = NULL;
    GValue val = {0};

    ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row");
    source_row = gtk_tree_row_reference_get_path(ref);

    if (source_row == NULL) return; 

    gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, source_row);
    gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
      COLUMN_DATA, &val);

    dialog->drag_iter = iter;

    account = g_value_get_pointer(&val);

    gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE),
      8, (void *)&account, sizeof(account));

    gtk_tree_path_free(source_row);
  }
}
Пример #16
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);
}
Пример #17
0
static void
gimp_scale_combo_box_mru_remove_last (GimpScaleComboBox *combo_box)
{
  GtkTreeModel *model;
  GtkTreePath  *path;
  GList        *last;
  GtkTreeIter   iter;

  if (! combo_box->mru)
    return;

  model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));

  last = g_list_last (combo_box->mru);
  path = gtk_tree_row_reference_get_path (last->data);

  if (gtk_tree_model_get_iter (model, &iter, path))
    {
      gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
      gtk_tree_row_reference_free (last->data);
      combo_box->mru = g_list_delete_link (combo_box->mru, last);
    }

  gtk_tree_path_free (path);
}
Пример #18
0
static void free_service(struct Service *s) {
    GtkTreeIter iter;
    GtkTreePath *path;

    if (current_service == s) {
        current_service = NULL;

        if (service_resolver) {
            avahi_s_service_resolver_free(service_resolver);
            service_resolver = NULL;
        }

        gtk_label_set_text(info_label, "<i>Service removed</i>");
    }

    s->service_type->services = g_list_remove(s->service_type->services, s);

    if ((path = gtk_tree_row_reference_get_path(s->tree_ref))) {
        gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_store), &iter, path);
        gtk_tree_path_free(path);
    }

    gtk_tree_store_remove(tree_store, &iter);

    gtk_tree_row_reference_free(s->tree_ref);

    g_free(s->service_name);
    g_free(s->domain_name);
    g_free(s);
}
Пример #19
0
void
seahorse_object_model_remove_rows_for_object (SeahorseObjectModel *self,
                                              GObject *object)
{
    SeahorseObjectModelPrivate *pv = SEAHORSE_OBJECT_MODEL_GET_PRIVATE (self);
    SeahorseObjectRow *skrow;
    GtkTreeIter iter;
    GtkTreePath *path;
    guint i;
    
    g_return_if_fail (SEAHORSE_IS_OBJECT_MODEL (self));
    g_return_if_fail (G_IS_OBJECT (object));
    g_return_if_fail (pv->data_column >= 0);
    
    skrow = (SeahorseObjectRow*)g_hash_table_lookup (pv->rows, object);
    if (!skrow) 
        return;
    
    for (i = 0; i < skrow->refs->len; i++) {
        
        path = gtk_tree_row_reference_get_path (g_ptr_array_index (skrow->refs, i));
        if (path) {
            gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
            gtk_tree_store_remove (GTK_TREE_STORE (self), &iter);
            gtk_tree_path_free (path);
        }
    }
    
    /* We no longer have rows associated with this key, then remove */
    g_hash_table_remove (pv->rows, object);
}
Пример #20
0
/* the function will check for a NULL row_ref of its associated path. In that
 * case will return FALSE
 */
static inline gboolean
sdb_view_locals_get_iter_from_row_ref (SymbolDBViewLocals *dbvl, 
									   GtkTreeRowReference *row_ref, 
									   GtkTreeIter *OUT_iter)
{
	GtkTreePath *path;
	if (row_ref == NULL) 
	{
		/* no node displayed found */
		return FALSE;
	}
			
	path = gtk_tree_row_reference_get_path (row_ref);
	if (path == NULL) 
	{
		/*DEBUG_PRINT ("%s", "sdb_view_locals_get_iter_from_row_ref (): path is null, something "
					 "went wrong ?!");*/
		return FALSE;
	}
		
	if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)),
                             OUT_iter, path) == FALSE) 
	{
		gtk_tree_path_free (path);
		return FALSE;
	}
	gtk_tree_path_free (path);
	
	return TRUE;
}
Пример #21
0
static void
play_back_delete_inpfile (GtkTreeRowReference *reference)
{
        GtkTreeModel *model;
        GtkTreePath *path;
        GtkTreeIter iter;
        gboolean valid;
        gchar *inpfile;

        model = gtk_tree_row_reference_get_model (reference);

        path = gtk_tree_row_reference_get_path (reference);
        valid = gtk_tree_model_get_iter (model, &iter, path);
        gtk_tree_path_free (path);
        g_assert (valid);

        gtk_tree_model_get (
                model, &iter, GVA_GAME_STORE_COLUMN_INPFILE, &inpfile, -1);
        g_assert (inpfile != NULL);

        errno = 0;
        if (g_unlink (inpfile) == 0)
                gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
        else
                g_warning ("%s: %s", inpfile, g_strerror (errno));

        g_free (inpfile);
}
Пример #22
0
static void
attachment_button_update_cell_view (EAttachmentButton *button)
{
	GtkCellView *cell_view;
	EAttachment *attachment;
	GtkTreeRowReference *reference;
	GtkTreeModel *model = NULL;
	GtkTreePath *path = NULL;

	cell_view = GTK_CELL_VIEW (button->priv->cell_view);

	attachment = e_attachment_button_get_attachment (button);
	if (attachment == NULL)
		goto exit;

	reference = e_attachment_get_reference (attachment);
	if (reference == NULL)
		goto exit;

	model = gtk_tree_row_reference_get_model (reference);
	path = gtk_tree_row_reference_get_path (reference);

exit:

	gtk_cell_view_set_model (cell_view, model);
	if (model)
		gtk_cell_view_set_displayed_row (cell_view, path);

	if (path != NULL)
		gtk_tree_path_free (path);
}
Пример #23
0
static void
configure_combo_box_set_active (GtkComboBox *combo_box, const gchar *value)
{
	GtkTreeRowReference *reference;
	GHashTable *index;

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

	reference = g_hash_table_lookup (index, value);
	if (reference != NULL) {
		GtkTreeModel *model;
		GtkTreePath *path;
		GtkTreeIter iter;

		model = gtk_tree_row_reference_get_model (reference);
		path = gtk_tree_row_reference_get_path (reference);

		if (path == NULL)
			return;

		if (gtk_tree_model_get_iter (model, &iter, path))
			gtk_combo_box_set_active_iter (combo_box, &iter);

		gtk_tree_path_free (path);
	}
}
Пример #24
0
/**
 * glista_remindhandler_remind:
 * @reminder     The reminder to handle
 * @error        A pointer to fill with an error, if any
 * 
 * Remind the user about a task. The dummy reminder simply prints out a 
 * message to STDOUT.
 * 
 * Returns: TRUE on success, FALSE otherwise
 */
G_MODULE_EXPORT gboolean
glista_remindhandler_remind(GlistaReminder *reminder, 
                            GError **error)
{
	GtkTreePath *path;
	GtkTreeIter  iter;
	gchar       *item_text, *time_str;
	struct tm   *ltime;
	
	// Get reminder time into a string
	ltime = localtime(&(reminder->remind_at));
	time_str = g_malloc0(sizeof(gchar[72]));
	strftime(time_str, 70, "%x %H:%M", ltime);
	
	// Get the item name
	path = gtk_tree_row_reference_get_path(reminder->item_ref);
	gtk_tree_model_get_iter(GL_ITEMSTM, &iter, path);
	gtk_tree_model_get(GL_ITEMSTM, &iter, GL_COLUMN_TEXT, &item_text, -1);
	
	// Remind!
	g_print("It's %s - don't forget: %s\n", time_str, item_text);
	
	// Free used memory
	g_free(time_str);
	
	return TRUE;
}
Пример #25
0
static void nsgtk_download_store_update_item (struct gui_download_window *dl)
{
	gchar *info = nsgtk_download_info_to_string(dl);
	char *human = human_friendly_bytesize(dl->speed);
	char speed[strlen(human) + SLEN("/s") + 1];
	sprintf(speed, "%s/s", human);
	gchar *time = nsgtk_download_time_to_string(dl->time_remaining);
	gboolean pulse = dl->status == NSGTK_DOWNLOAD_WORKING;

	/* Updates iter (which is needed to set and get data) with the dl row */
	gtk_tree_model_get_iter(GTK_TREE_MODEL(nsgtk_download_store),
				&nsgtk_download_iter,
				gtk_tree_row_reference_get_path(dl->row));

	gtk_list_store_set(nsgtk_download_store, &nsgtk_download_iter,
			   NSGTK_DOWNLOAD_PULSE, pulse ? dl->progress : -1,
			   NSGTK_DOWNLOAD_PROGRESS, pulse ? 0 : dl->progress,
			   NSGTK_DOWNLOAD_INFO, info,
			   NSGTK_DOWNLOAD_SPEED, dl->speed == 0 ? "-" : speed,
			   NSGTK_DOWNLOAD_REMAINING, time,
			   NSGTK_DOWNLOAD, dl,
			   -1);

	g_free(info);
	g_free(time);
}
Пример #26
0
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;
}
Пример #27
0
/*
 * env tree view value editing cancelled (Escape pressed)
 */
static void on_value_editing_cancelled(GtkCellRenderer *renderer, gpointer user_data)
{
	/* check whether escape was pressed when editing
	new variable value cell */
	GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row);
	if(!gtk_tree_path_compare(being_edited_value, empty_path))
	{
		/* if so - clear name sell */
		GtkTreeIter iter;
		gtk_tree_model_get_iter(model, &iter, being_edited_value);
		
		gtk_list_store_set (
			store,
			&iter,
			NAME, "",
		   -1);

		entering_new_var = FALSE;
	}

	g_object_set (renderer_value, "editable", FALSE, NULL);

	gtk_tree_path_free(being_edited_value);
	gtk_tree_path_free(empty_path);
}
static void on_item_changed (MateBG *bg, AppearanceData *data) {
  GtkTreeModel *model;
  GtkTreeIter iter;
  GtkTreePath *path;
  MateWPItem *item;

  item = g_hash_table_find (data->wp_hash, predicate, bg);

  if (!item)
    return;

  model = gtk_tree_row_reference_get_model (item->rowref);
  path = gtk_tree_row_reference_get_path (item->rowref);

  if (gtk_tree_model_get_iter (model, &iter, path)) {
    GdkPixbuf *pixbuf;

    g_signal_handlers_block_by_func (bg, G_CALLBACK (on_item_changed), data);

    pixbuf = mate_wp_item_get_thumbnail (item,
                                          data->thumb_factory,
                                          data->thumb_width,
                                          data->thumb_height);
    if (pixbuf) {
      gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
      g_object_unref (pixbuf);
    }

    g_signal_handlers_unblock_by_func (bg, G_CALLBACK (on_item_changed), data);
  }
}
Пример #29
0
static void
each_url_get_data_binder (GaleonDragEachSelectedItemDataGet iteratee, 
                          gpointer iterator_context, gpointer data)
{
	GtkTreeView *treeview = HISTORY_DIALOG(iterator_context)->priv->treeview;
	GtkTreeModel *model = HISTORY_DIALOG(iterator_context)->priv->model;
	GList *refs, *l;
	
	refs = gul_gui_treeview_get_selection_refs (treeview);	
	
	for (l = refs; l != NULL; l = l->next)
	{
        	char *url, *title;
		GtkTreeIter iter;
                GtkTreePath *path;

                path = gtk_tree_row_reference_get_path 
                        ((GtkTreeRowReference *)l->data); 
                gtk_tree_model_get_iter 
                        (model, &iter, path);

		gtk_tree_model_get (model, &iter, 
				    0, &title,
				    1, &url,
				    -1);

		iteratee (url, title, -1, -1, -1, -1, data);

		g_free (url);
		g_free (title);
	}

	gul_gui_treeview_free_selection_refs (refs);
}
Пример #30
0
static void
key_row_free (SeahorseObjectRow *skrow)
{
    SeahorseObjectModel *self = skrow->self;
    GtkTreeRowReference *ref;
    GtkTreePath *path;
    GtkTreeIter iter;
    guint i;

    g_return_if_fail (self->data_column != -1);

    for (i = 0; i < skrow->refs->len; i++) {

        ref = (GtkTreeRowReference*)g_ptr_array_index (skrow->refs, i);
        if (ref) {
            path = gtk_tree_row_reference_get_path (ref);
            if (path) {
                gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
                gtk_tree_store_set (GTK_TREE_STORE (self), &iter,
                                    self->data_column, NULL, -1);
                gtk_tree_path_free (path);
            }
            gtk_tree_row_reference_free (ref);
        }

    }

    if (skrow->binding)
        seahorse_bind_disconnect (skrow->binding);
    if (skrow->object)
        g_object_weak_unref (G_OBJECT (skrow->object), key_destroyed, skrow->self);

    g_ptr_array_free (skrow->refs, TRUE);
    g_free (skrow);
}