Пример #1
0
/* Called when Add... button is clicked */
static void add_exclude(GtkButton *button, gpointer user_data)
{
  /* Append new item */
  GtkTreeIter row_iter;
  gtk_list_store_append(exclude_list, &row_iter);
  /* Add a %s to the command */
  //gtk_list_store_set(actions_list, &row_iter, 1, "", -1);
  /* Set the first column to editing */
  GtkTreePath* row_path = gtk_tree_model_get_path((GtkTreeModel*)exclude_list, &row_iter);
  GtkTreeView* treeview = gtk_tree_selection_get_tree_view(exclude_selection);
  GtkTreeViewColumn* column = gtk_tree_view_get_column(treeview, 0);
  gtk_tree_view_set_cursor(treeview, row_path, column, TRUE);
  gtk_tree_path_free(row_path);
}
Пример #2
0
/**************************************************************************
  Give focus to view
**************************************************************************/
void gtk_tree_view_focus(GtkTreeView *view)
{
  GtkTreeModel *model;
  GtkTreePath *path;
  GtkTreeIter iter;

  if ((model = gtk_tree_view_get_model(view))
      && gtk_tree_model_get_iter_first(model, &iter)
      && (path = gtk_tree_model_get_path(model, &iter))) {
    gtk_tree_view_set_cursor(view, path, NULL, FALSE);
    gtk_tree_path_free(path);
    gtk_widget_grab_focus(GTK_WIDGET(view));
  }
}
Пример #3
0
static gboolean
set_current_action (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) {
    GValue val = {0,}, ctx_val = {0,};
    gtk_tree_model_get_value (model, iter, 1, &val);
    gtk_tree_model_get_value (model, iter, 2, &ctx_val);
    actionbinding_t *binding = data;
    const char *name = g_value_get_string (&val);
    if (name && binding->name && !strcmp (binding->name, name) && binding->ctx == g_value_get_int (&ctx_val)) {
        gtk_tree_view_expand_to_path (GTK_TREE_VIEW (binding->treeview), path);
        gtk_tree_view_set_cursor (GTK_TREE_VIEW (binding->treeview), path, NULL, FALSE);
        return TRUE;
    }
    return FALSE;
}
Пример #4
0
void prefsgui_apply_style_scheme(GuPrefsGui* prefs)
{
  const gchar* scheme = config_get_value("style_scheme");
  GList* schemes = editor_list_style_scheme_sorted();
  GList* schemes_iter = schemes;
  GList* tab = gummi->tabmanager->tabs;
  gint column = 0;
  GtkTreePath* treepath;

  while (schemes_iter) {
    if (STR_EQU(gtk_source_style_scheme_get_id(schemes_iter->data),
                scheme)) {
      gchar* path = g_strdup_printf("%d", column);
      treepath = gtk_tree_path_new_from_string(path);
      gtk_tree_view_set_cursor(prefs->styleschemes_treeview, treepath,
                               NULL, FALSE);
      gtk_tree_path_free(treepath);
      g_free(path);
      break;
    }
    ++column;
    schemes_iter = g_list_next(schemes_iter);
  }
  g_list_free(schemes);

  if (schemes && !schemes_iter) {
    treepath = gtk_tree_path_new_from_string("0");
    gtk_tree_view_set_cursor(prefs->styleschemes_treeview, treepath, NULL,
                             FALSE);
    gtk_tree_path_free(treepath);
    while (tab) {
      editor_set_style_scheme_by_id(GU_TAB_CONTEXT(tab->data)->editor,
                                    "classic");
      tab = g_list_next(tab);
    }
  }
}
Пример #5
0
/**
 * gva_main_execute_search:
 *
 * Executes a game database search and configures the main window to
 * display the results.  More precisely, the function saves the search
 * entry contents to GConf, switches to the Search Results view, forces
 * an update, ensures a row in the resulting game list is selected, and
 * gives focus to the main tree view.
 *
 * The SQL expression used in the database search is retrieved from
 * gva_main_get_search_expression().  It is applied while updating the
 * Search Results view.
 **/
