Esempio n. 1
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);

        ensure_layout ();
	test_position (GTK_TREE_VIEW (fixture->tree_view), path,
		       use_align, row_align);
}
Esempio n. 2
0
static void
select_created_user (UmUser *user, UmUserPanelPrivate *d)
{
        GtkTreeView *tv;
        GtkTreeModel *model;
        GtkTreeSelection *selection;
        GtkTreeIter iter;
        UmUser *current;
        GtkTreePath *path;

        tv = (GtkTreeView *)get_widget (d, "list-treeview");
        model = gtk_tree_view_get_model (tv);
        selection = gtk_tree_view_get_selection (tv);

        gtk_tree_model_get_iter_first (model, &iter);
        do {
                gtk_tree_model_get (model, &iter, USER_COL, &current, -1);
                if (user == current) {
                        path = gtk_tree_model_get_path (model, &iter);
                        gtk_tree_view_scroll_to_cell (tv, path, NULL, FALSE, 0.0, 0.0);
                        gtk_tree_selection_select_path (selection, path);
                        gtk_tree_path_free (path);
                        g_object_unref (current);
                        break;
                }
                if (current)
                        g_object_unref (current);
        } while (gtk_tree_model_iter_next (model, &iter));
}
Esempio n. 3
0
void
item_list_view_select (ItemListView *ilv, itemPtr item)
{
	GtkTreeView		*treeview = ilv->priv->treeview;
	GtkTreeSelection	*selection;
	
	selection = gtk_tree_view_get_selection (treeview);
	
	if (item) {
		GtkTreeIter		iter;
		GtkTreePath		*path;
		
		if (!item_list_view_id_to_iter(ilv, item->id, &iter))
			/* This is an evil hack to fix SF #1870052: crash
			   upon hitting <enter> when no headline selected.
			   FIXME: This code is rotten! Rewrite it! Now! */
			itemlist_selection_changed (NULL);

		path = gtk_tree_model_get_path (gtk_tree_view_get_model (treeview), &iter);
		gtk_tree_view_set_cursor (treeview, path, NULL, FALSE);
		gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0.0, 0.0);
		gtk_tree_path_free (path);
	} else {
		gtk_tree_selection_unselect_all (selection);
	}
}
Esempio n. 4
0
static void find_entry_changed(GtkEditable* entry, MateWeatherPref* pref)
{
	GtkTreeView *tree;
	GtkTreeModel *model;
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GtkTreePath *path;
	const gchar *location;

	tree = GTK_TREE_VIEW (pref->priv->tree);
	model = gtk_tree_view_get_model (tree);

	g_return_if_fail (model != NULL);

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
	gtk_tree_model_get_iter_first (model, &iter);

	location = gtk_entry_get_text (GTK_ENTRY (entry));

	if (find_location (model, &iter, location, TRUE))
	{
		gtk_widget_set_sensitive (pref->priv->find_next_btn, TRUE);

		path = gtk_tree_model_get_path (model, &iter);
		gtk_tree_view_expand_to_path (tree, path);
		gtk_tree_selection_select_iter (selection, &iter);
		gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0);

		gtk_tree_path_free (path);
	}
	else
	{
		gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE);
	}
}
Esempio n. 5
0
/**
 * gwy_grain_value_tree_view_select:
 * @treeview: A tree view with grain values.
 * @gvalue: The grain value to select.
 *
 * Selects a particular grain value in a grain value tree view.
 *
 * If the @gvalue group is currently unexpanded, it will be expanded to
 * show it, and the tree view may scroll to make it visible.
 *
 * Since: 2.8
 **/
