Example #1
0
static void
thunar_uca_chooser_up_clicked (ThunarUcaChooser *uca_chooser)
{
  GtkTreeSelection *selection;
  GtkTreeModel     *model;
  GtkTreePath      *path;
  GtkTreeIter       iter_a;
  GtkTreeIter       iter_b;

  g_return_if_fail (THUNAR_UCA_IS_CHOOSER (uca_chooser));

  /* determine the currently selected item */
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview));
  if (gtk_tree_selection_get_selected (selection, &model, &iter_a))
    {
      /* determine the tree path to the iter */
      path = gtk_tree_model_get_path (model, &iter_a);
      if (gtk_tree_path_prev (path))
        {
          /* determine the iter for the previous item */
          gtk_tree_model_get_iter (model, &iter_b, path);

          /* perform the exchange operation */
          thunar_uca_chooser_exchange (uca_chooser, selection, model, &iter_a, &iter_b);
        }

      /* release the path */
      gtk_tree_path_free (path);
    }
}
Example #2
0
static void
epif_remove_header_clicked (GtkButton *button, EPImapFeaturesData *ui)
{
	GtkTreeSelection *select;
	GtkTreeModel *model;
	GtkTreeIter iter, first;
	GtkTreePath *path;
	gboolean valid = TRUE;

	select = gtk_tree_view_get_selection (ui->custom_headers_tree);

	if (gtk_tree_selection_get_selected (select, &model, &iter))
	{
		path = gtk_tree_model_get_path (model, &iter);
		gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);

		if (gtk_tree_path_prev (path)) {
			gtk_tree_model_get_iter (model, &iter, path);
		} else {
			valid = gtk_tree_model_get_iter_first (model, &iter);
		}

		if (valid)
			gtk_tree_selection_select_iter (select, &iter);
	}

	if (gtk_tree_model_get_iter_first (model, &first)==FALSE)
		gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE);

	epif_add_sensitivity (ui);
}
static void
move_up_clicked_callback (GtkWidget *button, gpointer user_data)
{
	NautilusColumnChooser *chooser;
	GtkTreeIter iter;
	GtkTreeSelection *selection;

	chooser = NAUTILUS_COLUMN_CHOOSER (user_data);
	
	selection = gtk_tree_view_get_selection (chooser->details->view);
	
	if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
		GtkTreePath *path;
		GtkTreeIter prev;

		path = gtk_tree_model_get_path (GTK_TREE_MODEL (chooser->details->store), &iter);
		gtk_tree_path_prev (path);
		if (gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store), &prev, path)) {
			gtk_list_store_move_before (chooser->details->store,
						   &iter,
						   &prev);
		}
		gtk_tree_path_free (path);
	}

	list_changed (chooser);
}
Example #4
0
static void
sequence_prev (void)
{
  GtkTreeIter       iter;
  GtkTreePath      *path;
  GtkTreeSelection *selection;

  selection = gtk_tree_view_get_selection (sequence_view);

  if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
    return;

  path = gtk_tree_model_get_path (GTK_TREE_MODEL (sequence_store), &iter);

  if (!gtk_tree_path_prev (path))
    return;

  if (sequence_source_id > 0)
    {
      current_step->progress = 0;
      gtk_tree_model_get (GTK_TREE_MODEL (sequence_store), &iter,
                          COLUMN_DATA, &current_step,
                          -1);
      current_step->progress = 0;
    }
  
  gtk_tree_selection_select_path (selection, path);
  sequence_scroll_to_selected ();
}
void
on_btn_up_clicked (GtkButton *button, gpointer user_data)
{
	GtkTreeModel *treemodel;
	GtkTreeIter iter, previous;	
	GtkTreeSelection *sel;
	GtkTreePath *path;
	gint i, *indice;
	GList *launcher;
	
	sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(_dlg->treeview1) );
	if ( gtk_tree_selection_get_selected(sel, &treemodel, &iter) )
	{
		path = gtk_tree_model_get_path(treemodel, &iter);
		if ( gtk_tree_path_prev(path) )
		{
			if (gtk_tree_model_get_iter(treemodel, &previous, path))
				gtk_list_store_swap(GTK_LIST_STORE(treemodel), &iter, &previous);
			indice = gtk_tree_path_get_indices(path);
			launcher = g_list_nth(_quicklauncher->launchers,  indice[0]+1);
			_quicklauncher->launchers = g_list_remove_link(_quicklauncher->launchers, launcher);
			_quicklauncher->launchers = g_list_insert(_quicklauncher->launchers, launcher->data, indice[0]);
			quicklauncher_empty_widgets();
			quicklauncher_organize();
			g_list_free(launcher);
		}
		gtk_tree_path_free(path);
	}
}
Example #6
0
void
dat_moveup_templ_cb(GtkButton *button, gpointer user_data)
{
    GncABTransDialog *td = user_data;
    GtkTreeSelection *selection;
    GtkTreeModel *model;
    GtkTreeIter iter;
    GtkTreePath *prev_path;
    GtkTreeIter prev_iter;

    g_return_if_fail(td);

    selection = gtk_tree_view_get_selection(td->template_gtktreeview);
    if (!gtk_tree_selection_get_selected(selection, &model, &iter))
        return;

    prev_path = gtk_tree_model_get_path(model, &iter);
    if (gtk_tree_path_prev(prev_path))
    {
        if (gtk_tree_model_get_iter(model, &prev_iter, prev_path))
        {
            gtk_list_store_move_before(GTK_LIST_STORE(model), &iter, &prev_iter);
            td->templ_changed = TRUE;
        }
    }
    gtk_tree_path_free(prev_path);
}
Example #7
0
File: iopen.c Project: szfn/teddy
static bool iopen_other_keys(editor_t *editor, bool shift, bool ctrl, bool alt, bool super, guint keyval) {
	if (!shift && !ctrl && !alt && !super) {
		GtkTreePath *path;

		switch (keyval) {
		case GDK_KEY_Up:
			gtk_tree_view_get_cursor(GTK_TREE_VIEW(results_tree), &path, NULL);
			if (path == NULL) {
				path = gtk_tree_path_new_first();
			} else {
				gtk_tree_path_prev(path);
			}
			gtk_tree_view_set_cursor(GTK_TREE_VIEW(results_tree), path, NULL, FALSE);
			gtk_tree_path_free(path);
			return true;
		case GDK_KEY_Down:
			gtk_tree_view_get_cursor(GTK_TREE_VIEW(results_tree), &path, NULL);
			if (path == NULL) {
				path = gtk_tree_path_new_first();
			} else {
				gtk_tree_path_next(path);
			}
			gtk_tree_view_set_cursor(GTK_TREE_VIEW(results_tree), path, NULL, FALSE);
			gtk_tree_path_free(path);
			return true;
		}
	}
	return false;
}
/**
* Try to select the bookmark before the current one.
* If none is selected the last in the list is picked.
* Wraps around.
*/
void
AP_UnixDialog_Goto::_selectPrevBookmark () 
{
	UT_DEBUGMSG (("ROB: AP_UnixDialog_Goto::_selectPrevBookmark ()\n"));
	GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvBookmarks));
	UT_return_if_fail (model != NULL);

	GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvBookmarks));
	GtkTreeIter iter;

	// try to select prev
	gboolean haveSelected = gtk_tree_selection_get_selected (selection, &model, &iter);
	if (haveSelected) {
		GtkTreePath *path = gtk_tree_model_get_path (model, &iter);
		gtk_tree_path_prev (path);
		gboolean havePrev = gtk_tree_model_get_iter (model, &iter, path);
		if (havePrev) {
			gtk_tree_selection_select_path (selection, path);
			gtk_tree_path_free (path);
			return;
		}
		gtk_tree_path_free (path);
	}

	// select last
	UT_uint32 idx = getExistingBookmarksCount () - 1;
	GtkTreePath *path = gtk_tree_path_new_from_indices (idx);
	gtk_tree_selection_select_path (selection, path);
	UT_DEBUGMSG (("ROB: AP_UnixDialog_Goto::_selectPrevBookmark () select last '%d'\n", 
					gtk_tree_model_get_iter (model, &iter, path)));
	gtk_tree_path_free (path);
}
Example #9
0
/****************************************************************
  Move item up in worklist
*****************************************************************/
static void queue_bubble_up(struct worklist_data *ptr)
{
  GtkTreePath *path;
  GtkTreeViewColumn *col;
  GtkTreeModel *model;

  if (!gtk_widget_is_sensitive(ptr->dst_view)) {
    return;
  }

  model = GTK_TREE_MODEL(ptr->dst);
  gtk_tree_view_get_cursor(GTK_TREE_VIEW(ptr->dst_view), &path, &col);
  if (path) {
    GtkTreeIter it, it_prev;

    if (gtk_tree_path_prev(path)) {
      gtk_tree_model_get_iter(model, &it_prev, path);
      it = it_prev;
      gtk_tree_model_iter_next(model, &it);

      gtk_list_store_swap(GTK_LIST_STORE(model), &it, &it_prev);

      gtk_tree_view_set_cursor(GTK_TREE_VIEW(ptr->dst_view), path, col, FALSE);
      commit_worklist(ptr);
    }
  }
  gtk_tree_path_free(path);
}
Example #10
0
void
list_store_remove_selected_cb(GtkWidget *w, gpointer client_data)
{
  GtkTreeSelection *sel;
  GList *selected, *data;
  GtkTreeModel *model;
  gboolean found;
  GtkTreeIter iter;
  GtkTreePath *first_path = NULL;

  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(client_data));
  selected = gtk_tree_selection_get_selected_rows(sel, &model);

  if (selected == NULL)
    return;

  for (data = g_list_last(selected); data; data = data->prev) {
    found = gtk_tree_model_get_iter(model, &iter, data->data);
    if (found) {
      gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
    }

    first_path = data->data;
  }

  if (first_path) {
    if (! gtk_tree_model_get_iter(model, &iter, first_path)) {
      gtk_tree_path_prev(first_path);
    }
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(client_data), first_path, NULL, FALSE);
  }

  g_list_foreach(selected, free_tree_path_cb, NULL);
  g_list_free(selected);
}
Example #11
0
static void
clue_check_isempty (GtkTreeModel *model,
                    GtkTreePath *path,
                    GtkTreeIter *iter,
                    UIData *ui)
{
	GtkTreeSelection *selection;
	gchar *keyword = NULL;
	gboolean valid;

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview));
	/* move to the previous node */
	valid = gtk_tree_path_prev (path);

	gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1);
	if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0))
		gtk_list_store_remove (ui->store, iter);

	/* Check if we have a valid row to select. If not, then select
	 * the previous row */
	if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter)) {
		gtk_tree_selection_select_iter (selection, iter);
	} else {
		if (path && valid) {
			gtk_tree_model_get_iter (model, iter, path);
			gtk_tree_selection_select_iter (selection, iter);
		}
	}

	gtk_widget_grab_focus (ui->treeview);
	g_free (keyword);
}
static void
remove_selected_input (GtkButton *button, gpointer data)
{
  GtkBuilder *builder = data;
  GtkTreeModel *model;
  GtkTreeIter iter;
  GtkTreePath *path;

  g_debug ("remove selected input source");

  if (get_selected_iter (builder, &model, &iter) == FALSE)
    return;

  path = gtk_tree_model_get_path (model, &iter);

  gtk_list_store_remove (GTK_LIST_STORE (model), &iter);

  if (!gtk_tree_model_get_iter (model, &iter, path))
    gtk_tree_path_prev (path);

  set_selected_path (builder, path);

  gtk_tree_path_free (path);

  update_button_sensitivity (builder);
  update_configuration (model);
}
static void
dict_list_up_clicked_cb (GtkButton *button,
                         gpointer userdata)
{
    GtkTreeView *view = GTK_TREE_VIEW(userdata);
    GtkTreeModel *model = gtk_tree_view_get_model(view);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
        GtkTreePath *path;
        GtkTreeIter prev_iter;
        int i;
        path = gtk_tree_model_get_path(model, &iter);
        i = gtk_tree_path_get_indices(path)[0];
        if (i != 0) {
            vector<String>::iterator it  = __config_sysdicts.begin() + i;
            vector<String>::iterator it2 = it - 1;
            iter_swap(it, it2);
            __have_changed = true;
        }
        if (gtk_tree_path_prev(path) &&
            gtk_tree_model_get_iter(model, &prev_iter, path)) {
            gtk_list_store_move_before(GTK_LIST_STORE(model),
                                       &iter, &prev_iter);
        }
        gtk_tree_path_free(path);
    }
}
Example #14
0
static void delete_log_cb(gpointer *data)
{
	if (!purple_log_delete((PurpleLog *)data[2]))
	{
		purple_notify_error(NULL, NULL, _("Log Deletion Failed"),
		                  _("Check permissions and try again."));
	}
	else
	{
		GtkTreeStore *treestore = data[0];
		GtkTreeIter *iter = (GtkTreeIter *)data[1];
		GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(treestore), iter);
		gboolean first = !gtk_tree_path_prev(path);

#if GTK_CHECK_VERSION(2,2,0)
		if (!gtk_tree_store_remove(treestore, iter) && first)
		{
			/* iter was the last child at its level */

			if (gtk_tree_path_up(path))
			{
				gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), iter, path);
				gtk_tree_store_remove(treestore, iter);
			}
		}
