static void
preferences_languages_setup (EmpathyPreferences *preferences)
{
	EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
	GtkTreeView       *view;
	GtkListStore      *store;
	GtkTreeSelection  *selection;
	GtkTreeViewColumn *column;
	GtkCellRenderer   *renderer;
	guint              col_offset;

	view = GTK_TREE_VIEW (priv->treeview_spell_checker);

	store = gtk_list_store_new (COL_LANG_COUNT,
				    G_TYPE_BOOLEAN,  /* enabled */
				    G_TYPE_STRING,   /* code */
				    G_TYPE_STRING);  /* name */

	gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));

	selection = gtk_tree_view_get_selection (view);
	gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

	renderer = gtk_cell_renderer_toggle_new ();
	g_signal_connect (renderer, "toggled",
			  G_CALLBACK (preferences_languages_cell_toggled_cb),
			  preferences);

	column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
							   "active", COL_LANG_ENABLED,
							   NULL);

	gtk_tree_view_append_column (view, column);

	renderer = gtk_cell_renderer_text_new ();
	col_offset = gtk_tree_view_insert_column_with_attributes (view,
								  -1, _("Language"),
								  renderer,
								  "text", COL_LANG_NAME,
								  NULL);

	g_object_set_data (G_OBJECT (renderer),
			   "column", GINT_TO_POINTER (COL_LANG_NAME));

	column = gtk_tree_view_get_column (view, col_offset - 1);
	gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
	gtk_tree_view_column_set_resizable (column, FALSE);
	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);

	g_object_unref (store);
}
Exemplo n.º 2
0
void
glade_gtk_treeview_set_child_property (GladeWidgetAdaptor * adaptor,
                                       GObject * container,
                                       GObject * child,
                                       const gchar * property_name,
                                       const GValue * value)
{
  if (strcmp (property_name, "position") == 0)
    {

      gtk_tree_view_remove_column (GTK_TREE_VIEW (container),
                                   GTK_TREE_VIEW_COLUMN (child));
      gtk_tree_view_insert_column (GTK_TREE_VIEW (container),
                                   GTK_TREE_VIEW_COLUMN (child),
                                   g_value_get_int (value));
    }
  else
    /* Chain Up */
    GWA_GET_CLASS
        (GTK_TYPE_CONTAINER)->child_set_property (adaptor,
                                                  container, child,
                                                  property_name, value);
}
Exemplo n.º 3
0
/**
 * Triggered when user clicks on a column header.  Create and pop up a
 * menu to allow CSV config change.
 *
 * \param button	Button placed at the title column.
 * \param ev		Not used.
 * \param no_column	Position of the column.
 *
 * \return		FALSE
 */