void
gwy_grain_value_tree_view_select(GtkTreeView *treeview,
                                 GwyGrainValue *gvalue)
{
    GtkTreeSelection *selection;
    GtkTreeModel *model;
    GtkTreePath *path;
    GtkTreeIter iter;

    g_return_if_fail(GTK_IS_TREE_VIEW(treeview));
    g_return_if_fail(GWY_IS_GRAIN_VALUE(gvalue));
    g_return_if_fail(priv_quark
                     && g_object_get_qdata(G_OBJECT(treeview), priv_quark));

    model = gtk_tree_view_get_model(treeview);
    if (!find_grain_value(model, gvalue, &iter)) {
        g_warning("Grain value not in tree model.");
        return;
    }

    path = gtk_tree_model_get_path(model, &iter);
    gtk_tree_view_expand_to_path(treeview, path);
    gtk_tree_view_scroll_to_cell(treeview, path, NULL, FALSE, 0.0, 0.0);
    gtk_tree_path_free(path);

    selection = gtk_tree_view_get_selection(treeview);
    gtk_tree_selection_select_iter(selection, &iter);
}
Esempio n. 6
0
/**
 *  Logs a status message *without* setting the status bar.
 *  (Use ui_set_statusbar() to display text on the statusbar)
 *
 *  @param format @c printf()-style format string.
 *  @param ... Arguments for the @c format string.
 **/
GEANY_API_SYMBOL
void msgwin_status_add(const gchar *format, ...)
{
	GtkTreeIter iter;
	gchar *string;
	gchar *statusmsg, *time_str;
	va_list args;

	va_start(args, format);
	string = g_strdup_vprintf(format, args);
	va_end(args);

	/* add a timestamp to status messages */
	time_str = utils_get_current_time_string();
	statusmsg = g_strconcat(time_str, ": ", string, NULL);
	g_free(time_str);
	g_free(string);

	/* add message to Status window */
	gtk_list_store_append(msgwindow.store_status, &iter);
	gtk_list_store_set(msgwindow.store_status, &iter, 0, statusmsg, -1);
	g_free(statusmsg);

	if (G_LIKELY(main_status.main_window_realized))
	{
		GtkTreePath *path = gtk_tree_model_get_path(gtk_tree_view_get_model(GTK_TREE_VIEW(msgwindow.tree_status)), &iter);

		gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(msgwindow.tree_status), path, NULL, FALSE, 0.0, 0.0);
		if (prefs.switch_to_status)
			gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_STATUS);
		gtk_tree_path_free(path);
	}
}
Esempio n. 7
0
static void
on_panel_show (GtkWidget *widget,
               gpointer   dummy)
{
  GtkTreePath *path;
  GtkTreeView *view = GTK_TREE_VIEW (plugin_data.view);
  
  fill_store (plugin_data.store);
  
  gtk_widget_grab_focus (plugin_data.entry);
  
  if (plugin_data.last_path) {
    gtk_tree_view_set_cursor (view, plugin_data.last_path, NULL, FALSE);
    gtk_tree_view_scroll_to_cell (view, plugin_data.last_path, NULL,
                                  TRUE, 0.5, 0.5);
  }
  /* make sure the cursor is set (e.g. if plugin_data.last_path wasn't valid) */
  gtk_tree_view_get_cursor (view, &path, NULL);
  if (path) {
    gtk_tree_path_free (path);
  } else {
    GtkTreeIter iter;
    
    if (gtk_tree_model_get_iter_first (gtk_tree_view_get_model (view), &iter)) {
      tree_view_set_cursor_from_iter (GTK_TREE_VIEW (plugin_data.view), &iter);
    }
  }
}
Esempio n. 8
0
/* Expand trees (and any subtrees they may have) whose ett_ shows them as
 * expanded.
 * Callers should block calls to expand_tree() to avoid useless recursion.
 */