#else
		gtk_tree_store_remove(treestore, iter);
#endif
		gtk_tree_path_free(path);
	}

	delete_log_cleanup_cb(data);
}
static void
gdvd_button_delete_callback(GtkWidget *widget, GalDefineViewsDialog *dialog)
{
	int row;
	GtkTreeIter iter;
	GtkTreePath *path;
	GtkTreeSelection *selection;
	GalViewCollectionItem *item;

	selection = gtk_tree_view_get_selection (dialog->treeview);

	if (gtk_tree_selection_get_selected (selection,
					 &dialog->model,
					 &iter)) {
		gtk_tree_model_get (dialog->model, &iter, COL_GALVIEW_DATA, &item, -1);

		for (row=0; row<dialog->collection->view_count; row++) {
			if (item == dialog->collection->view_data[row]) {
				gal_view_collection_delete_view (dialog->collection, row);
				path = gtk_tree_model_get_path (dialog->model, &iter);
				gtk_list_store_remove (GTK_LIST_STORE (dialog->model), &iter);

				if (gtk_tree_path_prev (path)) {
					gtk_tree_model_get_iter (dialog->model, &iter, path);
			 	} else {
					gtk_tree_model_get_iter_first (dialog->model, &iter);
				}

				gtk_tree_selection_select_iter (selection, &iter);
				break;
			}
		}
	}
}
Example #16
0
static void
move_row (chan *ch, int delta, GtkTreeIter *parent)
{
	GtkTreeStore *store = ch->cv->store;
	GtkTreeIter *src = &ch->iter;
	GtkTreeIter dest = ch->iter;
	GtkTreePath *dest_path;

	if (delta < 0) /* down */
	{
		if (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &dest))
			gtk_tree_store_swap (store, src, &dest);
		else	/* move to top */
			gtk_tree_store_move_after (store, src, NULL);

	} else
	{
		dest_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &dest);
		if (gtk_tree_path_prev (dest_path))
		{
			gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &dest, dest_path);
			gtk_tree_store_swap (store, src, &dest);
		} else
		{	/* move to bottom */
			gtk_tree_store_move_before (store, src, NULL);
		}

		gtk_tree_path_free (dest_path);
	}
}
Example #17
0
static void prefs_dialog_sensor_up_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
        GtkTreeModel *model;
        GtkTreeIter iter;
        GtkTreePath *path;

        if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {
                /* if has no prev node set up button insentive */
                path = gtk_tree_model_get_path(model, &iter);
                if (gtk_tree_path_prev(path)) {
                        GtkTreeIter prev_iter;
                        /* check is a valid node in out model */
                        if (gtk_tree_model_get_iter(model, &prev_iter, path)) {
                                gtk_tree_store_move_before(GTK_TREE_STORE(model),
                                                           &iter,
                                                           &prev_iter);
                                g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,
                                                      "changed");

                                sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);


                        }
                }

                gtk_tree_path_free(path);

        }
}
Example #18
0
static void prefs_custom_header_up(void)
{
	GtkTreePath *prev, *sel;
	GtkTreeIter isel;
	GtkListStore *store = NULL;
	GtkTreeModel *model = NULL;
	GtkTreeIter iprev;
	
	if (!gtk_tree_selection_get_selected
		(gtk_tree_view_get_selection
			(GTK_TREE_VIEW(customhdr.list_view)),
		 &model,
		 &isel))
		return;
	store = (GtkListStore *)model;
	sel = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &isel);
	if (!sel)
		return;
	
	/* no move if we're at row 0... */
	prev = gtk_tree_path_copy(sel);
	if (!gtk_tree_path_prev(prev)) {
		gtk_tree_path_free(prev);
		gtk_tree_path_free(sel);
		return;
	}

	gtk_tree_model_get_iter(GTK_TREE_MODEL(store),
				&iprev, prev);
	gtk_tree_path_free(sel);
	gtk_tree_path_free(prev);

	gtk_list_store_swap(store, &iprev, &isel);
	prefs_custom_header_set_list(cur_ac);
}
Example #19
0
/*
 * Shift entry up
 */