gboolean csv_import_header_on_click ( GtkWidget * button, gint *no_column )
{
    GtkWidget * menu, * col;

    col = g_object_get_data ( G_OBJECT ( button ), "column" );

    menu = csv_import_fields_menu ( GTK_TREE_VIEW_COLUMN ( col ),
				    GPOINTER_TO_INT ( no_column ),
				    g_object_get_data ( G_OBJECT(col), "assistant" ) );
    gtk_menu_popup ( GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
		     gtk_get_current_event_time());

    return FALSE;
}
Exemplo n.º 4
0
Arquivo: list.c Projeto: wareya/gzrt
/* Generate the tree view */
GtkWidget * 
gzrt_wmain_tree_generate ( MAINWIN * c )
{
    GtkWidget    * menu = menu_generate( c );
	GtkWidget    * tv = gtk_tree_view_new();
	GtkListStore * ls = gtk_list_store_new( sizeof(Cols) / sizeof(struct ColumnSpec), G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, -1 );
	
	/* Right click handler */
	g_signal_connect(tv, "button-press-event", G_CALLBACK(click_handler), (gpointer)menu);
	
	/* Create columns */
	for( int i = 0; i < sizeof(Cols) / sizeof(struct ColumnSpec); i++ )
	{
		GtkCellRenderer * r = gtk_cell_renderer_text_new();
		GtkTreeViewColumn * col;
		
		/* Font? */
		if( Cols[i].font )
			g_object_set( G_OBJECT(r), "font", FONT, NULL );
		
		gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(tv), 
		-1, Cols[i].title, r, "text", i, NULL );
		col = gtk_tree_view_get_column( GTK_TREE_VIEW(tv), i );
		gtk_tree_view_column_set_resizable( col, TRUE );
		
		if( i == 1 )
		gtk_tree_view_column_set_expand( GTK_TREE_VIEW_COLUMN(col), TRUE );
	}
	
	/* Generate data */
	for( int i = 0; i < z64fs_entries( c->z->fs ); i++ )
	{
		GtkTreeIter j;
		
		gtk_list_store_append( GTK_LIST_STORE(ls), &j );
		 
		for( int k = 0; k < sizeof(Cols) / sizeof(struct ColumnSpec); k++ )
		{
			char buffer[64];
			Cols[k].func( buffer, i, c );
			gtk_list_store_set( GTK_LIST_STORE(ls), &j, k, buffer, -1 );
		}
	}
	
	/* Set model */
	gtk_tree_view_set_model( GTK_TREE_VIEW(tv), GTK_TREE_MODEL(ls) );
	
	/* Return it */
	return tv;
}
Exemplo n.º 5
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.º 6
0
void init_left_tree(void)
{
	GtkTreeView *view = GTK_TREE_VIEW(tree1_w);
	GtkCellRenderer *renderer;
	GtkTreeSelection *sel;
	GtkTreeViewColumn *column;

	gtk_tree_view_set_model(view, model1);
	gtk_tree_view_set_headers_visible(view, TRUE);
	gtk_tree_view_set_rules_hint(view, FALSE);
	
	column = gtk_tree_view_column_new();
	gtk_tree_view_append_column(view, column);
	gtk_tree_view_column_set_title(column, _("Options"));

	renderer = gtk_cell_renderer_toggle_new();
	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
					renderer, FALSE);
	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
					    renderer,
					    "active", COL_BTNACT,
					    "inconsistent", COL_BTNINC,
					    "visible", COL_BTNVIS, 
					    "radio", COL_BTNRAD, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
					renderer, FALSE);	
	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
					    renderer,
					    "text", COL_OPTION,
					    "foreground-gdk",
					    COL_COLOR, NULL);

	sel = gtk_tree_view_get_selection(view);
	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
	gtk_widget_realize(tree1_w);
}
Exemplo n.º 7
0
// Create and bind the tree model to the tree view for the chapter list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_chapter_tree_model(signal_user_data_t *ud)
{
    GtkCellRenderer *cell;
    GtkTreeViewColumn *column;
    GtkListStore *treestore;
    GtkTreeView  *treeview;

    g_debug("bind_chapter_tree_model()\n");
    treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list"));
    treestore = gtk_list_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
    gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));

    cell = ghb_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(
                                    _("Index"), cell, "text", 0, NULL);
    gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));

    cell = ghb_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(
                                    _("Start"), cell, "text", 1, NULL);
    gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));

    cell = ghb_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(
                                    _("Duration"), cell, "text", 2, NULL);
    gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));

    cell = ghb_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(
                    _("Title"), cell, "text", 3, "editable", 4, NULL);
    gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));

    g_signal_connect(cell, "key-press-event", chapter_keypress_cb, ud);
    g_signal_connect(cell, "edited", chapter_edited_cb, ud);
    g_debug("Done\n");
}
Exemplo n.º 8
0
static void
refresh_log (GitLogPane *self)
{
	Git *plugin;
	GtkTreeView *log_view;
	GtkTreeViewColumn *graph_column;

	plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self)));
	log_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder,
	                                                  "log_view"));
	graph_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
	                                                             "graph_column"));

	/* Unref the previous command if it's still running. */
	if (self->priv->log_command)
		g_object_unref (self->priv->log_command);

	gtk_tree_view_set_model (log_view, NULL);

	/* We don't support filters for now */
	self->priv->log_command = git_log_command_new (plugin->project_root_directory,
	                                               self->priv->selected_branch,
	                                               self->priv->path,
	                                               NULL,
	                                               NULL,
	                                               NULL,
	                                               NULL,
	                                               NULL,
	                                               NULL);

	/* Hide the graph column if we're looking at the log of a path. The graph
	 * won't be correct in this case. */
	if (self->priv->path)
		gtk_tree_view_column_set_visible (graph_column, FALSE);
	else
		gtk_tree_view_column_set_visible (graph_column, TRUE);

	g_signal_connect_object (G_OBJECT (self->priv->log_command), "command-finished",
	                         G_CALLBACK (on_log_command_finished),
	                         self, 0);

	gtk_list_store_clear (self->priv->log_model);

	/* Show the loading spinner */
	git_log_pane_set_view_mode (self, LOG_VIEW_LOADING);

	anjuta_command_start (ANJUTA_COMMAND (self->priv->log_command));
}
Exemplo n.º 9
0
Arquivo: t24.cpp Projeto: ombt/ombt
/* Create the list of "messages" */
static GtkWidget *create_list( void )
{

    GtkWidget *scrolled_window;
    GtkWidget *tree_view;
    GtkListStore *model;
    GtkTreeIter iter;
    GtkCellRenderer *cell;
    GtkTreeViewColumn *column;

    int i;
   
    /* Create a new scrolled window, with scrollbars only if needed */
    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
				    GTK_POLICY_AUTOMATIC, 
				    GTK_POLICY_AUTOMATIC);
   
    model = gtk_list_store_new (1, G_TYPE_STRING);
    tree_view = gtk_tree_view_new ();
    gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
    gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model));
    gtk_widget_show (tree_view);
   
    /* Add some messages to the window */
    for (i = 0; i < 10; i++) {
        gchar *msg = g_strdup_printf ("Message #%d", i);
        gtk_list_store_append (GTK_LIST_STORE (model), &iter);
        gtk_list_store_set (GTK_LIST_STORE (model), 
	                    &iter,
                            0, msg,
	                    -1);
	g_free (msg);
    }
   
    cell = gtk_cell_renderer_text_new ();

    column = gtk_tree_view_column_new_with_attributes ("Messages",
                                                       cell,
                                                       "text", 0,
                                                       NULL);
  
    gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
	  		         GTK_TREE_VIEW_COLUMN (column));

    return scrolled_window;
}
Exemplo n.º 10
0
Arquivo: main.c Projeto: chipx86/gtk
/* Technically a list, but if we do go to 80 demos, we may want to move to a tree */
static GtkWidget *
create_tree (void)
{
  GtkTreeSelection *selection;
  GtkCellRenderer *cell;
  GtkWidget *tree_view;
  GtkTreeViewColumn *column;
  GtkTreeStore *model;
  GtkTreeIter iter;
  gint i;

  model = gtk_tree_store_new_with_types (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
  tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));

  gtk_tree_selection_set_type (GTK_TREE_SELECTION (selection),
			       GTK_TREE_SELECTION_SINGLE);
  gtk_widget_set_usize (tree_view, 200, -1);

  for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++)
    {
      gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);

      gtk_tree_store_set (GTK_TREE_STORE (model),
			  &iter,
			  TITLE_COLUMN, testgtk_demos[i].title,
			  FILENAME_COLUMN, testgtk_demos[i].filename,
			  FUNC_COLUMN, testgtk_demos[i].func,
			  ITALIC_COLUMN, FALSE,
			  -1);
    }

  cell = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("Widget",
						     cell,
						     "text", TITLE_COLUMN,
						     "italic", ITALIC_COLUMN,
						     NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
			       GTK_TREE_VIEW_COLUMN (column));

  g_signal_connect (selection, "selection-changed", selection_cb, model);
  g_signal_connect (tree_view, "button-press-event", G_CALLBACK (button_press_event_cb), model);

  return tree_view;
}
Exemplo n.º 11
0
// Create and bind the tree model to the tree view for the preset list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_presets_tree_model(signal_user_data_t *ud)
{
    GtkCellRenderer *cell;
    GtkTreeViewColumn *column;
    GtkTreeStore *treestore;
    GtkTreeView  *treeview;
    GtkTreeSelection *selection;
    GtkWidget *widget;
    GtkTargetEntry SrcEntry;
    SrcEntry.target = "DATA";
    SrcEntry.flags = GTK_TARGET_SAME_WIDGET;

    g_debug("bind_presets_tree_model()\n");
    treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list"));
    selection = gtk_tree_view_get_selection(treeview);
    treestore = gtk_tree_store_new(6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT,
                                  G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
    gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));

    cell = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(_("Preset Name"), cell,
        "text", 0, "weight", 1, "style", 2,
        "foreground", 3, "editable", 5, NULL);

    g_signal_connect(cell, "edited", preset_edited_cb, ud);

    gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
    gtk_tree_view_column_set_expand(column, TRUE);
    gtk_tree_view_set_tooltip_column(treeview, 4);

    gtk_tree_view_enable_model_drag_dest(treeview, &SrcEntry, 1,
                                            GDK_ACTION_MOVE);
    gtk_tree_view_enable_model_drag_source(treeview, GDK_BUTTON1_MASK,
                                            &SrcEntry, 1, GDK_ACTION_MOVE);

    g_signal_connect(treeview, "drag_data_received", presets_drag_cb, ud);
    g_signal_connect(treeview, "drag_motion", presets_drag_motion_cb, ud);
    g_signal_connect(treeview, "row_expanded", presets_row_expanded_cb, ud);
    g_signal_connect(treeview, "row_collapsed", presets_row_expanded_cb, ud);
    g_signal_connect(selection, "changed", presets_list_selection_changed_cb, ud);
    widget = GHB_WIDGET(ud->builder, "presets_remove");
    gtk_widget_set_sensitive(widget, FALSE);
    g_debug("Done\n");
}
/* create a profile list widget */
static GtkWidget*
create_profile_list (void)
{
  GtkTreeSelection *selection;
  GtkCellRenderer *cell;
  GtkWidget *tree_view;
  GtkTreeViewColumn *column;
  GtkListStore *model;

  model = gtk_list_store_new (COLUMN_LAST,
                              G_TYPE_STRING,
                              G_TYPE_OBJECT);

  tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
  //terminal_util_set_atk_name_description (tree_view, _("Profile list"), NULL);

  g_object_unref (G_OBJECT (model));

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));

  gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
                               GTK_SELECTION_MULTIPLE);

  refill_profile_treeview (tree_view);

  cell = gtk_cell_renderer_text_new ();

  g_object_set (G_OBJECT (cell),
                "xpad", 2,
                NULL);

  column = gtk_tree_view_column_new_with_attributes (NULL,
                                                     cell,
                                                     "text", COLUMN_NAME,
                                                     NULL);

  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
                               GTK_TREE_VIEW_COLUMN (column));

  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);

  return tree_view;
}
Exemplo n.º 13
0
void ListBox::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const char *text) {
  listBox->selection = -1;
  object->widget = gtk_scrolled_window_new(0, 0);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(object->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(object->widget), GTK_SHADOW_ETCHED_IN);
  gtk_widget_set_size_request(object->widget, width, height);

  lstring list;
  list.split("\t", text);

  GType *v = (GType*)malloc(list.size() * sizeof(GType));
  for(unsigned i = 0; i < list.size(); i++) v[i] = G_TYPE_STRING;
  listBox->store = gtk_list_store_newv(list.size(), v);
  free(v);

  object->subWidget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(listBox->store));
  gtk_container_add(GTK_CONTAINER(object->widget), object->subWidget);
  g_object_unref(G_OBJECT(listBox->store));

  //alternate color of each row if there is more than one column
  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(object->subWidget), list.size() >= 2);
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(object->subWidget), false);

  for(unsigned i = 0; i < list.size(); i++) {
    listBox->column[i].renderer = gtk_cell_renderer_text_new();
    listBox->column[i].column = gtk_tree_view_column_new_with_attributes(
      list[i], listBox->column[i].renderer, "text", i, (void*)0
    );
    listBox->column[i].label = gtk_label_new(list[i]);
    gtk_tree_view_column_set_widget(GTK_TREE_VIEW_COLUMN(listBox->column[i].column), listBox->column[i].label);
    gtk_tree_view_append_column(GTK_TREE_VIEW(object->subWidget), listBox->column[i].column);
    gtk_widget_show(listBox->column[i].label);
  }

  g_signal_connect_swapped(G_OBJECT(object->subWidget), "cursor-changed", G_CALLBACK(ListBox_change), (gpointer)this);
  g_signal_connect_swapped(G_OBJECT(object->subWidget), "row-activated", G_CALLBACK(ListBox_activate), (gpointer)this);

  if(parent.window->defaultFont) setFont(*parent.window->defaultFont);
  gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
  gtk_widget_show(object->subWidget);
  gtk_widget_show(object->widget);
}
Exemplo n.º 14
0
static void col_edited_helper(GtkCellRendererText *cell, gchar *path_string,
                              gchar *new_text, gpointer _s_model)
{
    GncOwner *owner;
    GtkTreeModel *s_model;
    GtkTreeIter s_iter;
    GncTreeViewOwnerColumnTextEdited col_edited_cb;
    GtkTreeViewColumn *col;

    col_edited_cb = g_object_get_data(G_OBJECT(cell),
                                      "column_edited_callback");
    col = GTK_TREE_VIEW_COLUMN(g_object_get_data(G_OBJECT(cell),
                               "column_view"));
    s_model = GTK_TREE_MODEL(_s_model);

    if (!gtk_tree_model_get_iter_from_string(s_model, &s_iter, path_string))
        return;

    owner = gnc_tree_view_owner_get_owner_from_iter(s_model, &s_iter);
    col_edited_cb(owner, col, new_text);
}
Exemplo n.º 15
0
void
list_store_set_sort_all(GtkWidget *tview)
{
  GList *list, *ptr;
  int i;
  GtkTreeViewColumn *column;

  list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview));

  if (list == NULL)
    return;

  for (ptr = list, i = 0; ptr; ptr = ptr->next, i++) {
    column = GTK_TREE_VIEW_COLUMN(ptr->data);
    gtk_tree_view_column_set_sort_column_id(column, i);
    gtk_tree_view_column_set_clickable(column, TRUE);
  }

  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE);
  g_list_free(list);
}
Exemplo n.º 16
0
void
skin_view_realize(GtkTreeView * treeview)
{
    GtkListStore *store;
    GtkTreeViewColumn *column;
    GtkCellRenderer *renderer;
    GtkTreeSelection *selection;

    gtk_widget_show_all(GTK_WIDGET(treeview));

    gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);

    store = gtk_list_store_new(SKIN_VIEW_N_COLS, GDK_TYPE_PIXBUF,
                               G_TYPE_STRING , G_TYPE_STRING);
    gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
    g_object_unref (store);

    column = gtk_tree_view_column_new();
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_spacing(column, 16);
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview),
                                GTK_TREE_VIEW_COLUMN(column));

    renderer = gtk_cell_renderer_pixbuf_new();
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_set_attributes(column, renderer, "pixbuf",
                                        SKIN_VIEW_COL_PREVIEW, NULL);

    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(column, renderer, TRUE);
    gtk_tree_view_column_set_attributes(column, renderer, "markup",
                                        SKIN_VIEW_COL_FORMATTEDNAME, NULL);

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
    gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);

    g_signal_connect(treeview, "cursor-changed",
                     G_CALLBACK(skin_view_on_cursor_changed), NULL);
}
static void
preferences_sound_setup (EmpathyPreferences *preferences)
{
	EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
	GtkTreeView *view;
	GtkListStore *store;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;

	view = GTK_TREE_VIEW (priv->treeview_sounds);

	store = gtk_list_store_new (COL_SOUND_COUNT,
				    G_TYPE_BOOLEAN, /* enabled */
				    G_TYPE_STRING,  /* name */
				    G_TYPE_STRING); /* key */

	gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));

	renderer = gtk_cell_renderer_toggle_new ();
	g_signal_connect (renderer, "toggled",
			  G_CALLBACK (preferences_sound_cell_toggled_cb),
			  preferences);

	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_pack_start (column, renderer, FALSE);
	gtk_tree_view_column_add_attribute (column, renderer,
					    "active", COL_SOUND_ENABLED);

	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column, renderer, FALSE);
	gtk_tree_view_column_add_attribute (column, renderer,
					    "text", COL_SOUND_NAME);

	gtk_tree_view_append_column (view, column);

	gtk_tree_view_column_set_resizable (column, FALSE);
	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);

	g_object_unref (store);
}
Exemplo n.º 18
0
static void
contact_widget_model_populate_columns (EmpathyContactWidget *information)
{
  GtkTreeView *view;
  GtkTreeModel *model;
  GtkTreeViewColumn *column;
  GtkCellRenderer  *renderer;
  guint col_offset;

  view = GTK_TREE_VIEW (information->treeview_groups);
  model = gtk_tree_view_get_model (view);

  renderer = gtk_cell_renderer_toggle_new ();
  g_signal_connect (renderer, "toggled",
      G_CALLBACK (contact_widget_cell_toggled), information);

  column = gtk_tree_view_column_new_with_attributes (_("Select"), renderer,
      "active", COL_ENABLED, NULL);

  gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_fixed_width (column, 50);
  gtk_tree_view_append_column (view, column);

  renderer = gtk_cell_renderer_text_new ();
  col_offset = gtk_tree_view_insert_column_with_attributes (view,
      -1, _("Group"),
      renderer,
      "text", COL_NAME,
      /* "editable", COL_EDITABLE, */
      NULL);

  g_object_set_data (G_OBJECT (renderer),
      "column", GINT_TO_POINTER (COL_NAME));

  column = gtk_tree_view_get_column (view, col_offset - 1);
  gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
  gtk_tree_view_column_set_resizable (column,FALSE);
  gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
Exemplo n.º 19
0
void clearlooks_treeview_get_header_index (GtkTreeView *tv, GtkWidget *header,
                                    gint *column_index, gint *columns,
                                    gboolean *resizable)
{
	GList *list, *list_start;
	*column_index = *columns = 0;
	list_start = list = gtk_tree_view_get_columns (tv);

	do
	{
		GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(list->data);
		if ( column->button == header )
		{
			*column_index = *columns;
			*resizable = column->resizable;
		}
		if ( column->visible )
			(*columns)++;
	} while ((list = g_list_next(list)));

	g_list_free (list_start);
}
Exemplo n.º 20
0
static void
reset_sort_order (FsearchApplicationWindow *win)
{
    g_assert (FSEARCH_WINDOW_IS_WINDOW (win));

    GList *list = gtk_tree_view_get_columns (GTK_TREE_VIEW (win->listview));
    GList *l;
    for (l = list; l != NULL; l = l->next)
    {
        GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN (l->data);
        if (l == list) {
            gtk_tree_view_column_set_sort_order (col, GTK_SORT_ASCENDING);
            gtk_tree_view_column_set_sort_indicator (col, TRUE);
            gtk_tree_view_column_set_sort_column_id (col, SORT_ID_NAME);
        }
        else {
            gtk_tree_view_column_set_sort_order (col, GTK_SORT_ASCENDING);
            gtk_tree_view_column_set_sort_indicator (col, FALSE);
        }
    }
    g_list_free (list);
}
Exemplo n.º 21
0
static void fx_many_create_selected_column(FxMany* fxmany)
{
	GtkCellRenderer* renderer;
	GtkTreeViewColumn *col0 , *col1;

	renderer = gtk_cell_renderer_pixbuf_new();

	col0 = gtk_tree_view_column_new(); 
    gtk_tree_view_column_pack_start(col0, renderer , FALSE);
	gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", C_PIXBUF_COL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), 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_add_attribute(col1, renderer, "text", C_NAME_COL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), col1);
	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col1)
								   , GTK_TREE_VIEW_COLUMN_FIXED);


}
Exemplo n.º 22
0
/* This used to get the column as an argument binded when the signal was
 * created, but it seems GTK now destroys and recreates them in some
 * circumstances. So bind the column description instead and search for the
 * column by its title.
 */
