Exemplo n.º 1
0
static VALUE
rg_set_cell_data_func(VALUE self, VALUE renderer)
{
    volatile VALUE func = rb_block_proc();
    G_RELATIVE(self, func);
    G_RELATIVE(renderer, func);
    gtk_tree_view_column_set_cell_data_func(_SELF(self), RVAL2CELLRENDERER(renderer),
                                            (GtkTreeCellDataFunc)cell_data_func, (gpointer)func, NULL);
    return self;
}
GtkTreeViewColumn *add_vector_to_dialog (vector_table_options_D *dialog, VectorTable *pvt, int idx)
  {
  GList *llItr = NULL, *llCols = NULL ;
  GtkTreeViewColumn *col = NULL ;
  GtkCellRenderer *cr = NULL ;
  int idxCol = (-1 == idx ? idx : idx + 2) ;
  int idxVector = (-1 == idx ? pvt->vectors->icUsed - 1 : idx) ;
  char *psz = NULL ;
  int Nix, new_idx = -1 ;

  if (idx >= 0)
    {
    // Move to the first vector column
    if (NULL != (llCols = llItr = gtk_tree_view_get_columns (GTK_TREE_VIEW (dialog->tv))))
      {
      if (NULL != (llItr = llItr->next))
        llItr = llItr->next ;
      // Increment the indices for all vector columns following the new one.
      for (Nix = 0 ; llItr != NULL ; llItr = llItr->next, Nix++)
        if (Nix >= idx)
          if (NULL != (cr = g_object_get_data (G_OBJECT (llItr->data), "cr")))
            {
            g_object_set_data (G_OBJECT (cr), "idxVector",
              (gpointer)(new_idx = (int)g_object_get_data (G_OBJECT (cr), "idxVector") + 1)) ;
            gtk_tree_view_column_set_title (GTK_TREE_VIEW_COLUMN (llItr->data), psz = g_strdup_printf ("%d", new_idx)) ;
            g_free (psz) ;
            }
      g_list_free (llCols) ;
      }
    }

  gtk_tree_view_insert_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new (), idxCol) ;
  gtk_tree_view_column_set_title (col, psz = g_strdup_printf ("%d", idxVector)) ;
  g_free (psz) ;
  gtk_tree_view_column_pack_start (col, cr = qcad_cell_renderer_vt_new (), FALSE) ;
  g_object_set (G_OBJECT (cr), 
    "cell-background-gdk", &((gtk_widget_get_style (dialog->tv))->base[3]),
    "cell-background-set", FALSE, 
    "editable", TRUE, NULL) ;
  gtk_tree_view_column_add_attribute (col, cr, "row-type", BUS_LAYOUT_MODEL_COLUMN_TYPE) ;
  gtk_tree_view_column_add_attribute (col, cr, "sensitive", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ;
  gtk_tree_view_column_set_clickable (col, TRUE) ;
  g_object_set_data (G_OBJECT (cr), "idxVector", (gpointer)idxVector) ;
  g_object_set_data (G_OBJECT (cr), "pvt", pvt) ;
  gtk_tree_view_column_set_cell_data_func (col, cr, vector_data_func, pvt, NULL) ;
  g_object_set_data (G_OBJECT (col), "cr", cr) ;
  g_object_set_data (G_OBJECT (cr), "col", col) ;

  g_signal_connect (G_OBJECT (col), "clicked", (GCallback)vector_column_clicked, dialog) ;
  g_signal_connect (G_OBJECT (cr), "clicked", (GCallback)vector_column_clicked, dialog) ;
  g_signal_connect (G_OBJECT (cr), "edited",  (GCallback)vector_value_edited, dialog->tv) ;
  g_signal_connect (G_OBJECT (cr), "editing-started", (GCallback)vector_value_editing_started, dialog) ;

  return col ;
  }
Exemplo n.º 3
0
/*
 * create env tree view and return a widget 
 */