gboolean shift_entry_up()
{
	GtkTreePath *entry_path = NULL;
	GtkTreeView *entry_view = NULL;
	GtkTreeModel *entry_model = NULL;
	GtkTreeSelection *entry_selection = NULL;
	GtkTreeViewColumn *entry_column = NULL;
	GtkTreeIter entry_iter;
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	guint entry_index = 0;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();

	// Get entry model and view
	entry_view = get_entry_view(book);
	entry_model = gtk_tree_view_get_model(entry_view);

	sn_trace0("Shifting entry up.");

	// Make sure we are not at the top
	gtk_tree_view_get_cursor
		(entry_view, &entry_path, &entry_column);
	if(entry_path != NULL) {
		if(gtk_tree_path_prev(entry_path)) {

			// Get the entry to move up
			entry_selection = gtk_tree_view_get_selection(entry_view);
			if(gtk_tree_selection_get_selected
				(entry_selection, &entry_model, &entry_iter)) {
				gtk_tree_model_get(entry_model, &entry_iter,
					ENTRY_ITEM, &entry, END_OF_LIST);

				// Move entry up
				if(entry != NULL) {
					entry_index = g_list_index(section->entry_list, entry);
					section->entry_list = g_list_remove(section->entry_list, entry);
					section->entry_list = g_list_insert
						(section->entry_list, entry, --entry_index);

					// Write book
					write_book(book, note_dir);
				}
			}
			// Populate entries
			populate_entries(book, section);
			gtk_tree_view_set_cursor
				(entry_view, entry_path, entry_column, FALSE);
		}
	gtk_tree_path_free(entry_path);
	}

	return TRUE;
} // Shift entry up
Example #20
0
/**
 * Advance selection to previous/next item in list.
 * \param list_view List to process.
 * \param forward Set to <i>TRUE</i> to select next or <i>FALSE</i> for
 *                previous entry.
 */