static gboolean
col_onButtonPressed(GtkButton * button,
                    GdkEventButton * event, trg_column_description *desc)
{
    if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
    	GtkTreeView *gtv = GTK_TREE_VIEW(gtk_widget_get_parent(GTK_WIDGET(button)));
        GList *cols = gtk_tree_view_get_columns(gtv);
        GList *li;
        for (li = cols; li; li = g_list_next(li)) {
        	GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(li->data);
        	if (!g_strcmp0(desc->header, gtk_tree_view_column_get_title(col))) {
        		view_popup_menu(button, event, col);
        		break;
        	}
        }
        g_list_free(cols);

        return TRUE;
    }

    return FALSE;
}
Exemplo n.º 23
0
void
list_store_set_sort_column(GtkWidget *tview, int col)
{
  GList *list, *ptr;

  list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview));

  if (list == NULL)
    return;

  ptr = g_list_nth(list, col);

  if (ptr) {
    GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(ptr->data);

    gtk_tree_view_column_set_sort_column_id(column, col);
    gtk_tree_view_column_set_clickable(column, TRUE);
  }

  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE);
  g_list_free(list);
}
Exemplo n.º 24
0
static void
view_column_model_get_value (GtkTreeModel *tree_model,
			     GtkTreeIter  *iter,
			     gint          column,
			     GValue       *value)
{
  ViewColumnModel *view_model = (ViewColumnModel *)tree_model;

  g_return_if_fail (column < 2);
  g_return_if_fail (view_model->stamp == iter->stamp);
  g_return_if_fail (iter->user_data != NULL);

  if (column == 0)
    {
      g_value_init (value, G_TYPE_STRING);
      g_value_set_string (value, gtk_tree_view_column_get_title (GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data)));
    }
  else
    {
      g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
      g_value_set_object (value, ((GList *)iter->user_data)->data);
    }
}
Exemplo n.º 25
0
/** initialize this module */
gboolean ui_setup_ledlist_init(
        )
{
        _ui = ui_builder("niftyconf-setup-ledlist.ui");


        /* set selection mode for tree */
		GtkTreeSelection *selection = gtk_tree_view_get_selection
                                    (GTK_TREE_VIEW(UI("treeview")));
        gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);

		/* connect signal handler */
		g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), NULL);
		
        /* initialize setup treeview */
        GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(UI("column_led"));
        GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
        gtk_tree_view_column_pack_start(col, renderer, TRUE);
        gtk_tree_view_column_add_attribute(col, renderer, "text",
                                           C_CHAIN_LED);

        return TRUE;
}
Exemplo n.º 26
0
GuTemplate* template_init (GtkBuilder* builder) {
    g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
    GuTemplate* t = g_new0 (GuTemplate, 1);
    t->templatewindow =
        GTK_WINDOW (gtk_builder_get_object (builder, "templatewindow"));
    t->templateview =
        GTK_TREE_VIEW (gtk_builder_get_object (builder, "template_treeview"));
    t->list_templates =
        GTK_LIST_STORE (gtk_builder_get_object (builder, "list_templates"));
    t->template_label =
        GTK_LABEL (gtk_builder_get_object (builder, "template_label"));
    t->template_add =
        GTK_WIDGET (gtk_builder_get_object (builder, "template_add"));
    t->template_remove =
        GTK_WIDGET (gtk_builder_get_object (builder, "template_remove"));
    t->template_open =
        GTK_WIDGET (gtk_builder_get_object (builder, "template_open"));
    t->template_render = GTK_CELL_RENDERER_TEXT (
            gtk_builder_get_object (builder, "template_renderer"));
    t->template_col = GTK_TREE_VIEW_COLUMN (
            gtk_builder_get_object (builder, "template_column"));
    gtk_tree_view_column_set_sort_column_id (t->template_col, 0);
    return t;
}
Exemplo n.º 27
0
void
glade_gtk_treeview_add_child (GladeWidgetAdaptor * adaptor,
                              GObject * container, GObject * child)
{
  GtkTreeView *view = GTK_TREE_VIEW (container);
  GtkTreeViewColumn *column;
  GladeWidget *gcolumn;

  if (!GTK_IS_TREE_VIEW_COLUMN (child))
    return;

  if (gtk_tree_view_get_fixed_height_mode (view))
    {
      gcolumn = glade_widget_get_from_gobject (child);
      glade_widget_property_set (gcolumn, "sizing", GTK_TREE_VIEW_COLUMN_FIXED);
      glade_widget_property_set_sensitive (gcolumn, "sizing", FALSE,
                                           INSENSITIVE_COLUMN_SIZING_MSG);
    }

  column = GTK_TREE_VIEW_COLUMN (child);
  gtk_tree_view_append_column (view, column);

  glade_gtk_cell_layout_sync_attributes (G_OBJECT (column));
}
Exemplo n.º 28
0
gboolean
qtcTreeViewCellIsLeftOfExpanderColumn(GtkTreeView *treeView,
                                      GtkTreeViewColumn *column)
{
    // check expander column
    GtkTreeViewColumn *expanderColumn =
        gtk_tree_view_get_expander_column(treeView);

    if (!expanderColumn || column == expanderColumn) {
        return false;
    } else {
        bool found = false;
        bool isLeft = false;
        // get all columns
        GList *columns = gtk_tree_view_get_columns(treeView);
        for (GList *child = columns;child;child = g_list_next(child)) {
            if (!GTK_IS_TREE_VIEW_COLUMN(child->data)) {
                continue;
            }
            GtkTreeViewColumn *childCol = GTK_TREE_VIEW_COLUMN(child->data);
            if (childCol == expanderColumn) {
                if (found) {
                    isLeft = true;
                }
            } else if (found) {
                break;
            } else if (column == childCol) {
                found = true;
            }
        }
        if (columns) {
            g_list_free(columns);
        }
        return isLeft;
    }
}
Exemplo n.º 29
0
/*
 * Public API 
 */