void
gva_main_execute_search (void)
{
        GtkTreeSelection *selection;
        GtkTreeModel *model;
        GtkTreeView *view;
        GtkTreeIter iter;
        GtkEntry *entry;
        gchar *text;

        entry = GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY);
        view = GTK_TREE_VIEW (GVA_WIDGET_MAIN_TREE_VIEW);
        selection = gtk_tree_view_get_selection (view);

        /* Save the search entry text. */
        text = g_strdup (gtk_entry_get_text (entry));
        gtk_entry_set_text (entry, g_strstrip (text));
        gva_main_set_last_search_text (text);
        g_free (text);

        /* Force a tree view update. */
        if (gva_tree_view_get_selected_view () != 2)
                gva_tree_view_set_selected_view (2);
        else
        {
                GError *error = NULL;

                gva_tree_view_update (&error);
                gva_error_handle (&error);
        }

        /* Select something in the tree view.  Parts of this are
         * copied from gva_tree_view_set_selected_game(). */
        if (!gtk_tree_selection_get_selected (selection, &model, &iter))
        {
                if (gtk_tree_model_get_iter_first (model, &iter))
                {
                        GtkTreePath *path;

                        path = gtk_tree_model_get_path (model, &iter);
                        gtk_tree_view_set_cursor (view, path, NULL, FALSE);
                        gtk_tree_view_scroll_to_cell (
                                view, path, NULL, TRUE, 0.5, 0.0);
                        gtk_tree_path_free (path);
                }
        }

        gtk_widget_grab_focus (GTK_WIDGET (view));
}
Пример #6
0
static void
scroll_both_realize (ScrollFixture *fixture,
		     GtkTreePath   *path,
		     gboolean       use_align,
		     gdouble        row_align)
{
	GtkTreePath *end;

	gtk_widget_show_all (fixture->window);

	/* Scroll to end */
	end = gtk_tree_path_new_from_indices (999, -1);

	gtk_tree_view_set_cursor (GTK_TREE_VIEW (fixture->tree_view), end,
				  NULL, FALSE);
	gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fixture->tree_view),
				      end, NULL,
				      use_align, row_align, 0.0);
	gtk_tree_path_free (end);

	while (gtk_events_pending ())
		gtk_main_iteration ();

	/* Scroll to final position */
	gtk_tree_view_set_cursor (GTK_TREE_VIEW (fixture->tree_view), path,
				  NULL, FALSE);
	gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fixture->tree_view),
				      path, NULL,
				      use_align, row_align, 0.0);

	while (gtk_events_pending ())
		gtk_main_iteration ();

	test_position (GTK_TREE_VIEW (fixture->tree_view), path,
		       use_align, row_align);
}
Пример #7
0
void
tasks_select_first_position_in_list(GUI *appGUI) {

GtkTreeIter     iter;
GtkTreePath     *path;

    /* set cursor at first position */
    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter) == TRUE) {
        path = gtk_tree_model_get_path (GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter);
        if (path != NULL) {
            gtk_tree_view_set_cursor (GTK_TREE_VIEW (appGUI->tsk->tasks_list), path, NULL, TRUE);
            gtk_tree_path_free(path);
        }
    }
}
Пример #8
0
static void
library_switch_cb (GtkWidget *combo_box, Browser *br)
{
	GtkTreePath *path;
	GList *libs = oregano.libraries;

	br->library = (Library *) g_list_nth_data (libs,
		gtk_combo_box_get_active (GTK_COMBO_BOX (combo_box)));

	update_list (br);
	
	path = gtk_tree_path_new_first ();
	gtk_tree_view_set_cursor (GTK_TREE_VIEW (br->list), path, NULL, FALSE);
	gtk_tree_path_free (path);
}
Пример #9
0
static void
gimp_action_view_select_path (GimpActionView *view,
                              GtkTreePath    *path)
{
  GtkTreeView *tv = GTK_TREE_VIEW (view);
  GtkTreePath *expand;

  expand = gtk_tree_path_copy (path);
  gtk_tree_path_up (expand);
  gtk_tree_view_expand_row (tv, expand, FALSE);
  gtk_tree_path_free (expand);

  gtk_tree_view_set_cursor (tv, path, NULL, FALSE);
  gtk_tree_view_scroll_to_cell (tv, path, NULL, TRUE, 0.5, 0.0);
}
Пример #10
0
static void
contact_list_editor_scroll_to_end (EContactListEditor *editor)
{
	GtkTreeView *view;
	GtkTreePath *path;
	gint n_rows;

	view = GTK_TREE_VIEW (WIDGET (TREE_VIEW));
	n_rows = gtk_tree_model_iter_n_children (editor->priv->model, NULL);

	path = gtk_tree_path_new_from_indices (n_rows - 1, -1);
	gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0., 0.);
	gtk_tree_view_set_cursor (view, path, NULL, FALSE);
	gtk_tree_path_free (path);
}
Пример #11
0
void
toolbar__collapse_cb(gpointer data) {

        GtkTreeIter iter;
        GtkTreePath * path;

        gtk_tree_view_collapse_all(GTK_TREE_VIEW(music_tree));

        gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store), &iter, NULL, 0);
        path = gtk_tree_model_get_path (GTK_TREE_MODEL(music_store), &iter);
        if (path) {
                gtk_tree_view_set_cursor (GTK_TREE_VIEW (music_tree), path, NULL, TRUE);
                gtk_tree_path_free(path);
        }
}
Пример #12
0
static void
move_up (int val)
{
    int i;
    GtkTreePath *path;
    GtkTreePath *tree_path;
    GtkTreeIter iter1;
    GtkTreeIter iter2;
    GtkTreeModel *model;

    model = gtk_tree_view_get_model (GTK_TREE_VIEW (main_gui.displayed_list));

    gtk_tree_view_get_cursor (GTK_TREE_VIEW (main_gui.displayed_list), &path, NULL);

    if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
        return;

    for (i = 0; i < val; i++) {
        if (!gtk_tree_path_prev (path)) {
            if (!gtk_tree_path_up (path)) {
                break;
            } else {
                if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
                    break;
            }
        } else {
            if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (main_gui.displayed_list), path)) {
                gtk_tree_path_down (path);
                gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter2, path);
                iter1 = iter2;
                while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter2)) {
                    iter1 = iter2;
                }
            } else {
                if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
                    break;
            }
        }
    }

    tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter1);
    gtk_tree_view_set_cursor (GTK_TREE_VIEW (main_gui.displayed_list), tree_path, NULL, FALSE);
    gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (main_gui.displayed_list), tree_path, NULL, TRUE, 0.5, 0);
    gtk_tree_path_free (tree_path);

    gtk_widget_grab_focus (main_gui.displayed_list);

}
Пример #13
0
gboolean vdtree_set_fd(ViewDir *vd, FileData *dir_fd)
{
	FileData *fd;
	GtkTreeIter iter;

	if (!dir_fd) return FALSE;
	if (vd->dir_fd == dir_fd) return TRUE;

	file_data_unref(vd->dir_fd);
	vd->dir_fd = file_data_ref(dir_fd);;

	fd = vdtree_populate_path(vd, vd->dir_fd, TRUE, FALSE);

	if (!fd) return FALSE;

	if (vd_find_row(vd, fd, &iter))
		{
		GtkTreeModel *store;
		GtkTreePath *tpath, *old_tpath;
		GtkTreeSelection *selection;

		store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));

		selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));

		/* hack, such that selection is only allowed to be changed from here */
		selection_is_ok = TRUE;
		gtk_tree_selection_select_iter(selection, &iter);
		selection_is_ok = FALSE;

		gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
		tpath = gtk_tree_model_get_path(store, &iter);

		if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
			{
			/* setting the cursor scrolls the view; do not do that unless it is necessary */
			gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);

			/* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
			   does not work (switch from dir_list to dir_tree) */
			tree_view_row_make_visible(GTK_TREE_VIEW(vd->view), &iter, TRUE);
			}
		gtk_tree_path_free(tpath);
		gtk_tree_path_free(old_tpath);
		}

	return TRUE;
}
static void
notify_controlchange (BtIcControl * control, GParamSpec * arg,
    gpointer user_data)
{
  BtSettingsPageInteractionController *self =
      BT_SETTINGS_PAGE_INTERACTION_CONTROLLER (user_data);
  gint pos = get_control_pos (self->priv->device, control);
  GtkTreePath *path = gtk_tree_path_new_from_indices (pos, -1);

  // select the control
  gtk_widget_grab_focus (GTK_WIDGET (self->priv->controller_list));
  gtk_tree_view_set_cursor (self->priv->controller_list, path,
      gtk_tree_view_get_column (self->priv->controller_list,
          CONTROLLER_LIST_LABEL), TRUE);
  gtk_tree_path_free (path);
}
Пример #15
0
static void on_notebook_page_changed(GtkNotebook *notebook, gpointer page,
                                     guint n, GtkTreeView *view)
{
    GtkTreePath *tp;

    /* g_debug("changed pref page: %u", n); */
    gtk_tree_view_get_cursor(view, &tp, NULL);
    if (tp == NULL || gtk_tree_path_get_indices(tp)[0] != (int)n)
    {
        if (tp)
            gtk_tree_path_free(tp);
        tp = gtk_tree_path_new_from_indices(n, -1);
        gtk_tree_view_set_cursor(view, tp, NULL, FALSE);
    }
    gtk_tree_path_free(tp);
}
Пример #16
0
static void
select_iter (GucharmapChaptersView *view,
             GtkTreeIter *iter)
{
  GtkTreeView *tree_view = GTK_TREE_VIEW (view);
  GtkTreeSelection *selection;
  GtkTreePath *path;

  selection = gtk_tree_view_get_selection (tree_view);
  gtk_tree_selection_select_iter (selection, iter);

  path = gtk_tree_model_get_path (gtk_tree_view_get_model (tree_view), iter);
  gtk_tree_view_set_cursor (tree_view, path, NULL, FALSE);
  gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.5, 0);
  gtk_tree_path_free (path);
}
Пример #17
0
static void add_todo (MaintainrProjectbox *item)
{
	GtkTreeModel *model;
	GtkTreeView *todos;
	GtkTreeIter iter;
	GtkTreePath *path;

	todos = GTK_TREE_VIEW (item->priv->todos);
	model = gtk_tree_view_get_model (todos);
	gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, G_MAXINT, 0, FALSE, 1, "Edit me!", 2, -1, -1);

	path = gtk_tree_model_get_path (model, &iter);
	gtk_widget_grab_focus (item->priv->todos);
	gtk_tree_view_set_cursor (todos, path, gtk_tree_view_get_column (todos, 1), TRUE);
	gtk_tree_path_free (path);
}
Пример #18
0
static void remmina_string_list_add(GtkWidget *widget, RemminaStringList *gsl)
{
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GtkTreePath *path;

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gsl->list));
	gtk_list_store_append(gsl->store, &iter);
	gtk_list_store_set(gsl->store, &iter, COLUMN_COLOR, ERROR_COLOR, -1);
	gtk_tree_selection_select_iter(selection, &iter);

	path = gtk_tree_model_get_path(GTK_TREE_MODEL(gsl->store), &iter);
	gtk_tree_view_set_cursor(GTK_TREE_VIEW(gsl->list), path,
			gtk_tree_view_get_column(GTK_TREE_VIEW(gsl->list), COLUMN_TEXT), TRUE);
	gtk_tree_path_free(path);
}
Пример #19
0
static gboolean
on_treeview_btn_press_event        (GtkWidget       *widget,
                                        GdkEventButton  *event,
                                        gpointer         user_data)
{
    GtkTreeView *view = GTK_TREE_VIEW(widget);
	GtkTreePath *path;
	GtkTreeViewColumn *column;
    gboolean ret;

    switch (event->type) 
    {
    case GDK_BUTTON_PRESS:	// third button clicked
        if (event->button == 3) 
        {
            GdkEventButton *bevent;
            GtkWidget *menu;

            //--- set cell focus
            gint tx = (gint) event->x;
	        gint ty = (gint) event->y;
	        gint cx, cy;

	        ret = gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, &cy);
            gtk_tree_view_set_cursor(view, path, column, FALSE);    // select cell
            gtk_tree_view_row_activated(view, path, column);        // show selection
            gtk_tree_path_free(path);
            //printf("%i %i %i %i (%i)\n", tx, ty, cx, cy, ret);
            //---

		    bevent = (GdkEventButton *) (event);
            menu = display_dbgmem_popup_menu();

		    gtk_menu_popup(GTK_MENU(menu),
				       NULL, NULL, NULL, NULL,
				       bevent->button, bevent->time);
	        gtk_widget_show(menu);

		    return TRUE;
	    }
	    break;
    default:
        break;
    }

    return FALSE;
}
Пример #20
0
static void onkeyrelease(GtkEntry *entry, GdkEventKey *event, gpointer user_data)
{
	if(event->keyval == GDK_Return) {
		gtk_dialog_response(GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);
	}
	else if(event->keyval == GDK_Down || event->keyval == GDK_Up || event->keyval == GDK_Left || event->keyval == GDK_Right) {
		//Ignore keypresses that don't modify the text.
	}
	else {
		row_pos = 0;
		gtk_tree_store_clear(list);
		list_files(base_directory, gtk_entry_get_text(entry));
		gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment));

		gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree), first, NULL, FALSE);
	}
}
Пример #21
0
static void
select_path_str(GtkWidget *w, char *str)
{
  GtkTreePath *path;
  GtkTreeSelection *sel;
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(w));

  path = gtk_tree_path_new_from_string(str);
  if (! path)
    return;

  gtk_tree_selection_select_path(sel, path);

  gtk_tree_view_set_cursor(GTK_TREE_VIEW(w), path, NULL, FALSE); /* this line is commented out before (I forgot the reason). */

  gtk_tree_path_free(path);
}
Пример #22
0
/**
 * gucharmap_chapters_view_previous:
 * @view: a #GucharmapChapters
 *
 * Moves to the previous chapter if applicable.
 **/