static void completion_window_advance_selection(GtkTreeView *list_view, gboolean forward)
{
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GtkTreeModel *model;

	cm_return_if_fail(list_view != NULL);

	selection = gtk_tree_view_get_selection(list_view);
	if (!gtk_tree_selection_get_selected(selection, &model, &iter))
		return;

	if (forward) { 
		forward = gtk_tree_model_iter_next(model, &iter);
		if (forward) 
			gtk_tree_selection_select_iter(selection, &iter);
	} else {
		GtkTreePath *prev;

		prev = gtk_tree_model_get_path(model, &iter);
		if (!prev) 
			return;

		if (gtk_tree_path_prev(prev))
			gtk_tree_selection_select_path(selection, prev);
		
		gtk_tree_path_free(prev);
	}
}
Example #21
0
/* Remove an item from the page's current list.
 */
static void
tp_page_remove_selected(ToolbarPage * page)
{
    GtkTreeSelection *selection =
        gtk_tree_view_get_selection(GTK_TREE_VIEW(page->current));
    GtkTreeModel *model;
    GtkTreeIter iter;
    GtkTreePath *path;

    if (!gtk_tree_selection_get_selected(selection, &model, &iter))
        return;
    path = gtk_tree_model_get_path(model, &iter);

    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);

    if (gtk_tree_model_get_iter(model, &iter, path)
        || gtk_tree_path_prev(path)) {
        gtk_tree_selection_select_path(selection, path);
        gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(page->current),
                                     path, NULL, FALSE, 0, 0);
    }
    gtk_tree_path_free(path);

    gtk_widget_set_sensitive(page->standard_button, TRUE);
    tp_page_refresh_preview(page);