GtkWidget* envtree_init(void)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeSelection *selection;

	/* (re)initialize globals in case plugin was reloaded but those not cleared */
	page_read_only = FALSE;
	entering_new_var = FALSE;
	empty_row = NULL;
	being_edited_value = NULL;

	store = gtk_list_store_new (
		N_COLUMNS,
		G_TYPE_STRING,
		G_TYPE_STRING,
		G_TYPE_STRING);
	model = GTK_TREE_MODEL(store);
	tree = gtk_tree_view_new_with_model (model);
	g_object_unref(store);
	
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
	g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL);

	renderer_name = gtk_cell_renderer_text_new ();
	g_object_set (renderer_name, "editable", TRUE, NULL);
	g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL);
	column_name = gtk_tree_view_column_new_with_attributes (_("Name"), renderer_name, "text", NAME, NULL);
	gtk_tree_view_column_set_resizable (column_name, TRUE);
	gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column_name);

	renderer_value = gtk_cell_renderer_text_new ();
	column_value = gtk_tree_view_column_new_with_attributes (_("Value"), renderer_value, "text", VALUE, NULL);
	g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL);
	g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL);
	g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL);
	gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL);
	gtk_tree_view_column_set_resizable (column_value, TRUE);
	gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column_value);

	/* Last invisible column */
	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);

	/* add empty row */
	add_empty_row();

	/* set multiple selection */
	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);

	return tree;
}
Exemplo n.º 4
0
static void
aw_system_view_create_columns (AwTreeView *view)
{
    GtkCellRenderer *cell;

    /* === title column === */

    cell = gtk_cell_renderer_text_new ();

    gtk_tree_view_column_set_cell_data_func
    (aw_tree_view_append_primary_column (view, cell),
     cell, aw_system_view_title_cell_cb, NULL, NULL);

    /* === detail column === */

    cell = gtk_cell_renderer_text_new ();

    gtk_tree_view_column_set_cell_data_func
    (aw_tree_view_append_secondary_column (view, cell),
     cell, aw_system_view_detail_cell_cb, NULL, NULL);
}
Exemplo n.º 5
0
void
treeview2_set_up_news(GtkTreeView *treeview)
{
#ifdef DEBUG
    printf("treeview2_set_up_news\n");
#endif

    GtkTreeViewColumn   *col;
    GtkCellRenderer     *renderer;
    gint i;

    gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
				GTK_SELECTION_NONE);
    gtk_tree_view_set_headers_visible(treeview, FALSE);
    gtk_tree_view_set_rules_hint(treeview, FALSE);

    for(i = 0; i < 3; i++)
    {
        col = gtk_tree_view_column_new();
        gtk_tree_view_append_column(treeview, col);
        renderer = treeview_helper_cell_renderer_text_new();
        gtk_tree_view_column_pack_start(col, renderer, TRUE);	

        if(i == 0)
            gtk_tree_view_column_add_attribute(col, renderer,
                                               "markup", 0);
        else if(i == 1)
            gtk_tree_view_column_set_cell_data_func(col, renderer,
                                                    treeview_helper_news,
                                                    NULL, NULL);	        
        else
            gtk_tree_view_column_set_cell_data_func(col, renderer,
                                                    treeview_helper_news_additional,
                                                    NULL, NULL);	        

        g_object_set(renderer, "wrap-mode", PANGO_WRAP_WORD, NULL);
        g_object_set(renderer, "wrap-width", 400, NULL);
        g_object_set(renderer, "yalign", 0.0, NULL);
    }
}
Exemplo n.º 6
0
static void createTab(char *name)
{
	logInfo("Creating IRC console tab '%s'", name);

	char *dupname = strdup(name);

	// vertical layout
	GtkWidget *vLayout = gtk_vbox_new(false, 1);

	// scroll
	GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(vLayout), GTK_WIDGET(scroll));

	GtkWidget *input = gtk_entry_new();
	GtkRcStyle *style = gtk_widget_get_modifier_style(GTK_WIDGET(input));
	PangoFontDescription *font = pango_font_description_from_string("Monospace Normal");
	style->font_desc = font;
	gtk_widget_modify_style(GTK_WIDGET(input), style);

	gtk_container_add(GTK_CONTAINER(vLayout), GTK_WIDGET(input));
	g_signal_connect(GTK_OBJECT(input), "activate", GTK_SIGNAL_FUNC(inputActivate), dupname);
	gtk_box_set_child_packing(GTK_BOX(vLayout), GTK_WIDGET(input), false, true, 0, GTK_PACK_END);

	// list
	GtkWidget *list = gtk_tree_view_new();
	gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(list));

	// list columns
	gtk_tree_view_append_column(GTK_TREE_VIEW(list), gtk_tree_view_column_new_with_attributes("Timestamp", gtk_cell_renderer_text_new(), "text", ROW_TIME, NULL));
	GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
	GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", ROW_MESSAGE, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
	gtk_tree_view_column_set_cell_data_func(column, renderer, &formatMessageCell, NULL, NULL);

	// create store
	GtkListStore *store = gtk_list_store_new(N_ROWS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
	gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));

	GtkWidget *title = gtk_label_new(name);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), GTK_WIDGET(vLayout), GTK_WIDGET(title));

	IrcConsoleTab *tab = ALLOCATE_OBJECT(IrcConsoleTab);
	g_object_ref(G_OBJECT(list));
	tab->lines = 0;
	tab->list = list;
	tab->store = store;

	g_hash_table_insert(tabs, dupname, tab);

	gtk_widget_show_all(GTK_WIDGET(notebook));
}
Exemplo n.º 7
0
static GtkTreeView*	ug_selector_view_new (const gchar* title, gboolean active_toggled)
{
	GtkTreeView*		view;
	GtkCellRenderer*	renderer;
	GtkTreeViewColumn*	column;

	view = (GtkTreeView*) gtk_tree_view_new ();
//	gtk_tree_view_set_fixed_height_mode (view, TRUE);
	// UgSelectorItem.mark
	renderer = gtk_cell_renderer_toggle_new ();
	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_title (column, "M");
	gtk_tree_view_column_pack_start (column, renderer, TRUE);
	gtk_tree_view_column_set_cell_data_func (column, renderer,
			col_set_toggle, NULL, NULL);
	gtk_tree_view_column_set_resizable (column, FALSE);
	gtk_tree_view_column_set_alignment (column, 0.5);
	gtk_tree_view_column_set_min_width (column, 15);
//	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
	gtk_tree_view_append_column (view, column);
	if (active_toggled) {
		g_signal_connect (renderer, "toggled",
				G_CALLBACK (on_cell_toggled), view);
	}
	// UgSelectorItem.uri
	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_title (column, title);
	gtk_tree_view_column_pack_start (column, renderer, TRUE);
	gtk_tree_view_column_set_cell_data_func (column, renderer,
			col_set_uri, NULL, NULL);
	gtk_tree_view_column_set_resizable (column, TRUE);
//	gtk_tree_view_column_set_expand (column, TRUE);
//	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
	gtk_tree_view_append_column (view, column);

	gtk_widget_show (GTK_WIDGET (view));
	return view;
}
Exemplo n.º 8
0
static void
gitg_window_parser_finished(GtkBuildable *buildable, GtkBuilder *builder)
{
	if (parent_iface.parser_finished)
		parent_iface.parser_finished(buildable, builder);

	// Store widgets
	GitgWindow *window = GITG_WINDOW(buildable);
	
	window->priv->vpaned_main = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_main"));
	window->priv->hpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "hpaned_commit"));
	window->priv->vpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_commit"));
	
	window->priv->notebook_main = GTK_NOTEBOOK(gtk_builder_get_object(builder, "notebook_main"));
	window->priv->tree_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tree_view_rv"));
	window->priv->statusbar = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar"));
	window->priv->revision_view = GITG_REVISION_VIEW(gtk_builder_get_object(builder, "revision_view"));
	window->priv->revision_tree_view = GITG_REVISION_TREE_VIEW(gtk_builder_get_object(builder, "revision_tree_view"));
	window->priv->commit_view = GITG_COMMIT_VIEW(gtk_builder_get_object(builder, "hpaned_commit"));

	restore_state(window);

	window->priv->edit_group = GTK_ACTION_GROUP(gtk_builder_get_object(builder, "action_group_menu_edit"));

	GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "rv_column_subject"));
	
	window->priv->renderer_path = GITG_CELL_RENDERER_PATH(gtk_builder_get_object(builder, "rv_renderer_subject"));
	gtk_tree_view_column_set_cell_data_func(col, GTK_CELL_RENDERER(window->priv->renderer_path), (GtkTreeCellDataFunc)on_renderer_path, window, NULL);
	
	GtkRecentFilter *filter = gtk_recent_filter_new();
	gtk_recent_filter_add_group(filter, "gitg");

	GtkRecentChooser *chooser = GTK_RECENT_CHOOSER(gtk_builder_get_object(builder, "RecentOpenAction"));
	gtk_recent_chooser_add_filter(chooser, filter);

	// Intialize branches
	build_branches_combo(window, builder);

	// Create search entry
	build_search_entry(window, builder);
	
	gtk_builder_connect_signals(builder, window);

	// Connect signals
	GtkTreeSelection *selection = gtk_tree_view_get_selection(window->priv->tree_view);
	g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), window);
	g_signal_connect(window->priv->revision_view, "parent-activated", G_CALLBACK(on_parent_activated), window);
	
	g_signal_connect(window->priv->tree_view, "motion-notify-event", G_CALLBACK(on_tree_view_motion), window);
	g_signal_connect(window->priv->tree_view, "button-release-event", G_CALLBACK(on_tree_view_button_release), window);
}
Exemplo n.º 9
0
GtkWidget *hview_get_domain_window(HviewWidgetsT *w)
{
	GtkWidget		*window;
	GtkCellRenderer		*renderer;
	GtkTreeViewColumn	*col;

	window = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

	gtk_widget_set_size_request(GTK_WIDGET(window),
				    175,
				    HVIEW_TREE_WINDOW_HEIGHT);

	w->domain_view = gtk_tree_view_new();

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(
							w->domain_view),
						    VOH_LIST_COLUMN_NAME,
						    HVIEW_DOMAIN_COLUMN_TITLE,
						    renderer,
						    "text",
						    VOH_LIST_COLUMN_NAME, NULL);
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->domain_view),
				       VOH_LIST_COLUMN_NAME);
	gtk_tree_view_column_set_cell_data_func(col, renderer,
						hview_tree_cell_func,
						NULL, NULL);

	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(
							w->domain_view),
						    VOH_LIST_COLUMN_ICON,
						    NULL,
						    renderer,
						    "pixbuf",
						    VOH_LIST_COLUMN_ICON, NULL);
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->domain_view),
				       VOH_LIST_COLUMN_ICON);

	g_signal_connect(G_OBJECT(w->domain_view), "row-activated",
			 G_CALLBACK(hview_domain_row_activated_call),
			 (gpointer) w);

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window),
					      w->domain_view);

	return window;
}
Exemplo n.º 10
0
static void
update_toggle_renderers (EmpathyIndividualLinker *self)
{
  EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);

  /* Re-setting the cell data func to the same function causes a refresh of the
   * entire column, ensuring that each toggle button is correctly active or
   * inactive. This is necessary because one Individual might appear multiple
   * times in the list (in different groups), so toggling one instance of the
   * Individual should toggle all of them. */
  gtk_tree_view_column_set_cell_data_func (priv->toggle_column,
      priv->toggle_renderer,
      (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL);
}
Exemplo n.º 11
0
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
  GtkTreeSelection *selection;
  GtkTreeModel *sort;
  GtkGesture *gesture;

  self->priv = gtk_app_chooser_widget_get_instance_private (self);

  gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);

  gtk_widget_init_template (GTK_WIDGET (self));

  /* Various parts of the GtkTreeView code need custom code to setup, mostly
   * because we lack signals to connect to, or properties to set.
   */
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
  gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
                                          self, NULL);

  sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
                                        COLUMN_NAME,
                                        GTK_SORT_ASCENDING);
  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
                                   COLUMN_NAME,
                                   gtk_app_chooser_sort_func,
                                   self, NULL);

  gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME);
  gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
                                       gtk_app_chooser_search_equal_func,
                                       NULL, NULL);

  gtk_tree_view_column_set_cell_data_func (self->priv->column,
					   self->priv->secondary_padding,
                                           padding_cell_renderer_func,
                                           NULL, NULL);

  self->priv->monitor = g_app_info_monitor_get ();
  g_signal_connect (self->priv->monitor, "changed",
		    G_CALLBACK (app_info_changed), self);

  gesture = gtk_gesture_multi_press_new ();
  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
  g_signal_connect (gesture, "pressed",
                    G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
  gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture));
}
Exemplo n.º 12
0
/* Add three columns to the GtkTreeView. All three of the columns will be
 * displayed as text, although one is a gboolean value and another is
 * an integer. */