void
gucharmap_chapters_view_previous (GucharmapChaptersView *view)
{
  GtkTreeView *tree_view = GTK_TREE_VIEW (view);
  GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view);
  GtkTreeModel *model;
  GtkTreePath *path;
  GtkTreeIter iter;

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

  path = gtk_tree_model_get_path (model, &iter);
  if (gtk_tree_path_prev (path))
    gtk_tree_view_set_cursor (tree_view, path, NULL, FALSE);
  gtk_tree_path_free (path);
}
Пример #23
0
static gboolean
edit_row_idle (RowEditData *data)
{
  GtkTreePath *new_item_path;

  new_item_path = gtk_tree_row_reference_get_path (data->row_ref);

  gtk_widget_grab_focus (GTK_WIDGET (data->eprop->view));
  gtk_tree_view_expand_to_path (data->eprop->view, new_item_path);
  gtk_tree_view_set_cursor (data->eprop->view, new_item_path,
                            data->eprop->filename_column, TRUE);

  gtk_tree_path_free (new_item_path);
  gtk_tree_row_reference_free (data->row_ref);
  g_slice_free (RowEditData, data);
  return FALSE;
}
Пример #24
0
/* Highlight the specified address. */
void tilem_disasm_view_go_to_address(TilemDisasmView *dv, dword addr,
                                     gboolean logical)
{
	dword pos;
	GtkTreeModel *model;
	GtkTreePath *path;
	TilemCalc *calc;

	g_return_if_fail(TILEM_IS_DISASM_VIEW(dv));

	tilem_calc_emulator_lock(dv->dbg->emu);
	calc = dv->dbg->emu->calc;

	if (logical) {
		addr &= 0xffff;
		if (dv->use_logical)
			pos = ADDR_TO_POS(addr);
		else
			pos = pos_ltop(calc, ADDR_TO_POS(addr));
	}
	else {
		if (dv->use_logical) {
			addr = (*calc->hw.mem_ptol)(calc, addr);
			if (addr == (dword) -1) {
				tilem_calc_emulator_unlock(dv->dbg->emu);
				return;
			}
		}
		pos = ADDR_TO_POS(addr);
	}

	tilem_calc_emulator_unlock(dv->dbg->emu);

	if (pos >= dv->startpos && pos < dv->endpos) {
		model = gtk_tree_view_get_model(GTK_TREE_VIEW(dv));
		path = find_path_for_position(model, pos);
		if (path) {
			gtk_tree_view_set_cursor(GTK_TREE_VIEW(dv), path,
			                         NULL, FALSE);
			gtk_tree_path_free(path);
			return;
		}
	}

	refresh_disassembly(dv, pos, dv->nlines, pos);
}
Пример #25
0
void
on_trkproperties_edit_in_place_activate
                                        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
    GtkTreePath *path;
    gtk_tree_view_get_cursor (treeview, &path, NULL);
    if (!path) {
        return;
    }

    GtkTreeViewColumn *col = gtk_tree_view_get_column (treeview, 1);

    gtk_tree_view_set_cursor (treeview, path, col, TRUE); // set cursor onto new field
    gtk_tree_path_free(path);
}
Пример #26
0
void l_spisok_setstr(class spisok_data *data)
{
  if(data->snanomer  > data->kolzap-1)
     data->snanomer= data->kolzap-1;
  if(data->snanomer < 0)
     data->snanomer=0;
      
char strsql[50];
  sprintf(strsql,"%d",data->snanomer);
  GtkTreePath *path=gtk_tree_path_new_from_string(strsql);

//  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,TRUE,0,0);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE,0,0);

  gtk_tree_view_set_cursor(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE);
  gtk_tree_path_free(path);
}
Пример #27
0
void newline(IMAGE *ima){
	FNAME();
	GtkTreeIter cur_items;
	gtk_list_store_append(ima->store, &cur_items);
	gtk_list_store_set(ima->store, &cur_items,
			L_TYPENM,	key_types[0],
			L_KEY,		"NEW_KEY",
			L_VAL,		"",
			L_COMM,		"",
			L_TYPE,		type_vals[0],
			-1);
	// Set cursor onto a first field
	gtk_tree_view_set_cursor(Tree,
			gtk_tree_model_get_path(GTK_TREE_MODEL(ima->store), &cur_items),
			gtk_tree_view_get_column(Tree, 0), TRUE);
	DBG("ret");
}
Пример #28
0
void last_mod_callback(GPid pid, gint status, gpointer data)
{
  int * out_fd = (int *)data;
  gchar * comma_pos = 0, * newline_pos = 0;
  GString * msg = NULL;
  tree_node n;

  memset(&n, 0, sizeof(tree_node));

  msg = util_get_output(*out_fd);

  close(*out_fd);
  free(out_fd);

  if (!msg)
    return;

  if (g_str_has_prefix(msg->str, "Error:"))
  {
    g_string_truncate(msg, 2);
    g_string_overwrite(msg, 0, "ra");
  }
  else if (NULL != (comma_pos = g_strstr_len(msg->str, -1, ",")))
    *comma_pos = '\0';
  else if (NULL != (newline_pos = g_strstr_len(msg->str, -1, "\n")))
    *newline_pos = '\0';

  n.key = msg->str;

  gtk_tree_model_foreach(GTK_TREE_MODEL(tree_store), find_mod, &n);

  if (n.node_path)
  {
    GtkTreePath * path;
    path = gtk_tree_path_new_from_string(n.node_path);
    if (path == NULL)
      g_warning("Invalid Path");
    gtk_tree_view_expand_to_path(tree, path);
    gtk_tree_view_set_cursor(tree, path, NULL, FALSE);
    gtk_tree_path_free(path);
    g_free(n.node_path);
  }

  g_string_free(msg, TRUE);
}
Пример #29
0
static void
add_item (GtkWidget *button, gpointer data)
{
    Item foo;
    GtkTreeIter current, iter;
    GtkTreePath *path;
    GtkTreeModel *model;
    GtkTreeViewColumn *column;
    GtkTreeView *treeview = (GtkTreeView *)data;

    g_return_if_fail (articles != NULL);

    foo.number = 0;
    foo.product = g_strdup ("Description here");
    foo.yummy = 50;
    g_array_append_vals (articles, &foo, 1);

    /* Insert a new row below the current one */
    gtk_tree_view_get_cursor (treeview, &path, NULL);
    model = gtk_tree_view_get_model (treeview);
    if (path)
    {
        gtk_tree_model_get_iter (model, &current, path);
        gtk_tree_path_free (path);
        gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter, &current);
    }
    else
    {
        gtk_list_store_insert (GTK_LIST_STORE (model), &iter, -1);
    }

    /* Set the data for the new row */
    gtk_list_store_set (GTK_LIST_STORE (model), &iter,
                        COLUMN_ITEM_NUMBER, foo.number,
                        COLUMN_ITEM_PRODUCT, foo.product,
                        COLUMN_ITEM_YUMMY, foo.yummy,
                        -1);

    /* Move focus to the new row */
    path = gtk_tree_model_get_path (model, &iter);
    column = gtk_tree_view_get_column (treeview, 0);
    gtk_tree_view_set_cursor (treeview, path, column, FALSE);

    gtk_tree_path_free (path);
}
Пример #30
0
static void
editlist_add (GtkWidget *wid, gpointer userdata)
{
    GtkTreeView *view = g_object_get_data (G_OBJECT (editlist_win), "view");
    GtkTreeViewColumn *col;
    GtkListStore *store = GTK_LIST_STORE (get_store ());
    GtkTreeIter iter;
    GtkTreePath *path;

    gtk_list_store_append (store, &iter);

    /* make sure the new row is visible and selected */
    path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
    col = gtk_tree_view_get_column (view, NAME_COLUMN);
    gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0.0, 0.0);
    gtk_tree_view_set_cursor (view, path, col, TRUE);
    gtk_tree_path_free (path);
}