#ifndef BALSA_TOOLBAR_DEBUG_ACTIONS
    tp_page_refresh_available(page);
#else /* BALSA_TOOLBAR_DEBUG_ACTIONS */
    tp_page_refresh_available(page, NULL);
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
    balsa_toolbar_model_changed(page->model);
}
Example #22
0
static void
gimp_path_editor_move_clicked (GtkWidget      *widget,
                               GimpPathEditor *editor)
{
  GtkTreePath  *path;
  GtkTreeModel *model;
  GtkTreeIter   iter1, iter2;
  gchar        *utf81, *utf82;
  gchar        *dir1, *dir2;
  gboolean      writable1, writable2;

  if (editor->sel_path == NULL)
    return;

  path = gtk_tree_path_copy (editor->sel_path);

  if (widget == editor->up_button)
    gtk_tree_path_prev (path);
  else
    gtk_tree_path_next (path);

  model = GTK_TREE_MODEL (editor->dir_list);

  gtk_tree_model_get_iter (model, &iter1, editor->sel_path);
  gtk_tree_model_get_iter (model, &iter2, path);

  gtk_tree_model_get (model, &iter1,
                      COLUMN_UTF8,      &utf81,
                      COLUMN_DIRECTORY, &dir1,
                      COLUMN_WRITABLE,  &writable1,
                      -1);
  gtk_tree_model_get (model, &iter2,
                      COLUMN_UTF8,      &utf82,
                      COLUMN_DIRECTORY, &dir2,
                      COLUMN_WRITABLE,  &writable2,
                      -1);

  gtk_list_store_set (editor->dir_list, &iter1,
                      COLUMN_UTF8,      utf82,
                      COLUMN_DIRECTORY, dir2,
                      COLUMN_WRITABLE,  writable2,
                      -1);
  gtk_list_store_set (editor->dir_list, &iter2,
                      COLUMN_UTF8,      utf81,
                      COLUMN_DIRECTORY, dir1,
                      COLUMN_WRITABLE,  writable1,
                      -1);

  g_free (utf81);
  g_free (utf82);

  g_free (dir2);
  g_free (dir1);

  gtk_tree_selection_select_iter (editor->sel, &iter2);

  g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0);
}
Example #23
0
static void
tree_view_move_focus (GtkTreeView    *view,
                      GtkMovementStep step,
                      gint            amount)
{
  GtkTreeIter   iter;
  GtkTreePath  *path;
  GtkTreeModel *model = gtk_tree_view_get_model (view);
  gboolean      valid = FALSE;
  
  gtk_tree_view_get_cursor (view, &path, NULL);
  if (! path) {
    valid = gtk_tree_model_get_iter_first (model, &iter);
  } else {
    switch (step) {
      case GTK_MOVEMENT_BUFFER_ENDS:
        valid = gtk_tree_model_get_iter_first (model, &iter);
        if (valid && amount > 0) {
          GtkTreeIter prev;
          
          do {
            prev = iter;
          } while (gtk_tree_model_iter_next (model, &iter));
          iter = prev;
        }
        break;
      
      case GTK_MOVEMENT_PAGES:
        /* FIXME: move by page */
      case GTK_MOVEMENT_DISPLAY_LINES:
        gtk_tree_model_get_iter (model, &iter, path);
        if (amount > 0) {
          while ((valid = gtk_tree_model_iter_next (model, &iter)) &&
                 --amount > 0)
            ;
        } else if (amount < 0) {
          while ((valid = gtk_tree_path_prev (path)) && --amount > 0)
            ;
          
          if (valid) {
            gtk_tree_model_get_iter (model, &iter, path);
          }
        }
        break;
      
      default:
        g_assert_not_reached ();
    }
    gtk_tree_path_free (path);
  }
  
  if (valid) {
    tree_view_set_cursor_from_iter (view, &iter);
  } else {
    gtk_widget_error_bell (GTK_WIDGET (view));
  }
}
Example #24
0
static void
gimp_path_editor_delete_clicked (GtkWidget      *widget,
                                 GimpPathEditor *editor)
{
  GtkTreeIter iter;
  gboolean    dir_writable;

  if (editor->sel_path == NULL)
    return;

  gtk_tree_model_get_iter (GTK_TREE_MODEL (editor->dir_list), &iter,
                           editor->sel_path);

  gtk_tree_model_get (GTK_TREE_MODEL (editor->dir_list), &iter,
                      COLUMN_WRITABLE, &dir_writable,
                      -1);

  gtk_list_store_remove (editor->dir_list, &iter);

  editor->num_items--;

  if (editor->num_items == 0)
    {
      gtk_tree_path_free (editor->sel_path);
      editor->sel_path = NULL;

      g_signal_handlers_block_by_func (editor->file_entry,
                                       gimp_path_editor_file_entry_changed,
                                       editor);

      gimp_file_entry_set_filename (GIMP_FILE_ENTRY (editor->file_entry), "");

      g_signal_handlers_unblock_by_func (editor->file_entry,
                                         gimp_path_editor_file_entry_changed,
                                         editor);

      gtk_widget_set_sensitive (editor->delete_button, FALSE);
      gtk_widget_set_sensitive (editor->up_button,     FALSE);
      gtk_widget_set_sensitive (editor->down_button,   FALSE);
      gtk_widget_set_sensitive (editor->file_entry,    FALSE);
    }
  else
    {
      gint *indices;

      indices = gtk_tree_path_get_indices (editor->sel_path);
      if ((indices[0] == editor->num_items) && (indices[0] > 0))
        gtk_tree_path_prev (editor->sel_path);

      gtk_tree_selection_select_path (editor->sel, editor->sel_path);
    }

  g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0);

  if (dir_writable)
    g_signal_emit (editor, gimp_path_editor_signals[WRITABLE_CHANGED], 0);
}
Example #25
0
/* Test whether the iter addresses the first row.
 */