static void
setup_tree_view (GtkWidget *treeview)
{
  GtkCellRenderer *renderer;
  GtkTreeViewColumn *column;
  
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes
                         ("Standard Colors", renderer, "text", COLOR, NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
  
  gtk_tree_view_column_set_cell_data_func (column, renderer,
                                           cell_data_func, NULL, NULL);

}
Exemplo n.º 13
0
static GtkCellRenderer *set_col_func(
	GtkTreeView *view,
	int col_id,
	GtkTreeCellDataFunc fn,
	gpointer dataptr,
	GDestroyNotify destroyfn)
{
	GtkTreeViewColumn *col = gtk_tree_view_get_column(view, col_id);
	GList *rs_list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
	if(rs_list == NULL) return NULL;
	GtkCellRenderer *r = GTK_CELL_RENDERER(g_list_first(rs_list)->data);
	g_list_free(rs_list);
	gtk_tree_view_column_set_cell_data_func(col, r, fn, dataptr, destroyfn);
	return g_object_ref(r);
}
Exemplo n.º 14
0
static GtkTreeViewColumn *
add_column(
	GtkTreeView *tv,
	const gchar *name,
	gint id,
	gfloat xalign,
	GtkTreeCellDataFunc cell_data_func,
	gint fg_col,
	gint bg_col)
{
    GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;

	renderer = create_cell_renderer(xalign);
	g_object_set(G_OBJECT(renderer),
		"foreground-set",	TRUE,
		"background-set",	TRUE,
		(void *) 0);

	if (cell_data_func) {
		column = gtk_tree_view_column_new_with_attributes(name, renderer,
					(void *) 0);
		gtk_tree_view_column_set_cell_data_func(column, renderer,
			cell_data_func, GUINT_TO_POINTER(id), NULL);
	} else {
		column = gtk_tree_view_column_new_with_attributes(name, renderer,
					"text", id, (void *) 0);
	}

	if (fg_col >= 0)
		gtk_tree_view_column_add_attribute(column, renderer,
			"foreground-gdk", fg_col);
	if (bg_col >= 0)
		gtk_tree_view_column_add_attribute(column, renderer,
			"background-gdk", bg_col);
			
	g_object_set(column,
		"fixed-width", 100,
		"min-width", 1,
		"reorderable", FALSE,
		"resizable", TRUE,
		"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
		(void *) 0);
	
    gtk_tree_view_append_column(tv, column);

	return column;
}
Exemplo n.º 15
0
static GtkWidget*
gwy_module_browser_construct(GtkWidget *parent)
{
    static const gchar *columns[] = {
        N_("Module"), N_("Version"), N_("Author"),
    };

    GtkWidget *tree;
    GtkListStore *store;
    GtkTreeSelection *selection;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    gsize i;

    store = gtk_list_store_new(MODEL_LAST,
                               G_TYPE_POINTER,
                               G_TYPE_POINTER,
                               G_TYPE_BOOLEAN);
    gwy_module_foreach((GHFunc)gwy_module_browser_store_module, store);
    _gwy_module_failure_foreach((GHFunc)gwy_module_browser_store_failure,
                                store);
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store),
                                    MODEL_NAME, compare_modules, NULL, NULL);
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), MODEL_NAME,
                                         GTK_SORT_ASCENDING);

    tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
    gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
    g_object_unref(store);

    for (i = 0; i < G_N_ELEMENTS(columns); i++) {
        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes(_(columns[i]),
                                                          renderer, NULL);
        gtk_tree_view_column_set_cell_data_func(column, renderer,
                                                gwy_module_browser_render,
                                                GUINT_TO_POINTER(i), NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
    }

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
    gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);

    g_signal_connect(tree, "cursor-changed",
                     G_CALLBACK(update_module_info_cb), parent);

    return tree;
}
Exemplo n.º 16
0
static GtkTreeViewColumn *
create_column(int column_id, const char *title, gfloat xalign,
	GtkCellRenderer *renderer, GtkTreeCellDataFunc cell_data_func)
{
    GtkTreeViewColumn *column;

	if (!renderer) {
		renderer = create_text_cell_renderer(xalign);
	}

	column = gtk_tree_view_column_new_with_attributes(title,
				renderer, (void *) 0);
	gtk_tree_view_column_set_cell_data_func(column, renderer,
		cell_data_func, uint_to_pointer(column_id), NULL);
	return column;
}
Exemplo n.º 17
0
static void create_view_and_model()
{
	GtkTreeViewColumn	*col;
	GtkCellRenderer		*renderer;

	bdk_window.view = gtk_tree_view_new();
	gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(bdk_window.view), TRUE);

	col = gtk_tree_view_column_new();

	gtk_tree_view_column_set_title(col, "Variable");

	gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), col);
	
	renderer = gtk_cell_renderer_text_new();

	gtk_tree_view_column_pack_start(col, renderer, TRUE);

	gtk_tree_view_column_add_attribute(col, renderer, "text", COL_VARIABLE);

	/* Columm #2 */

	col = gtk_tree_view_column_new();

	gtk_tree_view_column_set_title(col, "Value");

	gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), col);

	renderer = gtk_cell_renderer_text_new();

	gtk_tree_view_column_pack_start(col, renderer, TRUE);

	gtk_tree_view_column_add_attribute(col, renderer, "text", COL_VALUE);

	gtk_tree_view_column_set_cell_data_func(col, renderer, age_cell_data_func, NULL, NULL);

	create_and_fill_model();

	gtk_tree_view_set_model(GTK_TREE_VIEW(bdk_window.view), bdk_window.model);

	g_object_unref(bdk_window.model);

	gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(bdk_window.view)), GTK_SELECTION_NONE);

	g_signal_connect(bdk_window.view, "row-activated", (GCallback) view_onRowActivated, NULL);

}
Exemplo n.º 18
0
GtkWidget *sigview_init(void)
{
	GtkWidget *sw, *tv;
	GtkTreeViewColumn *col;
	GtkCellRenderer *cel;

	sw = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
				GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
	tv = gtk_tree_view_new();
	gtk_container_add(GTK_CONTAINER(sw), tv);
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv), FALSE);
	g_object_set(G_OBJECT(tv), "reorderable", TRUE, NULL);

	col = gtk_tree_view_column_new_with_attributes(NULL,
					gtk_cell_renderer_text_new(),
					"text", 0, "foreground", 1, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);

	cel = gtk_cell_renderer_signal_new();
	g_object_set(G_OBJECT(cel), "ypad", 1, NULL);
	g_signal_connect(tv, "scroll-event", G_CALLBACK(do_scroll_event), cel);
	g_signal_connect(tv, "button-press-event", G_CALLBACK(do_button_event), cel);
	g_signal_connect(tv, "button-release-event", G_CALLBACK(do_button_event), cel);
	col = gtk_tree_view_column_new();
	g_object_set_data(G_OBJECT(tv), "signalcol", col);
	g_object_set_data(G_OBJECT(tv), "signalcel", cel);
	gtk_tree_view_column_pack_start(col, cel, TRUE);
	gtk_tree_view_column_set_cell_data_func(col, cel, format_func,
					NULL, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
	g_signal_connect_swapped(col, "notify::width",
					G_CALLBACK(col_resized), tv);

	siglist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
					G_TYPE_INT);
	gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(siglist));

	GtkObject *pan = gtk_adjustment_new(0, 0, 0, 1, 1, 1);
	g_object_set_data(G_OBJECT(tv), "hadj", pan);
	gtk_range_set_adjustment(GTK_RANGE(GTK_SCROLLED_WINDOW(sw)->hscrollbar),
				GTK_ADJUSTMENT(pan));
	g_signal_connect(pan, "value-changed", G_CALLBACK(pan_changed), tv);
	
	return sw;
}
Exemplo n.º 19
0
static inline void
gwy_graph_data_pack_renderer(GwyGraphData *graph_data,
                             GtkTreeViewColumn *column,
                             gint id)
{
    GtkCellRenderer *renderer;

    renderer = gtk_cell_renderer_text_new();
    gtk_cell_renderer_text_set_fixed_height_from_font
                                        (GTK_CELL_RENDERER_TEXT(renderer), 1);
    g_object_set(renderer, "xalign", 1.0, NULL);
    if (id)
        g_object_set_qdata(G_OBJECT(renderer), quark_id, GINT_TO_POINTER(id));

    gtk_tree_view_column_pack_start(column, renderer, TRUE);
    gtk_tree_view_column_set_cell_data_func(column, renderer,
                                            render_data, graph_data, NULL);
}
Exemplo n.º 20
0
GtkWidget* create_hotkey_editor(void)
{
	GtkWidget *hotkey_tree_view = NULL;
	GtkCellRenderer *renderer = NULL;
	GtkListStore  *model = NULL;
	GtkTreeViewColumn *column = NULL;
	GtkTreeIter iter = {0};

	/* create a tree view */
	hotkey_tree_view = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(hotkey_tree_view), FALSE);
	g_signal_connect (hotkey_tree_view, "button-press-event", G_CALLBACK (start_editing_cb), NULL);
	g_signal_connect (hotkey_tree_view, "row-activated", G_CALLBACK (start_editing_keybd_cb), NULL);
	g_object_set(hotkey_tree_view, "visible", TRUE, NULL);

	/* create the Egg Cell Renderer and connect to signals */
	renderer = (GtkCellRenderer*) gtk_cell_renderer_accel_new ();
	g_object_set(renderer, "editable", TRUE, NULL);
	g_signal_connect (renderer, "accel-edited", G_CALLBACK (accel_edited_callback), hotkey_tree_view);
	g_signal_connect (renderer, "accel-cleared", G_CALLBACK (accel_cleared_callback), hotkey_tree_view);

	/* create a column and set the created renderer - append the same to the tree view */
	column = gtk_tree_view_column_new_with_attributes ("Shortcut", renderer, NULL);
	/* since it's a custom renderer, setting the data to the cell needs to be custom as well */
	gtk_tree_view_column_set_cell_data_func (column, renderer, accel_set_func, NULL, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW(hotkey_tree_view), column);

	/* create the list store for the tree */
	model = gtk_list_store_new (1, G_TYPE_POINTER);
	gtk_tree_view_set_model (GTK_TREE_VIEW (hotkey_tree_view), GTK_TREE_MODEL(model));

	gtk_list_store_append (model, &iter);
	gtk_list_store_set (model, &iter, HOTKEY_COLUMN, &app_hotkey, -1);

	/* The tree view has acquired its own reference to the
	*  model, so we can drop ours. That way the model will
	*  be freed automatically when the tree view is destroyed */
	g_object_unref (model);

	g_object_set(hotkey_tree_view, "visible", TRUE, NULL);

	return hotkey_tree_view;
}
Exemplo n.º 21
0
/*
 * Init book section view
 * Called from copy_entry in entry.c
 * Called from move_entry in entry.c
 */