static void
check_expand_trees(GtkTreeView *tree_view, GtkTreeModel *model, GtkTreePath *path,
                   GtkTreeIter *iter, gboolean scroll_it, gboolean expand_parent)
{
    /* code inspired by gtk_tree_model_foreach_helper */

    field_info *fi;

    do {
        GtkTreeIter child;

        if (gtk_tree_model_iter_children(model, &child, iter)) {
            gtk_tree_model_get(model, iter, 1, &fi, -1);

            if (tree_expanded(fi->tree_type)) {
                if (expand_parent)
                    gtk_tree_view_expand_row(tree_view, path, FALSE);

                if (scroll_it)
                     gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, (prefs.gui_auto_scroll_percentage/100.0f), 0.0f);

                /* try to expand children only when parent is expanded */
                gtk_tree_path_down(path);
                check_expand_trees(tree_view, model, path, &child, scroll_it, TRUE);
                gtk_tree_path_up(path);
            }
        }

        gtk_tree_path_next(path);
    } while (gtk_tree_model_iter_next(model, iter));
}
Esempio n. 9
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);
}
Esempio n. 10
0
/* compose_add_field */
void compose_add_field(Compose * compose, char const * field,
		char const * value)
{
	GtkTreeIter iter;
	GtkTreeIter iter2;
	gboolean valid;
	GtkTreePath * path;

	gtk_list_store_append(compose->h_store, &iter);
	gtk_list_store_set(compose->h_store, &iter, CHC_VISIBLE, TRUE, -1);
	if(field != NULL)
		gtk_list_store_set(compose->h_store, &iter, CHC_HEADER, field,
				-1);
	if(value != NULL)
		gtk_list_store_set(compose->h_store, &iter, CHC_VALUE, value,
				-1);
	valid = gtk_tree_model_filter_convert_child_iter_to_iter(
			GTK_TREE_MODEL_FILTER(compose->h_store_filter), &iter2,
			&iter);
	if(valid)
	{
		path = gtk_tree_model_get_path(GTK_TREE_MODEL(
					compose->h_store_filter), &iter2);
		gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(compose->h_view),
				path, NULL, TRUE, 0.0, 0.5);
		gtk_tree_path_free(path);
	}
}
Esempio n. 11
0
void list_moveto_case(list_t *list, char *name)
{
  filter_item_t *fi;
  list_item_t *item = NULL;
  int i = 0;

  /* Retrieve first line of Test Case */
  fi = filter_retrieve(list->fl_case.filter, name);
  if ( fi != NULL )
    item = fi->ptr;

  /* Retrieve first non-filtered line of this test case */
  while ( (item != NULL) && (item->flags & LIST_FLAG_FILTER) ) {
    if ( item->flags & LIST_FLAG_DONE ) {
      item = NULL;
    }
    else {
      i++;
      item = list->items[i];
    }
  }

  /* Jump to the line if not filtered */
  if ( (item != NULL) && (item->path != NULL) ) {
    gtk_tree_view_scroll_to_cell(list->tree, item->path, NULL, FALSE, 0, 0);
  }
}
Esempio n. 12
0
static void vdlist_scroll_to_row(ViewDir *vd, FileData *fd, gfloat y_align)
{
    GtkTreeIter iter;

#if GTK_CHECK_VERSION(2,20,0)
    if (gtk_widget_get_realized(vd->view) && vd_find_row(vd, fd, &iter))
#else
    if (GTK_WIDGET_REALIZED(vd->view) && vd_find_row(vd, fd, &iter))
#endif
    {
        GtkTreeModel *store;
        GtkTreePath *tpath;

        store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
        tpath = gtk_tree_model_get_path(store, &iter);
        gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vd->view), tpath, NULL, TRUE, y_align, 0.0);
        gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
        gtk_tree_path_free(tpath);

#if GTK_CHECK_VERSION(2,20,0)
        if (!gtk_widget_has_focus(vd->view)) gtk_widget_grab_focus(vd->view);
#else
        if (!GTK_WIDGET_HAS_FOCUS(vd->view)) gtk_widget_grab_focus(vd->view);