static gboolean
tp_list_iter_is_first(GtkWidget * list, GtkTreeIter * iter)
{
    GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(list));
    GtkTreePath *path = gtk_tree_model_get_path(model, iter);
    gboolean ret_val = !gtk_tree_path_prev(path);
    gtk_tree_path_free(path);
    return ret_val;
}
/**
 * Move account in list depending on direction and selected account
 */
static void
account_move(gboolean move_up, gpointer data)
{
    // Get view, model and selection of account
    GtkTreeView *tree_view = GTK_TREE_VIEW(data);
    GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);

    // Find selected iteration and create a copy
    GtkTreeIter iter;
    gtk_tree_selection_get_selected(selection, &model, &iter);
    GtkTreeIter *iter_copy;
    iter_copy = gtk_tree_iter_copy(&iter);

    // Find path of iteration
    gchar *path = gtk_tree_model_get_string_from_iter(model, &iter);

    // The first real account in the list can't move up because of the IP2IP account
    // It can still move down though
    if (g_strcmp0(path, "1") == 0 && move_up)
        return;

    GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
    gint *indices = gtk_tree_path_get_indices(tree_path);
    const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */

    // Depending on button direction get new path
    if (move_up)
        gtk_tree_path_prev(tree_path);
    else
        gtk_tree_path_next(tree_path);

    gtk_tree_model_get_iter(model, &iter, tree_path);

    // Swap iterations if valid
    if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter))
        gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy);

    // Scroll to new position
    gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0);

    // Free resources
    gtk_tree_path_free(tree_path);
    gtk_tree_iter_free(iter_copy);
    g_free(path);

    // Perpetuate changes in account queue
    if (move_up)
        account_list_move_up(pos);
    else
        account_list_move_down(pos);

    // Set the order in the configuration file
    gchar *ordered_account_list = account_list_get_ordered_list();
    dbus_set_accounts_order(ordered_account_list);
    g_free(ordered_account_list);
}
Example #27
0
/**
@brief delete selected row(s), if any, from @a treeview

@param treeview where the action is to occur

@return
*/
void e2_tree_delete (GtkTreeView *treeview)
{
	GtkTreeSelection *sel = gtk_tree_view_get_selection (treeview);
	if (gtk_tree_selection_count_selected_rows (sel) > 0)
	{
		GtkTreeModel *model;
		GList *tmp, *rowrefs = NULL;
		GList *selpaths = gtk_tree_selection_get_selected_rows (sel, &model);
		//identify a place to goto after the deletion
		//(current place, if we're at the start of the tree)
		GtkTreePath *newpath = gtk_tree_path_copy (selpaths->data);
		if (!gtk_tree_path_prev (newpath))
			if (gtk_tree_path_get_depth (newpath) > 1)
				gtk_tree_path_up (newpath);
		GtkTreePath *path;
		GtkTreeIter iter;

		//create treerowrefs for all selected rows
		for (tmp = selpaths; tmp!=NULL; tmp=tmp->next)
		{
			path = (GtkTreePath *) tmp->data;
			if (gtk_tree_model_get_iter (model, &iter, path))
				_e2_tree_reference_treerow (model, &iter, &rowrefs);
			gtk_tree_path_free (path);
		}
		g_list_free (selpaths);

		for (tmp = rowrefs; tmp != NULL; tmp = tmp->next)
		{
			path = gtk_tree_row_reference_get_path ((GtkTreeRowReference *) tmp->data);
			if (path != NULL)
			{
				if (gtk_tree_model_get_iter (model, &iter, path))
				{
					//gtk_tree_selection_unselect_path (sel, path);	//needed ?
					//this deletes all children too
					gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
				}
				gtk_tree_path_free (path);
			}
			gtk_tree_row_reference_free ((GtkTreeRowReference *) tmp->data);
		}
		g_list_free (rowrefs);

		//go to the new place
		if (!gtk_tree_model_get_iter (model, &iter, newpath)
			&& gtk_tree_model_get_iter_first (model, &iter))
		{
			gtk_tree_path_free (newpath);
			newpath = gtk_tree_model_get_path (model, &iter);
		}
		gtk_tree_view_set_cursor (treeview, newpath,
			gtk_tree_view_get_column (treeview, 0), FALSE);

		gtk_tree_path_free (newpath);
	}
}
Example #28
0
static gboolean
acwin_move_selection(BluefishTextView * btv, gint keyval)
{
	GtkTreeSelection *selection;
	GtkTreeIter it;
	GtkTreeModel *model;
	GtkTreePath *path;

	selection = gtk_tree_view_get_selection(ACWIN(btv->autocomp)->tree);
	if (gtk_tree_selection_get_selected(selection, &model, &it)) {
		gboolean retval = TRUE;
		gint i, rows = 12, *indices = NULL;
		path = gtk_tree_model_get_path(model, &it);
		indices = gtk_tree_path_get_indices(path);
		switch (keyval) {
		case GDK_Up:			/* move the selection one up */
			retval = gtk_tree_path_prev(path);
			break;
		case GDK_Down:
			gtk_tree_path_next(path);
			break;
		case GDK_Page_Down:
			i = MIN(gtk_tree_model_iter_n_children(model, NULL) - 1, indices[0] + rows);
			gtk_tree_path_free(path);
			path = gtk_tree_path_new_from_indices(i, -1);
			break;
		case GDK_Page_Up:
			i = MAX(indices[0] - rows, 0);
			gtk_tree_path_free(path);
			path = gtk_tree_path_new_from_indices(i, -1);
			break;
		case GDK_Home:
			gtk_tree_path_free(path);
			path = gtk_tree_path_new_first();
			break;
		case GDK_End:
			gtk_tree_path_free(path);
			i = gtk_tree_model_iter_n_children(model, NULL);
			path = gtk_tree_path_new_from_indices(i - 1, -1);
			break;
		default:
			return FALSE;
			break;
		}
		if (gtk_tree_model_get_iter(model, &it, path)) {
			gtk_tree_selection_select_iter(selection, &it);
			gtk_tree_view_scroll_to_cell(ACWIN(btv->autocomp)->tree, path, NULL, FALSE, 0, 0);
		} else
			retval = FALSE;
		gtk_tree_path_free(path);
		return retval;
	} else {
		/* set selection */

	}
	return FALSE;
}
Example #29
0
/**
@brief find previous iter in a tree model
This is because gtk doesn't have one.
On entry, @a iter is assumed valid
Sets @a iter to point to the node preceding it at the current level.

@param model the tree model being interrogated
@param iter pointer to reference iter

@return TRUE if a prior node was found, and iter was set accordingly
*/
gboolean e2_tree_iter_previous (GtkTreeModel *model, GtkTreeIter *iter)
{
	GtkTreePath *path = gtk_tree_model_get_path (model, iter);
	gboolean retval = gtk_tree_path_prev (path);
	if (retval)
		retval = gtk_tree_model_get_iter (model, iter, path);
	gtk_tree_path_free (path);
	return retval;
}
Example #30
0
static void
codec_moved_cb (GtkWidget *widget, 
                gpointer data)
{ 	
  CodecsBox *self = NULL;

  GtkTreeIter iter;
  GtkTreeIter *iter2 = NULL;
  GtkTreeModel *model = NULL;
  GtkTreeSelection *selection = NULL;
  GtkTreePath *tree_path = NULL;

  std::list<std::string> list;

  gchar *path_str = NULL;

  self = CODECS_BOX (data);

  model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list));
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list));
  if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), 
                                        NULL, &iter))
    return;

  /* Update the tree view */
  iter2 = gtk_tree_iter_copy (&iter);
  path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model), 
                                                  &iter);
  tree_path = gtk_tree_path_new_from_string (path_str);
  if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"), 
               "up"))
    gtk_tree_path_prev (tree_path);
  else
    gtk_tree_path_next (tree_path);

  gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path);
  if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)
      && gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2))
    gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);

  /* Scroll to the new position */
  gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list), 
                                tree_path, NULL, FALSE, 0, 0);

  gtk_tree_path_free (tree_path);
  gtk_tree_iter_free (iter2);
  g_free (path_str);

  /* Update the key */
  list = codecs_box_to_list (self);
  if (self->priv->type == Ekiga::Call::Audio)
    self->priv->audio_settings->set_string_list ("media-list", list);
  else if (self->priv->type == Ekiga::Call::Video)
    self->priv->video_settings->set_string_list ("media-list", list);
}