static gboolean init_book_section_view(GtkTreeView *section_view)
{
	GtkTreeViewColumn *view_col = NULL;
	GtkCellRenderer *cell_rend = NULL;

	// Create section column
	view_col = gtk_tree_view_column_new();
	gtk_tree_view_column_set_title(view_col, "Section");
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(section_view), FALSE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(section_view), view_col);

	// Create section cell_rend with get_book_section_name callback
	cell_rend = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(view_col, cell_rend, TRUE);
	gtk_tree_view_column_set_cell_data_func
		(view_col, cell_rend, get_book_section_name, NULL, NULL);

	return TRUE;
} // Init book section view
Exemplo n.º 22
0
GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title,
				data_func_t data_func, unsigned int flags)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *col;
	double xalign = 0.0; /* left as default */
	PangoAlignment align;
	gboolean visible;

	align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
		(flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
		PANGO_ALIGN_CENTER;
	visible = !(flags & INVISIBLE);

	renderer = gtk_cell_renderer_text_new();
	col = gtk_tree_view_column_new();

	gtk_tree_view_column_set_title(col, title);
	if (!(flags & UNSORTABLE))
		gtk_tree_view_column_set_sort_column_id(col, index);
	gtk_tree_view_column_set_resizable(col, TRUE);
	gtk_tree_view_column_pack_start(col, renderer, TRUE);
	if (data_func)
		gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL);
	else
		gtk_tree_view_column_add_attribute(col, renderer, "text", index);
	gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
	switch (align) {
	case PANGO_ALIGN_LEFT:
		xalign = 0.0;
		break;
	case PANGO_ALIGN_CENTER:
		xalign = 0.5;
		break;
	case PANGO_ALIGN_RIGHT:
		xalign = 1.0;
		break;
	}
	gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
	gtk_tree_view_column_set_visible(col, visible);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
	return col;
}
Exemplo n.º 23
0
void EntityList_constructWindow(GtkWindow* main_window)
{
  ASSERT_MESSAGE(getEntityList().m_window == 0, "error");

  GtkWindow* window = create_persistent_floating_window("Entity List", main_window);  

  gtk_window_add_accel_group(window, global_accel);

  getEntityList().m_positionTracker.connect(window);
  

  getEntityList().m_window = window;

  {
    GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(scr));

    {
      GtkWidget* view = gtk_tree_view_new();
      gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);

      GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
      GtkTreeViewColumn* column = gtk_tree_view_column_new();
      gtk_tree_view_column_pack_start(column, renderer, TRUE);
      gtk_tree_view_column_set_cell_data_func(column, renderer, entitylist_treeviewcolumn_celldatafunc, 0, 0);

      GtkTreeSelection* select = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
      gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);

      g_signal_connect(G_OBJECT(view), "row_expanded", G_CALLBACK(entitylist_treeview_row_expanded), 0);
      g_signal_connect(G_OBJECT(view), "row_collapsed", G_CALLBACK(entitylist_treeview_rowcollapsed), 0);

      gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);

      gtk_widget_show(view);
      gtk_container_add (GTK_CONTAINER(scr), view);
      getEntityList().m_tree_view = GTK_TREE_VIEW(view);
    }
  }

  EntityList_ConnectSignals(getEntityList().m_tree_view);
  AttachEntityTreeModel();
}
Exemplo n.º 24
0
GtkWidget *hview_get_detail_window(HviewWidgetsT *w, gint page)
{
	GtkWidget		*window;
	GtkCellRenderer		*renderer;
	GtkTreeViewColumn	*col;
	GtkWidget		*view;

	window = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window),
				       GTK_POLICY_AUTOMATIC,
				       GTK_POLICY_AUTOMATIC);