GtkWidget *
addressbook_window_new (boost::shared_ptr<Ekiga::ContactCore> core)
{
  AddressBookWindow *self = NULL;

  boost::signals::connection conn;

  GtkWidget *menu_bar = NULL;
  GtkWidget *frame = NULL;
  GtkWidget *vbox = NULL;
  GtkWidget *hpaned = NULL;

  GtkCellRenderer *cell = NULL;
  GtkTreeViewColumn *column = NULL;
  GtkTreeStore *store = NULL;

  self = (AddressBookWindow *) g_object_new (ADDRESSBOOK_WINDOW_TYPE, NULL);
  self->priv = new AddressBookWindowPrivate (core);

  gtk_window_set_title (GTK_WINDOW (self), _("Address Book"));
  gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER);

  gtk_window_set_icon_name (GTK_WINDOW (self), "x-office-address-book");

  /* Start building the window */
  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);

  /* The menu */
  menu_bar = gtk_menu_bar_new ();

  self->priv->accel = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
  g_object_unref (self->priv->accel);

  self->priv->menu_item_core = 
    gtk_menu_item_new_with_mnemonic (_("Address _Book"));
  gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar),
                         self->priv->menu_item_core);
  g_object_ref (self->priv->menu_item_core);
  conn = core->updated.connect (boost::bind (&on_core_updated,
                                           (gpointer) self));
  self->priv->connections.add (conn);
  on_core_updated (self); // This will add static and dynamic actions

  self->priv->menu_item_view = gtk_menu_item_new_with_mnemonic (_("_Action"));
  gtk_widget_set_sensitive (self->priv->menu_item_view, FALSE);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar),
                         self->priv->menu_item_view);
  g_object_ref (self->priv->menu_item_view);

  gtk_container_add (GTK_CONTAINER (vbox), menu_bar);
  gtk_box_set_child_packing (GTK_BOX (vbox), menu_bar,
                             FALSE, FALSE, 2, GTK_PACK_START);
  gtk_container_add (GTK_CONTAINER (self), vbox);


  /* A hpaned to put the list of Books and their content */
  hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
  gtk_container_set_border_width (GTK_CONTAINER (hpaned), 6);
  gtk_container_add (GTK_CONTAINER (vbox), hpaned);
  gtk_box_set_child_packing (GTK_BOX (vbox), hpaned,
                             TRUE, TRUE, 0, GTK_PACK_START);

  /* The store listing the Books */
  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  store = gtk_tree_store_new (NUM_COLUMNS,
                              G_TYPE_STRING,
                              G_TYPE_STRING,
                              G_TYPE_POINTER,
                              G_TYPE_OBJECT);
  self->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
  g_object_unref (store);
  gtk_container_add (GTK_CONTAINER (frame), self->priv->tree_view);
  gtk_widget_set_size_request (GTK_WIDGET (self->priv->tree_view), 185, -1);
  gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, TRUE);

  /* Several renderers for one column */
  column = gtk_tree_view_column_new ();
  cell = gtk_cell_renderer_pixbuf_new ();
  gtk_tree_view_column_pack_start (column, cell, FALSE);
  gtk_tree_view_column_add_attribute (column, cell,
                                      "icon-name", COLUMN_PIXBUF);

  cell = gtk_cell_renderer_text_new ();
  gtk_tree_view_column_pack_start (column, cell, FALSE);
  gtk_tree_view_column_set_attributes (column, cell,
                                       "text", COLUMN_NAME,
                                       NULL);

  gtk_tree_view_column_set_title (column, _("Category"));
  gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
  gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
                                   GTK_TREE_VIEW_COLUMN_AUTOSIZE);
  gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), true);
  gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->tree_view),
                               GTK_TREE_VIEW_COLUMN (column));


  self->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree_view));
  gtk_tree_selection_set_mode (GTK_TREE_SELECTION (self->priv->selection),
                               GTK_SELECTION_SINGLE);
  g_signal_connect (self->priv->selection, "changed",
                    G_CALLBACK (on_book_selection_changed), self);
  g_signal_connect (self->priv->tree_view, "event-after",
                    G_CALLBACK (on_book_clicked), self);

  /* The notebook containing the books */
  self->priv->notebook = gtk_notebook_new ();
  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE);
  g_signal_connect (self->priv->notebook, "realize",
                    G_CALLBACK (on_notebook_realize), self);
  gtk_paned_pack2 (GTK_PANED (hpaned), self->priv->notebook, TRUE, TRUE);

  conn = core->source_added.connect (boost::bind (&on_source_added, _1, (gpointer) self));
  self->priv->connections.add (conn);

  conn = core->book_updated.connect (boost::bind (&on_book_updated, _1, _2,
                                                (gpointer) self));
  self->priv->connections.add (conn);
  conn = core->book_added.connect (boost::bind (&on_book_added, _1, _2,
                                              (gpointer) self));
  self->priv->connections.add (conn);
  conn =
    core->book_removed.connect (boost::bind (&on_book_removed, _1, _2,
                                           (gpointer) self));
  self->priv->connections.add (conn);

  conn = core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self));
  self->priv->connections.add (conn);

  core->visit_sources (boost::bind (on_visit_sources, _1, (gpointer) self));

  return GTK_WIDGET (self);
}
Exemplo n.º 30
0
static void setup_view(GtkWidget* view)
{
    GtkListStore* store = gtk_list_store_new (23,
    G_TYPE_STRING,   /* 0 Country */
    G_TYPE_STRING,   /* 1 Good Name */
    GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */
    G_TYPE_STRING,   /* 3 User Comments */
    G_TYPE_STRING,   /* 4 File Name */
    G_TYPE_STRING,   /* 5 MD5 Hash */
    G_TYPE_STRING,   /* 6 CRC1 */
    G_TYPE_STRING,   /* 7 CRC2 */
    G_TYPE_STRING,   /* 8 Internal Name */
    G_TYPE_STRING,   /* 9 Save Type */
    G_TYPE_STRING,   /* 10 Players */
    G_TYPE_STRING,   /* 11 Size */
    G_TYPE_STRING,   /* 12 Compression */
    G_TYPE_STRING,   /* 13 Image Type */
    G_TYPE_STRING,   /* 14 CIC Chip */
    G_TYPE_STRING,   /* 15 Rumble */
    GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */
    GDK_TYPE_PIXBUF,
    GDK_TYPE_PIXBUF,
    GDK_TYPE_PIXBUF,
    GDK_TYPE_PIXBUF,
    GDK_TYPE_PIXBUF, /* 21 Flag */
    G_TYPE_POINTER,  /* 22 RCS Entry */
    -1);

    GtkCellRenderer* renderer;
    GtkTreeViewColumn* column;
    GtkWidget* item;
    char buffer[128];
    int i;
    unsigned char visible;

    /* Create country flag / string dual rendered cell. */
    renderer = gtk_cell_renderer_pixbuf_new();
    g_MainWindow.column[0] = gtk_tree_view_column_new();
    column = g_MainWindow.column[0];
    gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]); 
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21);
    g_object_set(renderer, "xpad", 5, NULL);
    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(column, renderer, TRUE);
    gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_reorderable(column, TRUE);
    gtk_tree_view_column_set_sort_column_id(column, 0);
    gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0);
    g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);

    renderer = gtk_cell_renderer_text_new();
    g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL);
    column = g_MainWindow.column[1];
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_reorderable(column, TRUE);
    gtk_tree_view_column_set_sort_column_id(column, 1);
    gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1);
    g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);

    /* Status stars. */
    g_MainWindow.column[2] = gtk_tree_view_column_new();
    column = g_MainWindow.column[2];
    gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]); 
    renderer = gtk_cell_renderer_pixbuf_new();
    g_object_set(renderer, "xpad", 2, NULL);
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
    for(i = 0; i < 5; ++i)
        {
        renderer = gtk_cell_renderer_pixbuf_new();
        gtk_tree_view_column_pack_start(column, renderer, FALSE);
        gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i);
        }
    renderer = gtk_cell_renderer_pixbuf_new();
    g_object_set(renderer, "xpad", 2, NULL);
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_reorderable(column, TRUE);
    gtk_tree_view_column_set_sort_column_id(column, 2);
    gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2);
    g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);

    for(i = 3; i < 16; ++i)
        {
        renderer = gtk_cell_renderer_text_new();
        g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL);
        column = g_MainWindow.column[i];
        gtk_tree_view_column_set_resizable(column, TRUE);
        gtk_tree_view_column_set_reorderable(column, TRUE);
        gtk_tree_view_column_set_sort_column_id(column, i);
        gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i);
        g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
        }

    renderer = gtk_cell_renderer_text_new ();
    g_MainWindow.column[16] = gtk_tree_view_column_new();
    column = g_MainWindow.column[16];
    gtk_tree_view_column_set_visible(column, FALSE);
    gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2);
    g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);

    gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));

    g_MainWindow.romHeaderMenu = gtk_menu_new();

    /* Toggle column visibility from config file, make menu. */
    for(i = 0; i < 16; ++i)
        {
        snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]);
        item = gtk_check_menu_item_new_with_mnemonic(buffer); 
        if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2)
             {
             visible = (i<5) ? TRUE: FALSE;
             config_put_bool(g_MainWindow.column_names[i][1], visible);
             }
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible); 
        gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible);
        gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item);
        g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i));
        }

    gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE);
    for(i = 0; i < 16; ++i)
        {
        if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i])))
            return;
        }
    gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE);
}