#endif
    }
}
Esempio n. 13
0
static void mem_jmp (GtkTreeView *view,
                     GtkEntry    *entry,
                     guint32      base_addr,
                     gsize        size,
                     GError     **err)
{
	GtkTreeModel *model;
	guint32       jmp_addr;
	GtkTreeIter   iter;

	jmp_addr = hexstr_to_guint32 (gtk_entry_get_text (entry), err);
	if (err && *err) {
		return;
	}

	if (jmp_addr < base_addr || jmp_addr > base_addr + size) {
		g_set_error (err,
		             g_quark_from_string ("mem_jmp"),
		             1,
		             "Invalid address");
		return;
	}

	model = gtk_tree_view_get_model (view);
	if (!model) {
		return;
	}

	if (gtk_tree_model_get_iter_first (model, &iter)) {
		do {
			guint32 addr;
			GValue  value = G_VALUE_INIT;
			GError *err   = NULL;

			gtk_tree_model_get_value (model, &iter, 0, &value);
			if (G_VALUE_HOLDS_STRING (&value)) {
				addr = hexstr_to_guint32 (g_value_get_string (&value), &err);
				if (!err) {
					if (addr == (jmp_addr & 0xFFFFFFF0)) {
						GtkTreeSelection *selection;
						GtkTreePath      *path;

						selection = gtk_tree_view_get_selection (view);
						path      = gtk_tree_model_get_path (model, &iter);

						gtk_tree_selection_select_iter (selection, &iter);
						gtk_tree_view_scroll_to_cell (view,
						                              path,
						                              NULL,
						                              TRUE,
						                              0.0,
						                              0.0);
						gtk_tree_path_free (path);
					}
				}
			}
			g_value_unset (&value);
		} while (gtk_tree_model_iter_next (model, &iter));
	}
}
Esempio n. 14
0
static void update_cb (void * data, void * user)
{
    g_return_if_fail (treeview);

    GtkTreeModel * model;
    GtkTreeIter iter;
    GtkTreePath * path = NULL;

    if (GPOINTER_TO_INT (data) <= PLAYLIST_UPDATE_SELECTION)
        return;

    if (cache != NULL)
    {
        ui_jump_to_track_cache_free (cache);
        cache = NULL;
    }

    /* If it's only a metadata update, save and restore the cursor position. */
    if (GPOINTER_TO_INT (data) <= PLAYLIST_UPDATE_METADATA &&
     gtk_tree_selection_get_selected (gtk_tree_view_get_selection
     ((GtkTreeView *) treeview), & model, & iter))
        path = gtk_tree_model_get_path (model, & iter);

    fill_list ();

    if (path != NULL)
    {
        gtk_tree_selection_select_path (gtk_tree_view_get_selection
         ((GtkTreeView *) treeview), path);
        gtk_tree_view_scroll_to_cell ((GtkTreeView *) treeview, path, NULL, TRUE, 0.5, 0);
        gtk_tree_path_free (path);
    }
}
Esempio n. 15
0
void
feed_list_view_select (nodePtr node)
{
	GtkTreeModel *model = gtk_tree_view_get_model (flv->treeview);

	if (model && node && node != feedlist_get_root ()) {
		GtkTreePath *path;

		/* in filtered mode we need to convert the iterator */
		if (flv->feedlist_reduced_unread) {
			GtkTreeIter iter;
			gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (flv->filter), &iter, feed_list_view_to_iter (node->id));
			path = gtk_tree_model_get_path (model, &iter);
		} else {
			path = gtk_tree_model_get_path (model, feed_list_view_to_iter (node->id));
		}

		if (node->parent)
			feed_list_view_expand (node->parent);

		if (path) {
			gtk_tree_view_scroll_to_cell (flv->treeview, path, NULL, FALSE, 0.0, 0.0);
			gtk_tree_view_set_cursor (flv->treeview, path, NULL, FALSE);
			gtk_tree_path_free (path);
		}
 	} else {
		GtkTreeSelection *selection = gtk_tree_view_get_selection (flv->treeview);
		gtk_tree_selection_unselect_all (selection);
	}
}
Esempio n. 16
0
G_MODULE_EXPORT void
queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
{
    GtkTreeModel *store;
    GtkTreeIter iter, piter;
    
    g_debug("queue_list_selection_changed_cb ()");
    // A queue entry is made up of a parent and multiple
    // children that are visible when expanded.  When and entry
    // is selected, I want the parent to be selected.
    // This is purely cosmetic.
    if (gtk_tree_selection_get_selected(selection, &store, &iter))
    {
        GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
        gtk_widget_set_sensitive (widget, TRUE);
        if (gtk_tree_model_iter_parent (store, &piter, &iter))
        {
            GtkTreePath *path;
            GtkTreeView *treeview;
            
            gtk_tree_selection_select_iter (selection, &piter);
            path = gtk_tree_model_get_path (store, &piter);
            treeview = gtk_tree_selection_get_tree_view (selection);
            // Make the parent visible in scroll window if it is not.
            gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0);
            gtk_tree_path_free(path);
        }
    }
    else
    {
        GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
        gtk_widget_set_sensitive (widget, FALSE);
    }
}
Esempio n. 17
0
static void cv_tree_focus(chan * ch)
{
	GtkTreeView *tree = ((treeview *) ch->cv)->tree;
	GtkTreeModel *model = gtk_tree_view_get_model(tree);
	GtkTreePath *path;
	GtkTreeIter parent;

	/* expand the parent node */
	if (gtk_tree_model_iter_parent(model, &parent, &ch->iter)) {
		path = gtk_tree_model_get_path(model, &parent);
		if (path) {
			/*if (!gtk_tree_view_row_expanded (tree, path))
			   {
			   gtk_tree_path_free (path);
			   return;
			   } */
			gtk_tree_view_expand_row(tree, path, FALSE);
			gtk_tree_path_free(path);
		}
	}

	path = gtk_tree_model_get_path(model, &ch->iter);
	if (path) {
		gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0.5, 0.5);
		gtk_tree_view_set_cursor(tree, path, NULL, FALSE);
		gtk_tree_path_free(path);
	}
}
Esempio n. 18
0
void
mdm_lang_set (char *language)
{
   char *locale;
   GtkTreeSelection *selection;
   GtkTreeIter iter = {0};

   g_free (current_language);
   current_language = g_strdup (language);

   if (dialog == NULL)
     mdm_lang_setup_treeview ();

   if (language == NULL)
      return;
 
   lang_set_custom_callback (language);

   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
   gtk_tree_selection_unselect_all (selection);

   if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model), &iter)) {
      do {
         gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter, LOCALE_COLUMN, &locale, -1);
         if (locale != NULL && strcmp (locale, language) == 0) {
            GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (lang_model), &iter);

            gtk_tree_selection_select_iter (selection, &iter);
            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv), path, NULL, FALSE, 0.0, 0.0);
            gtk_tree_path_free (path);
            break;
         }
      } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter));
   }
}
Esempio n. 19
0
static void
expand_tree(GtkTreeView *tree_view, GtkTreeIter *iter,
            GtkTreePath *path, gpointer user_data _U_)
{
    field_info   *finfo;
    GtkTreeModel *model;

    model = gtk_tree_view_get_model(tree_view);
    gtk_tree_model_get(model, iter, 1, &finfo, -1);
    g_assert(finfo);

    /* scroll the expanded item to reduce the need to do a manual scroll down
     * and provide faster navigation of deeper trees */

    if(prefs.gui_auto_scroll_on_expand)
        gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, (prefs.gui_auto_scroll_percentage/100.0f), 0.0f);

    /*
     * Nodes with "finfo->tree_type" of -1 have no ett_ value, and
     * are thus presumably leaf nodes and cannot be expanded.
     */
    if (finfo->tree_type != -1)
        tree_expanded_set(finfo->tree_type, TRUE);

    if (finfo->tree_type != -1 && path) {
        /* Expand any subtrees that the user had left open */
        g_signal_handlers_block_by_func(tree_view, expand_tree, NULL);
        check_expand_trees(tree_view, model, path, iter, FALSE, FALSE);
        g_signal_handlers_unblock_by_func(tree_view, expand_tree, NULL);
    }
}
Esempio n. 20
0
void wxListBox::DoSetSelection( int n, bool select )
{
    wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );

    wxGtkEventsDisabler<wxListBox> noEvents(this);

    GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);

    // passing -1 to SetSelection() is documented to deselect all items
    if ( n == wxNOT_FOUND )
    {
        gtk_tree_selection_unselect_all(selection);
        return;
    }

    wxCHECK_RET( IsValid(n), wxT("invalid index in wxListBox::SetSelection") );


    GtkTreeIter iter;
    wxCHECK_RET( GTKGetIteratorFor(n, &iter), wxT("Invalid index") );

    if (select)
        gtk_tree_selection_select_iter(selection, &iter);
    else
        gtk_tree_selection_unselect_iter(selection, &iter);

    wxGtkTreePath path(
            gtk_tree_model_get_path(GTK_TREE_MODEL(m_liststore), &iter));

    gtk_tree_view_scroll_to_cell(m_treeview, path, NULL, FALSE, 0.0f, 0.0f);
}
Esempio n. 21
0
void msgwin_compiler_add_string(gint msg_color, const gchar *msg)
{
	GtkTreeIter iter;
	GtkTreePath *path;
	const GdkColor *color = get_color(msg_color);
	gchar *utf8_msg;

	if (! g_utf8_validate(msg, -1, NULL))
		utf8_msg = utils_get_utf8_from_locale(msg);
	else
		utf8_msg = (gchar *) msg;

	gtk_list_store_append(msgwindow.store_compiler, &iter);
	gtk_list_store_set(msgwindow.store_compiler, &iter,
		COMPILER_COL_COLOR, color, COMPILER_COL_STRING, utf8_msg, -1);

	if (ui_prefs.msgwindow_visible && interface_prefs.compiler_tab_autoscroll)
	{
		path = gtk_tree_model_get_path(
			gtk_tree_view_get_model(GTK_TREE_VIEW(msgwindow.tree_compiler)), &iter);
		gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(msgwindow.tree_compiler), path, NULL, TRUE, 0.5, 0.5);
		gtk_tree_path_free(path);
	}

	/* calling build_menu_update for every build message would be overkill, TODO really should call it once when all done */
	gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_NEXT_ERROR], TRUE);
	gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_PREV_ERROR], TRUE);

	if (utf8_msg != msg)
		g_free(utf8_msg);
}
Esempio n. 22
0
static void changed(GtkTreeSelection *treeselection, gpointer user_data) {
  GtkWidget *list = static_cast<GtkWidget *>(user_data);
  list_priv_t *priv = static_cast<list_priv_t *>(g_object_get_data(G_OBJECT(list), "priv"));

  GtkTreeModel *model;
  GtkTreeIter iter;
  bool selected = list_get_selected(list, &model, &iter);

  /* scroll to selected entry if exactly one is selected */
  if(selected) {
    /* check if the entry isn't already visible */
    GtkTreePath *start = nullptr, *end = nullptr;
    tree_path_guard path(gtk_tree_model_get_path(model, &iter));

    gtk_tree_view_get_visible_range(priv->view, &start, &end);
    tree_path_guard sguard(start), eguard(end);

    /* check if path is before start of visible area or behin end of it */
    if((sguard && (gtk_tree_path_compare(path.get(), sguard.get())) < 0) ||
       (eguard && (gtk_tree_path_compare(path.get(), eguard.get()) > 0)))
      gtk_tree_view_scroll_to_cell(priv->view, path.get(), nullptr, TRUE, 0.5, 0.5);
  }

  /* the change event handler is overridden */
  priv->change(treeselection, priv->callback_context);
}
Esempio n. 23
0
static void
search_selection_changed(GtkTreeSelection * treeselection, gpointer user_data) {

    GtkTreeIter iter;
    GtkTreePath * path;
    GtkTreePath * path_up;
    gpointer gptr1;
    gpointer gptr2;
    playlist_t * pl;

    if (!gtk_tree_selection_get_selected(search_select, NULL, &iter)) {
        return;
    }

    gtk_tree_model_get(GTK_TREE_MODEL(search_store), &iter,
                       1, &gptr1, 3, &gptr2, -1);

    path = (GtkTreePath *)gptr1;
    path_up = gtk_tree_path_copy(path);

    pl = (playlist_t *)gptr2;

    if (gtk_tree_path_up(path_up)) {
        gtk_tree_view_expand_row(GTK_TREE_VIEW(pl->view), path_up, FALSE);
    }

    gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(pl->view), path, NULL, TRUE, 0.5f, 0.5f);
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(pl->view), path, NULL, FALSE);

    playlist_set_current(pl);

    gtk_tree_path_free(path_up);
}
Esempio n. 24
0
static void
showed_message_cb (GtrTab * tab, GtrMsg * msg, GtrMessageTable * table)
{
    GtkTreePath *path;
    GtkTreeSelection *selection;
    GtkTreeIter iter, child_iter;
    GtrMessageTablePrivate *priv;

    priv = gtr_message_table_get_instance_private (table);

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
    gtr_message_table_get_message_iter (priv->store, msg, &child_iter);

    gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT
            (priv->sort_model),
            &iter, &child_iter);

    gtk_tree_selection_select_iter (selection, &iter);
    path = gtk_tree_model_get_path (priv->sort_model, &iter);

    gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->treeview),
                                  path, NULL, TRUE, 0.5, 0.0);

    gtk_tree_path_free (path);
}
Esempio n. 25
0
static gboolean compare_location(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer user_data)
{
    MateWeatherPref* pref = user_data;
    WeatherLocation* loc;
    GtkTreeView* view;

    gtk_tree_model_get(model, iter, MATEWEATHER_XML_COL_POINTER, &loc, -1);

    if (!loc)
    {
		return FALSE;
	}

    if (!weather_location_equal(loc, pref->priv->applet->mateweather_pref.location))
    {
		return FALSE;
	}

    view = GTK_TREE_VIEW(pref->priv->tree);
    gtk_tree_view_expand_to_path(view, path);
    gtk_tree_view_set_cursor(view, path, NULL, FALSE);
    gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.5);

    return TRUE;
}
void tourney_result(PIECE win, int moves)
{
        GtkTreeIter iter;
        GtkTreePath *path;
        int game = tourney_total - tournament + 1;
        char *filename;

        tourney_wins[win]++;

        /* Add game to list */
        gtk_list_store_append(tourney_store, &iter);
        gtk_list_store_set(tourney_store, &iter, 0, piece_to_string(win),
                           1, moves, 2, game, -1);

        /* Scroll games list down */
        path = gtk_tree_model_get_path(GTK_TREE_MODEL(tourney_store), &iter);
        gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tourney_view), path,
                                     NULL, FALSE, 0., 0.);
        gtk_tree_path_free(path);

        /* Save the tournament game */
        if (tourney_prefix_str) {
                filename = g_strdup(va("%s%d", tourney_prefix_str, game));
                save_moves_list(filename);
                g_free(filename);
        }

        if (--tournament > 0) {
                new_game(board_size);
                return;
        }
        tourney_dialog_stop(NULL);
}
Esempio n. 27
0
void
find_entry_changed (GtkEditable *entry/*, GWeatherPref *pref*/)
{
	GtkTreeModel *model;
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GtkTreePath *path;
	GtkWidget *nextbutton;
	const gchar *location;

	nextbutton = (GtkWidget *) glade_xml_get_widget(glade_xml, "findnextbutton");

	model = gtk_tree_view_get_model (GTK_TREE_VIEW(locations_widgets->tree));

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (locations_widgets->tree));
	gtk_tree_model_get_iter_first (model, &iter);

	location = gtk_entry_get_text (GTK_ENTRY (entry));

	if (find_location (model, &iter, location, TRUE)) 
	{
		gtk_widget_set_sensitive (nextbutton , TRUE);

		path = gtk_tree_model_get_path (model, &iter);
		gtk_tree_view_expand_to_path (GTK_TREE_VIEW(locations_widgets->tree), path);
		gtk_tree_selection_select_iter (selection, &iter);
		gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(locations_widgets->tree), path, NULL, TRUE, 0.5, 0);

		gtk_tree_path_free (path);
	} 
	else 
	{
		gtk_widget_set_sensitive (nextbutton, FALSE);
	}
}
void AP_UnixDialog_Stylist::setStyleInGUI(void)
{
	UT_sint32 row,col;
	UT_UTF8String sCurStyle = *getCurStyle();

	if((getStyleTree() == NULL) || (sCurStyle.size() == 0))
		updateDialog();

	if(m_wStyleList == NULL)
		return;

	if(isStyleTreeChanged())
		_fillTree();

	getStyleTree()->findStyle(sCurStyle,row,col);
	UT_DEBUGMSG(("After findStyle row %d col %d col \n",row,col));
	UT_UTF8String sPathFull = UT_UTF8String_sprintf("%d:%d",row,col);
	UT_UTF8String sPathRow = UT_UTF8String_sprintf("%d",row);
	UT_DEBUGMSG(("Full Path string is %s \n",sPathFull.utf8_str()));
	GtkTreePath * gPathRow = gtk_tree_path_new_from_string (sPathRow.utf8_str());
	GtkTreePath * gPathFull = gtk_tree_path_new_from_string (sPathFull.utf8_str());
	gtk_tree_view_expand_row( GTK_TREE_VIEW(m_wStyleList),gPathRow,TRUE);
	gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE,0.5,0.5);
	gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE);
	setStyleChanged(false);
	gtk_tree_path_free(gPathRow);
	gtk_tree_path_free(gPathFull);
}
Esempio n. 29
0
static void
select_index (const gchar *uri)
{
  GtkTreeSelection *selection;
  GtkTreeIter      *iter = NULL;

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));

  if (uri)
    iter = g_hash_table_lookup (uri_hash_table, uri);

  if (iter)
    {
      GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
      GtkTreePath  *path;
      GtkTreePath  *scroll_path;

      path = gtk_tree_model_get_path (model, iter);
      scroll_path = gtk_tree_path_copy (path);

      gtk_tree_path_up (path);
      gtk_tree_view_expand_to_path (GTK_TREE_VIEW (tree_view), path);
      gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tree_view), scroll_path,
                                    NULL, FALSE, 0.0, 0.0);

      gtk_tree_path_free (path);
      gtk_tree_path_free (scroll_path);

      gtk_tree_selection_select_iter (selection, iter);
    }
  else
    {
      gtk_tree_selection_unselect_all (selection);
    }
}
Esempio n. 30
0
static void remmina_main_select_file(RemminaMain *remminamain, const gchar *filename)
{
	GtkTreeIter iter;
	GtkTreePath *path;
	gchar *item_filename;
	gboolean cmp;

	if (!gtk_tree_model_get_iter_first(remminamain->priv->file_model_sort, &iter))
		return;

	while (1)
	{
		gtk_tree_model_get(remminamain->priv->file_model_sort, &iter, FILENAME_COLUMN, &item_filename, -1);
		cmp = g_strcmp0(item_filename, filename);
		g_free(item_filename);
		if (cmp == 0)
		{
			gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(remminamain->priv->file_list)),
					&iter);
			path = gtk_tree_model_get_path(remminamain->priv->file_model_sort, &iter);
			gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(remminamain->priv->file_list), path, NULL, TRUE, 0.5, 0.0);
			gtk_tree_path_free(path);
			return;
		}
		if (!gtk_tree_model_iter_next(remminamain->priv->file_model_sort, &iter))
			return;
	}
}