//	gtk_widget_set_size_request(GTK_WIDGET(window),
//				    HVIEW_DETAIL_WINDOW_WIDTH,
//				    HVIEW_DETAIL_WINDOW_HEIGHT);

	w->tab_views[page].detail_view = view = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
						    -1,
						    NULL,
						    renderer,
						    "text", 0, NULL);
	col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0);
	gtk_tree_view_column_set_cell_data_func(col, renderer,
						hview_detail_cell_func,
						NULL, NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
						    -1,
						    NULL,
						    renderer,
						    "text", 1, NULL);

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window),
					      view);

	return window;
}
Exemplo n.º 25
0
/**
 * Add a column to the GtkTreeView.
 *
 * This function adds a column to the treeview.
 *
 * @param tree The GtkTreeView which will have a new column appended.
 * @param column_id The numerical tag for this column.
 * @param title The title displayed in the column header.
 * @param xalign A number between 0.0 (left) and 1.0 (right)
 * horizontal alignment.
 * @param cell_data_func The function which will render that data
 * to show in the cell.  If, NULL gtk will try to render the data
 * as appropriate for the type.
 *
 */
static void
add_column(
    GtkTreeView *tv,
	gint column_id,
	const gchar *title,
	gfloat xalign,
	GtkTreeIterCompareFunc sortfunc,
	GtkTreeCellDataFunc cell_data_func)
{
    GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;

	g_assert(column_id >= 0);
	g_assert(column_id <= c_us_num);
	g_assert(tv);

	renderer = gtk_cell_renderer_text_new();
   	column = gtk_tree_view_column_new_with_attributes(title, renderer,
				(void *) 0);
	gtk_tree_view_column_set_cell_data_func(column, renderer,
			cell_data_func, GINT_TO_POINTER(column_id), NULL);

	g_object_set(renderer,
		"xalign", xalign,
		"xpad", GUI_CELL_RENDERER_XPAD,
		"ypad", GUI_CELL_RENDERER_YPAD,
		(void *) 0);
	g_object_set(column,
		"fixed-width", 1,
		"min-width", 1,
		"resizable", TRUE,
		"reorderable", TRUE,
		"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
		(void *) 0);
   	gtk_tree_view_column_set_sort_column_id(column, column_id);
    gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column);
	gtk_tree_sortable_set_sort_func(
		GTK_TREE_SORTABLE(gtk_tree_view_get_model(tv)),
		column_id, sortfunc, NULL, NULL);
}
Exemplo n.º 26
0
static void create_column(GtkWidget* tree , FxMain* UNUSED(fxmain))
{
	GtkCellRenderer* renderer;
	GtkTreeViewColumn *col , *col0;

	renderer = gtk_cell_renderer_pixbuf_new();
	col = gtk_tree_view_column_new(); 
    gtk_tree_view_column_pack_start(col, renderer , FALSE);
	gtk_tree_view_column_add_attribute(col, renderer, "pixbuf", B_PIXBUF_COL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col);

    renderer = gtk_cell_renderer_text_new();
    col0 = gtk_tree_view_column_new(); 
    gtk_tree_view_column_pack_start(col0, renderer , FALSE);
	gtk_tree_view_column_set_cell_data_func(col0
										  , renderer
										  , text_cell_data_func
										  , NULL
										  , NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0);

}
Exemplo n.º 27
0
void
search_preferences_initialize_setting_treeview(GtkWidget *dialog)
{
	GtkTreeView *view;
	GtkTreeStore *store;	
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
		
	view = GTK_TREE_VIEW (sr_get_gladewidget(SETTING_PREF_TREEVIEW)->widget);
	store = gtk_tree_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN);
	gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
	gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view),
					     GTK_SELECTION_SINGLE);

	renderer = gtk_cell_renderer_toggle_new ();
	column = gtk_tree_view_column_new_with_attributes (_("Default"),
														renderer,
								   						"active",
														PREF_DEFAULT_COLUMN,
														NULL);
	g_signal_connect (renderer, "toggled",
						  G_CALLBACK (on_search_preferences_treeview_enable_toggle), NULL);
	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
	gtk_tree_view_append_column (view, column);
	
	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (_("Name"),
														renderer, 
														"text", 
														PREF_NAME_COLUMN, 
														NULL);
	g_signal_connect (view, "row-activated",
						  G_CALLBACK (on_search_preferences_row_activated), renderer);
	gtk_tree_view_column_set_cell_data_func (column, renderer,
					on_search_preferences_colorize_setting, NULL, NULL);
	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
	gtk_tree_view_append_column (view, column);
}
Exemplo n.º 28
0
/* sortcolidx == -1 means 'sortcolidx = colidx' */
static void
append_col (GtkTreeView * treeview, const char *label, int colidx,
	    int sortcolidx, gint maxwidth)
{
	GtkTreeViewColumn *col;
	GtkCellRenderer *renderer;

	renderer = gtk_cell_renderer_text_new ();
	g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END,
		      NULL);

	col = gtk_tree_view_column_new_with_attributes (label, renderer, "text",
							colidx, NULL);
	g_object_set (G_OBJECT (col), "resizable", TRUE, NULL);

	gtk_tree_view_column_set_sort_indicator (col, TRUE);

	if (sortcolidx == -1)
		sortcolidx = colidx;
	gtk_tree_view_column_set_sort_column_id (col, sortcolidx);
	gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);

	if (maxwidth) {
		gtk_tree_view_column_set_fixed_width (col, maxwidth);
		gtk_tree_view_column_set_expand (col, FALSE);
	} else
		gtk_tree_view_column_set_expand (col, TRUE);

	gtk_tree_view_column_set_cell_data_func (col, renderer,
						 (GtkTreeCellDataFunc)
						 treecell_func, NULL, NULL);

	gtk_tree_view_append_column (treeview, col);

	gtk_tree_view_columns_autosize (treeview);
	gtk_tree_view_set_fixed_height_mode (treeview, TRUE);
}
Exemplo n.º 29
0
static void fx_many_create_all_column(FxMany* fxmany)
{
	GtkCellRenderer* renderer;
	GtkTreeViewColumn *col , *col1;
	GtkWidget* tree = fxmany->tree;

	renderer = gtk_cell_renderer_toggle_new();
	g_signal_connect(renderer , "toggled" , G_CALLBACK(fx_many_item_toggled) , fxmany);
	col = gtk_tree_view_column_new();
	gtk_tree_view_column_pack_start(col , renderer , TRUE);
	gtk_tree_view_column_add_attribute(col, renderer, "active", S_CHECK_COL);
	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col)
								   , GTK_TREE_VIEW_COLUMN_FIXED);
	gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 40);
	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (col), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree) , col);

	renderer = gtk_cell_renderer_pixbuf_new();

	GtkTreeViewColumn* col0 = gtk_tree_view_column_new(); 
    gtk_tree_view_column_pack_start(col0, renderer , FALSE);
	gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", S_PIXBUF_COL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0);

    renderer = gtk_cell_renderer_text_new();
    col1 = gtk_tree_view_column_new(); 
    gtk_tree_view_column_pack_start(col1, renderer , FALSE);
	gtk_tree_view_column_set_cell_data_func(col1
										  , renderer
										  , fx_many_text_cell_data_func
										  , NULL
										  , NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col1);
	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col)
								   , GTK_TREE_VIEW_COLUMN_FIXED);

}
Exemplo n.º 30
0
/**
 * query_favorite_selector_new
 *
 * Returns: a new #GtkWidget
 */
GtkWidget *
query_favorite_selector_new (TConnection *tcnc)
{
	QueryFavoriteSelector *tsel;
	GdaTreeManager *manager;

	g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
	tsel = QUERY_FAVORITE_SELECTOR (g_object_new (QUERY_FAVORITE_SELECTOR_TYPE, NULL));

	tsel->priv->tcnc = g_object_ref (tcnc);
	g_signal_connect (t_connection_get_favorites (tsel->priv->tcnc), "favorites-changed",
			  G_CALLBACK (favorites_changed_cb), tsel);
	
	/* create tree managers */
	tsel->priv->tree = gda_tree_new ();
	manager = mgr_favorites_new (tcnc, T_FAVORITES_QUERIES, ORDER_KEY_QUERIES);
        gda_tree_add_manager (tsel->priv->tree, manager);
	g_object_unref (manager);

	/* update the tree's contents */
	if (! gda_tree_update_all (tsel->priv->tree, NULL)) {
		if (tsel->priv->idle_update_favorites == 0)
			tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel);
	}

	/* header */
	GtkWidget *label;
	gchar *str;
	str = g_strdup_printf ("<b>%s</b>", _("Favorites"));
	label = gdaui_bar_new (str);
	g_free (str);
	gdaui_bar_set_icon_from_resource (GDAUI_BAR (label), "/images/gda-browser-bookmark.png");
        gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0);
        gtk_widget_show (label);

	/* tree model */
	GtkTreeModel *model;
	GtkWidget *treeview;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;

	model = gdaui_tree_store_new (tsel->priv->tree, 7,
				      G_TYPE_INT, MGR_FAVORITES_POSITION_ATT_NAME,
				      G_TYPE_OBJECT, "icon",
				      G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME,
				      G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME,
				      G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME,
				      G_TYPE_STRING, MGR_FAVORITES_NAME_ATT_NAME,
				      G_TYPE_STRING, "summary");
	treeview = ui_make_tree_view (model);
	tsel->priv->treeview = treeview;
	g_object_unref (model);

	/* icon */
	column = gtk_tree_view_column_new ();

	renderer = gtk_cell_renderer_pixbuf_new ();
	gtk_tree_view_column_pack_start (column, renderer, FALSE);
	gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON);
	g_object_set ((GObject*) renderer, "yalign", 0., NULL);

	/* text */
	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column, renderer, TRUE);
	gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) cell_data_func,
						 NULL, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
	
	/* scrolled window packing */
	GtkWidget *sw;
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
					     GTK_SHADOW_ETCHED_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
					GTK_POLICY_NEVER,
					GTK_POLICY_AUTOMATIC);
	gtk_container_add (GTK_CONTAINER (sw), treeview);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);	

	gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0);
	gtk_widget_show_all (sw);
	g_signal_connect (G_OBJECT (treeview), "row-activated",
			  G_CALLBACK (selection_changed_cb), tsel);
	g_signal_connect (G_OBJECT (treeview), "key-press-event",
			  G_CALLBACK (key_press_event_cb), tsel);
	g_signal_connect (G_OBJECT (treeview), "popup-menu",
			  G_CALLBACK (popup_menu_cb), tsel);
	g_signal_connect (G_OBJECT (treeview), "button-press-event",
			  G_CALLBACK (button_press_event_cb), tsel);

	/* DnD */
	gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table),
					      GDK_ACTION_COPY);
	gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK,
						dbo_table, G_N_ELEMENTS (dbo_table),
						GDK_ACTION_COPY | GDK_ACTION_MOVE);
	g_signal_connect (model, "drag-drop",
			  G_CALLBACK (tree_store_drag_drop_cb), tsel);
	g_signal_connect (model, "drag-can-drag",
			  G_CALLBACK (tree_store_drag_can_drag_cb), tsel);
	g_signal_connect (model, "drag-get",
			  G_CALLBACK (tree_store_drag_get_cb), tsel);

	return (GtkWidget*) tsel;
}