static void tree_config_make_columns(void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeView *view = GTK_TREE_VIEW(GET_WIDGET(TREE_CONFIGS));
// Current column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes( _("Open"),
renderer,
"text", COL_CURRENT,
NULL);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_append_column(view, column);
// Priority column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes( _("Priority"),
renderer,
"text", COL_PRIORITY,
NULL);
gtk_tree_view_column_set_min_width (column, 40);
gtk_tree_view_append_column(view, column);
// Priority column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes( _("Name"),
renderer,
"text", COL_NAME,
NULL);
gtk_tree_view_column_set_min_width (column, 60);
gtk_tree_view_append_column(view, column);
}
static void tree_buttons_make_columns(void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeView *view = GTK_TREE_VIEW(GET_WIDGET(TREEVIEW_BUTTONS_CONFIG));
// Property column
renderer = gtk_cell_renderer_text_new();
/* TRANSLATORS: Property is the title of a table column. Make it as short
* as possible. Abbreviate if necessary. It refers to a property that
* a certain group can have. */
column = gtk_tree_view_column_new_with_attributes( _("Property"),
renderer,
"text", COL_NAME,
NULL);
gtk_tree_view_column_set_min_width (column, 80);
gtk_tree_view_append_column(view, column);
// Value column
renderer = gtk_cell_renderer_text_new();
/* TRANSLATORS: Value is the title of a table column. Make it as short
* as possible. Abbreviate if necessary. It refers to the value that a
* certain property can have. For example, color can be a property and
* blue is one possible value. */
column = gtk_tree_view_column_new_with_attributes( _("Value"),
renderer,
"text", COL_PROPERTY,
NULL);
gtk_tree_view_column_set_min_width (column, 80);
gtk_tree_view_append_column(view, column);
}
static void
xfburn_directory_browser_init (XfburnDirectoryBrowser * browser)
{
GtkListStore *model;
GtkTreeViewColumn *column_file;
GtkCellRenderer *cell_icon, *cell_file;
GtkTreeSelection *selection;
GtkTargetEntry gte[] = { {"text/plain;charset=utf-8", 0, DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN} };
model = gtk_list_store_new (DIRECTORY_BROWSER_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE,
directory_tree_sortfunc, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (browser), GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (browser), TRUE);
column_file = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column_file, _("File"));
cell_icon = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column_file, cell_icon, FALSE);
gtk_tree_view_column_set_attributes (column_file, cell_icon, "pixbuf", DIRECTORY_BROWSER_COLUMN_ICON, NULL);
g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL);
cell_file = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column_file, cell_file, TRUE);
gtk_tree_view_column_set_attributes (column_file, cell_file, "text", DIRECTORY_BROWSER_COLUMN_FILE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (browser), column_file);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Size"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_HUMANSIZE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Type"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_TYPE, NULL);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 1);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 1);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 500);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 60);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (browser));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* set up DnD */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (browser), GDK_BUTTON1_MASK, gte,
G_N_ELEMENTS (gte), GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (browser), "drag-data-get", G_CALLBACK (cb_browser_drag_data_get), browser);
}
static void init_search_result( FindFile* data )
{
GtkTreeIter it;
GtkTreeViewColumn* col;
GtkCellRenderer* render;
gtk_tree_selection_set_mode( gtk_tree_view_get_selection((GtkTreeView*)data->result_view),
GTK_SELECTION_MULTIPLE );
data->result_list = gtk_list_store_new( N_RES_COLS,
GDK_TYPE_PIXBUF, /* icon */
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* dir */
G_TYPE_STRING, /* type */
G_TYPE_STRING, /* size */
G_TYPE_STRING, /* mtime */
G_TYPE_POINTER /* VFSFileInfo */ );
gtk_tree_view_set_model( (GtkTreeView*)data->result_view, (GtkTreeModel*)data->result_list );
g_object_unref( data->result_list );
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title( col, _("Name") );
render = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start( col, render, FALSE );
gtk_tree_view_column_set_attributes( col, render, "pixbuf", COL_ICON, NULL );
render = gtk_cell_renderer_text_new();
g_object_set( render, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
gtk_tree_view_column_pack_start( col, render, TRUE );
gtk_tree_view_column_set_attributes( col, render, "text", COL_NAME, NULL );
gtk_tree_view_column_set_expand ( col, TRUE );
gtk_tree_view_column_set_min_width( col, 200 );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
render = gtk_cell_renderer_text_new();
g_object_set( render, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
col = gtk_tree_view_column_new_with_attributes( _("Folder"), render, "text", COL_DIR, NULL );
gtk_tree_view_column_set_expand ( col, TRUE );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_column_set_min_width( col, 200 );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Size"), gtk_cell_renderer_text_new(), "text", COL_SIZE, NULL );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Type"), gtk_cell_renderer_text_new(), "text", COL_TYPE, NULL );
gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_FIXED );
gtk_tree_view_column_set_fixed_width ( col, 120 );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Last Modified"), gtk_cell_renderer_text_new(), "text", COL_MTIME, NULL );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
}
static GtkWidget *
banlist_treeview_new (GtkWidget *box)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeSelection *select;
GtkTreeViewColumn *col;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
MASK_COLUMN, _("Mask"),
FROM_COLUMN, _("From"),
DATE_COLUMN, _("Date"), -1);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), MASK_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_min_width (col, 300);
gtk_tree_view_column_set_sort_column_id (col, MASK_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), FROM_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, FROM_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), DATE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
gtk_widget_show (view);
return view;
}
// Create and bind the tree model to the tree view for the queue list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_queue_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell, *textcell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTargetEntry SrcEntry;
SrcEntry.target = "DATA";
SrcEntry.flags = GTK_TARGET_SAME_WIDGET;
g_debug("bind_queue_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "queue_list"));
selection = gtk_tree_view_get_selection (treeview);
treestore = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (column, _("Job Information"));
cell = gtk_cell_renderer_pixbuf_new();
g_object_set(cell, "yalign", 0.0, NULL);
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell, "icon-name", 0);
textcell = gtk_cell_renderer_text_new();
g_object_set(textcell, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(textcell, "wrap-width", 500, NULL);
gtk_tree_view_column_pack_start (column, textcell, TRUE);
gtk_tree_view_column_add_attribute (column, textcell, "markup", 1);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_max_width (column, 550);
cell = custom_cell_renderer_button_new();
g_object_set(cell, "yalign", 0.0, NULL);
column = gtk_tree_view_column_new_with_attributes(
_(""), cell, "icon-name", 2, NULL);
gtk_tree_view_column_set_min_width (column, 24);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
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(selection, "changed", queue_list_selection_changed_cb, ud);
g_signal_connect(cell, "clicked", queue_remove_clicked_cb, ud);
g_signal_connect(treeview, "size-allocate", queue_list_size_allocate_cb,
textcell);
g_signal_connect(treeview, "drag_data_received", queue_drag_cb, ud);
g_signal_connect(treeview, "drag_motion", queue_drag_motion_cb, ud);
// Work around silly treeview display bug. If the treeview
// hasn't been shown yet, the width request doesn't seem
// to work right. Cells get badly formatted.
GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
gtk_widget_show (widget);
gtk_widget_hide (widget);
}
static void
create_bidding_widget (window_board_t *win)
{
/*
GtkScrolledWindow *scroll = GTK_SCROLLED_WINDOW
(get_widget ("scrolledwindow2"));
GdkColor bg = { 0, 0.8*65535, 0.0, 0.0 };
gdk_colormap_alloc_color (gdk_colormap_get_system (), &bg, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (scroll), GTK_STATE_NORMAL, &bg);
*/
win->bidding = GTK_TREE_VIEW (get_widget ("treeview_bidding"));
//gtk_widget_modify_bg (GTK_WIDGET (bidding), GTK_STATE_NORMAL, &bg);
//gdk_window_set_background (gtk_tree_view_get_bin_window (bidding), &bidding_vuln);
win->bidding_store = gtk_list_store_new (8,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (win->bidding, GTK_TREE_MODEL (win->bidding_store));
#if GTK_CHECK_VERSION (2,12,0)
g_signal_connect (G_OBJECT (win->bidding), "query-tooltip",
G_CALLBACK (bidding_query_tooltip), win);
#endif
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5,
"cell-background", "yellow",
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
NULL);
char *dir[] = {"W", "N", "E", "S"};
int i;
for (i = 0; i < 4; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (_(dir[i]), renderer,
"markup", 2 * i, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_min_width (column, 36);
gtk_tree_view_column_set_alignment (column, 0.5);
//g_signal_connect_swapped (column, "clicked", G_CALLBACK (bidding_clicked), 0);
/*
win->bidding_label[i] = gtk_label_new (dir[i]);
//gtk_label_set_width_chars (win->bidding_label[i], 4);
gtk_label_set_ellipsize (win->bidding_label[i], PANGO_ELLIPSIZE_END);
gtk_tree_view_column_set_widget (column, win->bidding_label[i]);
gtk_widget_show (win->bidding_label[i]);
*/
gtk_tree_view_append_column (win->bidding, column);
win->bidding_column[i] = column;
}
gtk_container_forall (GTK_CONTAINER (win->bidding), (GtkCallback) create_bidding_widget_cb, win);
GdkColormap *cmap = gdk_colormap_get_system ();
gdk_colormap_alloc_color (cmap, &bidding_non_vuln, FALSE, TRUE);
gdk_colormap_alloc_color (cmap, &bidding_vuln, FALSE, TRUE);
}
static GtkWidget *
editlist_treeview_new (GtkWidget *box, char *title1, char *title2)
{
GtkWidget *scroll;
GtkListStore *store;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key_press_event",
G_CALLBACK (editlist_keypress), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(NAME_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), NAME_COLUMN,
title1, render,
"text", NAME_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(CMD_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), CMD_COLUMN,
title2, render,
"text", CMD_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), NAME_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_min_width (col, 100);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
gtk_widget_show_all (box);
return view;
}
// Create and bind the tree model to the tree view for the queue list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_queue_tree_model(signal_user_data_t *ud)
{
GtkCellRenderer *cell, *textcell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTargetEntry SrcEntry;
SrcEntry.target = "DATA";
SrcEntry.flags = GTK_TARGET_SAME_WIDGET;
g_debug("bind_queue_tree_model()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
selection = gtk_tree_view_get_selection(treeview);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Job Information"));
cell = gtk_cell_renderer_spinner_new();
gtk_tree_view_column_pack_start(column, cell, FALSE);
gtk_tree_view_column_add_attribute(column, cell, "active", 0);
gtk_tree_view_column_add_attribute(column, cell, "pulse", 4);
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", 1);
textcell = gtk_cell_renderer_text_new();
g_object_set(textcell, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(textcell, "wrap-width", 500, NULL);
gtk_tree_view_column_pack_start(column, textcell, TRUE);
gtk_tree_view_column_add_attribute(column, textcell, "markup", 2);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_max_width(column, 550);
g_signal_connect(treeview, "size-allocate", queue_list_size_allocate_cb,
textcell);
cell = custom_cell_renderer_button_new();
column = gtk_tree_view_column_new_with_attributes(
_(""), cell, "icon-name", 3, NULL);
gtk_tree_view_column_set_min_width(column, 24);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
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(selection, "changed", queue_list_selection_changed_cb, ud);
g_signal_connect(cell, "clicked", queue_remove_clicked_cb, ud);
g_signal_connect(treeview, "drag_data_received", queue_drag_cb, ud);
g_signal_connect(treeview, "drag_motion", queue_drag_motion_cb, ud);
}
static GtkWidget *
banlist_treeview_new (GtkWidget *box, banlist_info *banl)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeSelection *select;
GtkTreeViewColumn *col;
GtkTreeSortable *sortable;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_sortable_set_sort_func (sortable, DATE_COLUMN, banlist_date_sort, GINT_TO_POINTER (DATE_COLUMN), NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
TYPE_COLUMN, _("Type"),
MASK_COLUMN, _("Mask"),
FROM_COLUMN, _("From"),
DATE_COLUMN, _("Date"), -1);
g_signal_connect (G_OBJECT (view), "button-press-event", G_CALLBACK (banlist_button_pressed), NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), MASK_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_min_width (col, 100);
gtk_tree_view_column_set_sort_column_id (col, MASK_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), TYPE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, TYPE_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), FROM_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, FROM_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), DATE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, DATE_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (banlist_select_changed), banl);
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
gtk_widget_show (view);
return view;
}
static GtkTreeViewColumn *new_column(int type, int width, const char *title, ...){
GtkTreeViewColumn *col;
GtkCellRenderer *render=NULL;
col=gtk_tree_view_column_new();
switch(type){
case 0:
render=gtk_cell_renderer_text_new();
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 18
gtk_cell_renderer_set_padding(render, 1, 1);
gtk_cell_renderer_set_alignment(render, 1, 0.5);
#endif
break;
case 1:
render=gtk_cell_renderer_progress_new();
break;
case 2:
render=gtk_cell_renderer_pixbuf_new();
break;
default:
error("Invalid\n");
}
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_spacing(col, 2);
gtk_tree_view_column_set_alignment(col, 1);
gtk_tree_view_column_set_resizable(col, TRUE);
//gtk_tree_view_column_set_clickable(col, TRUE);
//gtk_tree_view_column_set_expand(col,FALSE);
if(width>0){//Adjustable columns
//Do not set min_width if set resizable.
//gtk_tree_view_column_set_min_width(col, width);
gtk_tree_view_column_set_expand(col,TRUE);
//resizable is not good if expand
gtk_tree_view_column_set_resizable(col, FALSE);
if(type==0){
g_object_set(G_OBJECT(render),"ellipsize",PANGO_ELLIPSIZE_START,NULL);
}
}else if(width<0){/*max width*/
gtk_tree_view_column_set_min_width(col,-width/10);
gtk_tree_view_column_set_max_width(col,-width);
}
gtk_tree_view_column_pack_start(col,render,TRUE);
va_list ap;
va_start(ap, title);
const char *att=NULL;
while((att=va_arg(ap, const char *))){
gtk_tree_view_column_add_attribute(col, render, att, va_arg(ap,int));
}
va_end(ap);
return col;
}
void create_column(void *view, int type,
char *title, int width)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
debug("create_column()");
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(title, renderer,
"text", type,
NULL);
gtk_tree_view_column_set_title(column, title);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_min_width(column, width);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_order(column, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
void list_init(void)
{
list.rows = 0;
int cols = COL_DIGESTS;
for (int i = 0; i < HASH_FUNCS_N; i++) {
if (!hash.funcs[i].supported)
continue;
list_priv.hash_cols[i] = cols;
cols = gtk_tree_view_insert_column_with_attributes(gui.treeview, -1,
hash.funcs[i].name, gtk_cell_renderer_text_new(),
"text", cols, NULL);
}
GType types[cols];
types[COL_STATUS] = G_TYPE_CHAR;
types[COL_ICON_NAME] = G_TYPE_STRING;
types[COL_PNAME] = G_TYPE_STRING;
types[COL_CHECK] = G_TYPE_STRING;
for (int i = COL_DIGESTS; i < cols; i++) {
types[i] = G_TYPE_STRING;
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview, i);
gtk_tree_view_column_set_resizable(col, true);
gtk_tree_view_column_set_min_width(col, 10);
}
gui.liststore = gtk_list_store_newv(cols, types);
gui.treemodel = GTK_TREE_MODEL(gui.liststore);
gtk_tree_view_set_model(gui.treeview, gui.treemodel);
const GtkTargetEntry targets[] = {
{ (char *)"text/uri-list", 0, 0 }
};
gtk_drag_dest_set(GTK_WIDGET(gui.treeview), GTK_DEST_DEFAULT_ALL, targets,
G_N_ELEMENTS(targets), GDK_ACTION_COPY);
}
static void
populate_jobs_list (PpJobsDialog *dialog)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkCellRenderer *title_renderer;
GtkTreeView *treeview;
treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "job-treeview");
renderer = gtk_cell_renderer_text_new ();
title_renderer = gtk_cell_renderer_text_new ();
/* Translators: Name of column showing titles of print jobs */
column = gtk_tree_view_column_new_with_attributes (_("Job Title"), title_renderer,
"text", JOB_TITLE_COLUMN, NULL);
g_object_set (G_OBJECT (title_renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_fixed_width (column, 180);
gtk_tree_view_column_set_min_width (column, 180);
gtk_tree_view_column_set_max_width (column, 180);
gtk_tree_view_append_column (treeview, column);
/* Translators: Name of column showing statuses of print jobs */
column = gtk_tree_view_column_new_with_attributes (_("Job State"), renderer,
"text", JOB_STATE_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (treeview, column);
/* Translators: Name of column showing times of creation of print jobs */
column = gtk_tree_view_column_new_with_attributes (_("Time"), renderer,
"text", JOB_CREATION_TIME_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (treeview, column);
g_signal_connect (gtk_tree_view_get_selection (treeview),
"changed", G_CALLBACK (job_selection_changed_cb), dialog);
update_jobs_list (dialog);
}
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;
}
/* Create list */
static
GtkWidget* create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/
G_TYPE_UINT, /* ID */
G_TYPE_STRING, /* Operation Code */
G_TYPE_INT, /* Invokes */
G_TYPE_INT, /* Num Bytes */
G_TYPE_FLOAT, /* Avg Bytes */
G_TYPE_INT, /* RetResult */
G_TYPE_INT, /* Num Bytes */
G_TYPE_FLOAT, /* Avg Bytes */
G_TYPE_INT, /* Total Bytes */
G_TYPE_FLOAT); /* Avg Bytes */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, ID_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ID", renderer,
"text", ID_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ID_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 40);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column..Operation Code. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer,
"text", OP_CODE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, OP_CODE_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 210);
gtk_tree_view_append_column (list_view, column);
/* 3:d column..Invokes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer,
"text", INVOKES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, INVOKES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* 4:th column.. Num Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_FWD_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 5:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_FWD_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 6:d column..Invokes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer,
"text", RET_RES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, RET_RES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* 7:th column.. Num Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_REV_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 8:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_REV_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 9:th column.. Total Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer,
"text", TOT_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 10:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
GtkWidget *create_list_upcoming(void)
{
GtkListStore *store;
GtkWidget *view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
DB( g_print ("\n[list_upcoming] create\n") );
/* create list store */
store = gtk_list_store_new(
NUM_LST_DSPUPC,
G_TYPE_POINTER,
G_TYPE_BOOLEAN, /* payee */
G_TYPE_STRING, /* memo */
G_TYPE_DOUBLE, /* expense */
G_TYPE_DOUBLE, /* income */
G_TYPE_POINTER, /* account */
G_TYPE_BOOLEAN, /* next on */
G_TYPE_INT, /* remaining */
G_TYPE_INT /* nb late */
);
//treeview
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), PREFS->grid_lines);
//gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
// COLUMN_DESCRIPTION);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_SINGLE);
/* column : Late */
column = gtk_tree_view_column_new();
//TRANSLATORS: title of list column to inform the scheduled transaction is Late
gtk_tree_view_column_set_title(column, _("Late"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_lateicon_cell_data_function, NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_latetext_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_NB_LATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column : Remaining */
/*column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("In"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remaining_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_REMAINING);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
*/
/* column: Next on */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Next date"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, date_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Payee */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Payee"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, payee_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_pay_width);
/* column: Memo */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Memo"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, memo_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 2);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_mem_width);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Expense"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(-1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Income"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Account */
renderer = gtk_cell_renderer_text_new ();
/*g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);*/
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Account"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, account_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPOPE_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
//gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: empty */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), list_account_selectionfunc, NULL, NULL);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), LST_DSPUPC_REMAINING, GTK_SORT_ASCENDING);
g_signal_connect (view, "destroy", G_CALLBACK (list_upcoming_destroy), NULL);
return(view);
}
void prefs_dialog_open(SensorsApplet *sensors_applet) {
gchar *header_text;
PrefsDialog *prefs_dialog;
DisplayMode display_mode;
g_assert(sensors_applet->prefs_dialog == NULL);
/* while prefs dialog is open, stop the updating of sensors so
* we don't get any race conditions due to concurrent updates
* of the labels, values and icons linked lists etc. */
if (sensors_applet->timeout_id != 0) {
if (g_source_remove(sensors_applet->timeout_id)) {
sensors_applet->timeout_id = 0;
}
}
sensors_applet->prefs_dialog = g_new0(PrefsDialog, 1);
prefs_dialog = sensors_applet->prefs_dialog;
prefs_dialog->sensors_applet = sensors_applet;
prefs_dialog->dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Sensors Applet Preferences"),
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL));
g_object_set(prefs_dialog->dialog,
"border-width", 12,
"default-width", 480,
"default-height", 350,
NULL);
gtk_box_set_homogeneous(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), FALSE);
gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), 5);
g_signal_connect(prefs_dialog->dialog,
"response", G_CALLBACK(prefs_dialog_response),
sensors_applet);
g_signal_connect_swapped(prefs_dialog->dialog,
"delete-event", G_CALLBACK(prefs_dialog_close),
sensors_applet);
g_signal_connect_swapped(prefs_dialog->dialog,
"destroy", G_CALLBACK(prefs_dialog_close),
sensors_applet);
/* if no SensorsList's have been created, this is because
we haven't been able to access any sensors */
if (sensors_applet->sensors == NULL) {
GtkWidget *label;
label = gtk_label_new(_("No sensors found!"));
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), label, TRUE, TRUE, 0);
return;
}
header_text = g_markup_printf_escaped("<b>%s</b>", _("Display"));
prefs_dialog->display_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->display_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("label with value"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon with value"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("value only"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon only"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("graph only"));
display_mode = g_settings_get_int(sensors_applet->settings, DISPLAY_MODE);
gtk_combo_box_set_active(prefs_dialog->display_mode_combo_box, display_mode);
g_signal_connect(prefs_dialog->display_mode_combo_box,
"changed",
G_CALLBACK(prefs_dialog_display_mode_changed),
prefs_dialog);
/* use spaces in label to indent */
prefs_dialog->display_mode_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("_Display sensors in panel as"),
"mnemonic-widget", prefs_dialog->display_mode_combo_box,
"xalign", 0.0,
NULL);
prefs_dialog->layout_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons"));
gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons"));
gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, g_settings_get_int(sensors_applet->settings, LAYOUT_MODE));
g_signal_connect(prefs_dialog->layout_mode_combo_box,
"changed",
G_CALLBACK(prefs_dialog_layout_mode_changed),
prefs_dialog);
prefs_dialog->layout_mode_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Preferred _position of sensor values"),
"mnemonic-widget", prefs_dialog->layout_mode_combo_box,
"xalign", 0.0,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
prefs_dialog->temperature_scale_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin"));
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius"));
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit"));
gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE));
g_signal_connect(prefs_dialog->temperature_scale_combo_box,
"changed",
G_CALLBACK(prefs_dialog_temperature_scale_changed),
prefs_dialog);
prefs_dialog->temperature_scale_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("_Temperature scale"),
"mnemonic-widget", prefs_dialog->temperature_scale_combo_box,
"xalign", 0.0,
NULL);
prefs_dialog->graph_size_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE),
"lower", 1.0,
"upper", 100.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 0.0,
NULL);
prefs_dialog->graph_size_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", prefs_dialog->graph_size_adjust,
"climb-rate", 1.0,
"digits", 0,
"value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE),
"width-chars", 4,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
(display_mode == DISPLAY_GRAPH));
prefs_dialog->graph_size_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Graph _size (pixels)"),
"mnemonic-widget", prefs_dialog->graph_size_spinbutton,
"xalign", 0.0,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),
(display_mode == DISPLAY_GRAPH));
g_signal_connect(prefs_dialog->graph_size_spinbutton, "value-changed",
G_CALLBACK(prefs_dialog_graph_size_changed),
prefs_dialog);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Update"));
prefs_dialog->update_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 2.0,
"lower", 1.5,
"upper", 10.0,
"step-increment", 0.5,
"page-increment", 1.0,
"page-size", 0.0,
NULL);
prefs_dialog->timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", prefs_dialog->timeout_adjust,
"climb-rate", 0.5,
"digits", 1,
"value", (gdouble) g_settings_get_int(sensors_applet->settings, TIMEOUT) / 1000.0,
"width-chars", 4,
NULL);
prefs_dialog->timeout_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Update _interval (secs)"),
"mnemonic-widget", prefs_dialog->timeout_spinbutton,
"xalign", 0.0,
NULL);
g_signal_connect(prefs_dialog->timeout_spinbutton, "value-changed",
G_CALLBACK(prefs_dialog_timeout_changed),
prefs_dialog);
#ifdef HAVE_LIBNOTIFY
header_text = g_markup_printf_escaped("<b>%s</b>", _("Notifications"));
prefs_dialog->notifications_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->display_notifications = g_object_new(GTK_TYPE_CHECK_BUTTON,
"use-underline", TRUE,
"label", _("Display _notifications"),
NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications),
g_settings_get_boolean(sensors_applet->settings,
DISPLAY_NOTIFICATIONS));
g_signal_connect(prefs_dialog->display_notifications,
"toggled",
G_CALLBACK(prefs_dialog_display_notifications_toggled),
prefs_dialog);
#endif
/* SIZE AND LAYOUT */
/* keep all widgets same size */
prefs_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->display_mode_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->layout_mode_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->temperature_scale_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->timeout_spinbutton));
g_object_unref(prefs_dialog->size_group);
prefs_dialog->globals_table = g_object_new(GTK_TYPE_TABLE,
"homogeneous", FALSE,
"n-columns", 3,
#ifdef HAVE_LIBNOTIFY
"n-rows", 9,
#else
"n-rows", 7,
#endif
"row-spacing", 6,
"column-spacing", 12,
NULL);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_header),
0, 2,
0, 1,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_mode_label),
1, 2,
1, 2,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_mode_combo_box),
2, 3,
1, 2,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->layout_mode_label),
1, 2,
2, 3,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
2, 3,
2, 3,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->graph_size_label),
1, 2,
3, 4,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
2, 3,
3, 4,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->temperature_scale_label),
1, 2,
4, 5,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->temperature_scale_combo_box),
2, 3,
4, 5,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->update_header),
0, 2,
5, 6,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->timeout_label),
1, 2,
6, 7,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->timeout_spinbutton),
2, 3,
6, 7,
GTK_FILL,
GTK_FILL,
0,
0);
#ifdef HAVE_LIBNOTIFY
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->notifications_header),
0, 2,
7, 8,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_notifications),
1, 2,
8, 9,
GTK_FILL,
GTK_FILL,
0,
0);
#endif
prefs_dialog->view = g_object_new(GTK_TYPE_TREE_VIEW,
"model", GTK_TREE_MODEL(sensors_applet->sensors),
"rules-hint", TRUE,
"reorderable", FALSE,
"enable-search", TRUE,
"search-column", LABEL_COLUMN,
NULL);
/* get double clicks on rows - do same as configure sensor
* button clicks */
g_signal_connect(prefs_dialog->view, "row-activated",
G_CALLBACK(prefs_dialog_row_activated),
prefs_dialog);
prefs_dialog->id_renderer = gtk_cell_renderer_text_new();
prefs_dialog->label_renderer = gtk_cell_renderer_text_new();
g_object_set(prefs_dialog->label_renderer,
"editable", TRUE,
NULL);
g_signal_connect(prefs_dialog->label_renderer, "edited",
G_CALLBACK(prefs_dialog_sensor_name_changed),
prefs_dialog);
prefs_dialog->enable_renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(prefs_dialog->enable_renderer, "toggled",
G_CALLBACK(prefs_dialog_sensor_toggled),
prefs_dialog);
prefs_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();
prefs_dialog->id_column = gtk_tree_view_column_new_with_attributes(_("Sensor"),
prefs_dialog->id_renderer,
"text", ID_COLUMN,
NULL);
gtk_tree_view_column_set_min_width(prefs_dialog->id_column, 90);
prefs_dialog->label_column = gtk_tree_view_column_new_with_attributes(_("Label"),
prefs_dialog->label_renderer,
"text", LABEL_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_tree_view_column_set_min_width(prefs_dialog->label_column, 100);
/* create the tooltip */
gtk_widget_set_tooltip_text(GTK_WIDGET(prefs_dialog->view),
_("Labels can be edited directly by clicking on them."));
prefs_dialog->enable_column = gtk_tree_view_column_new_with_attributes(_("Enabled"),
prefs_dialog->enable_renderer,
"active", ENABLE_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
prefs_dialog->icon_column = gtk_tree_view_column_new_with_attributes(_("Icon"),
prefs_dialog->icon_renderer,
"pixbuf", ICON_PIXBUF_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->id_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->icon_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->label_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->enable_column);
gtk_tree_view_columns_autosize(prefs_dialog->view);
prefs_dialog->scrolled_window = g_object_new(GTK_TYPE_SCROLLED_WINDOW,
"hadjustment", NULL,
"height-request", 200,
"hscrollbar-policy", GTK_POLICY_AUTOMATIC,
"vadjustment",NULL,
"vscrollbar-policy", GTK_POLICY_AUTOMATIC,
NULL);
gtk_container_add(GTK_CONTAINER(prefs_dialog->scrolled_window), GTK_WIDGET(prefs_dialog->view));
/* GtkTree Selection */
sensors_applet->selection = gtk_tree_view_get_selection(prefs_dialog->view);
/* allow user to only select one row at a time at most */
gtk_tree_selection_set_mode(sensors_applet->selection, GTK_SELECTION_SINGLE);
/* when selection is changed, make sure sensor_config button is
activated */
/* Create buttons for user to interact with sensors tree */
prefs_dialog->sensor_up_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_UP));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
g_signal_connect(prefs_dialog->sensor_up_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_up_button_clicked),
prefs_dialog);
prefs_dialog->sensor_down_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_DOWN));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);
g_signal_connect(prefs_dialog->sensor_down_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_down_button_clicked),
prefs_dialog);
prefs_dialog->buttons_box = GTK_VBUTTON_BOX(gtk_vbutton_box_new());
gtk_button_box_set_layout(GTK_BUTTON_BOX(prefs_dialog->buttons_box),
GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE, FALSE, 0);
prefs_dialog->sensors_hbox = g_object_new(GTK_TYPE_HBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 5,
NULL);
gtk_box_pack_start(prefs_dialog->sensors_hbox,
GTK_WIDGET(prefs_dialog->scrolled_window),
TRUE, TRUE, 0); /* make sure window takes
* up most of room */
gtk_box_pack_start(prefs_dialog->sensors_hbox,
GTK_WIDGET(prefs_dialog->buttons_box),
FALSE, FALSE, 0);
/* Sensor Config button */
/* initially make button insensitive until user selects a row
from the sensors tree */
prefs_dialog->sensor_config_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_PROPERTIES));
g_object_set(prefs_dialog->sensor_config_button,
"sensitive", FALSE,
NULL);
g_signal_connect(sensors_applet->selection,
"changed",
G_CALLBACK(prefs_dialog_selection_changed),
prefs_dialog);
/* pass selection to signal handler so we can give user a
sensors_applet->prefs_dialog with the selected rows alarm
value and enable */
g_signal_connect(prefs_dialog->sensor_config_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_config_button_clicked),
prefs_dialog);
prefs_dialog->sensor_config_hbox = g_object_new(GTK_TYPE_HBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 0,
NULL);
gtk_box_pack_end(prefs_dialog->sensor_config_hbox,
GTK_WIDGET(prefs_dialog->sensor_config_button),
FALSE, FALSE, 0);
/* pack sensors_vbox */
prefs_dialog->sensors_vbox = g_object_new(GTK_TYPE_VBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 0,
NULL);
gtk_box_pack_start(prefs_dialog->sensors_vbox,
GTK_WIDGET(prefs_dialog->sensors_hbox),
TRUE, TRUE, 0);
gtk_box_pack_start(prefs_dialog->sensors_vbox,
GTK_WIDGET(prefs_dialog->sensor_config_hbox),
FALSE, FALSE, 0);
prefs_dialog->globals_alignment = g_object_new(GTK_TYPE_ALIGNMENT,
"xalign", 0.5,
"yalign", 0.0,
"top-padding", 12,
"left-padding", 12,
"bottom-padding", 12,
"right-padding", 12,
NULL);
gtk_container_add(GTK_CONTAINER(prefs_dialog->globals_alignment),
GTK_WIDGET(prefs_dialog->globals_table));
prefs_dialog->notebook = g_object_new(GTK_TYPE_NOTEBOOK,
NULL);
gtk_notebook_append_page(prefs_dialog->notebook,
GTK_WIDGET(prefs_dialog->globals_alignment),
gtk_label_new(_("General Options")));
gtk_notebook_append_page(prefs_dialog->notebook,
GTK_WIDGET(prefs_dialog->sensors_vbox),
gtk_label_new(_("Sensors")));
/* pack notebook into prefs_dialog */
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)),
GTK_WIDGET(prefs_dialog->notebook), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog));
}
Compose * compose_new(Config * config)
{
Compose * compose;
GtkAccelGroup * group;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkToolItem * toolitem;
GtkSizeGroup * sizegroup;
GtkWidget * vpaned;
GtkWidget * vbox2;
GtkWidget * widget;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeIter iter;
char const * headers[] = {
"To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:",
"Followup-To:" };
size_t i;
if((compose = malloc(sizeof(*compose))) == NULL)
{
compose_error(NULL, strerror(errno), 0);
return NULL;
}
compose->mime = mime_new(NULL);
/* check errors */
if(compose->mime == NULL)
{
free(compose);
return NULL;
}
compose->config = config;
compose->standalone = FALSE;
/* window */
group = gtk_accel_group_new();
compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(compose->window), group);
#ifndef EMBEDDED
gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384);
#else
gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300);
#endif
gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose"));
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer");
#endif
g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event",
G_CALLBACK(_compose_on_closex), compose);
vbox = gtk_vbox_new(FALSE, 0);
/* menubar */
#ifndef EMBEDDED
widget = desktop_menubar_create(_compose_menubar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
#endif
/* toolbar */
toolbar = desktop_toolbar_create(_compose_toolbar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* from */
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("From: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_widget_set_size_request(widget, 80, -1);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
#if GTK_CHECK_VERSION(2, 24, 0)
compose->from = gtk_combo_box_text_new_with_entry();
#else
compose->from = gtk_combo_box_entry_new_text();
#endif
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->from);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* paned */
vpaned = gtk_vpaned_new();
/* headers */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN);
compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(
compose->h_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(
compose->h_store_filter),
_compose_on_headers_filter, compose, NULL);
compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
compose->h_store_filter));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE);
compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_STRING);
for(i = 0; i < sizeof(headers) / sizeof(*headers); i++)
{
gtk_list_store_append(compose->h_headers, &iter);
gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1,
headers[i], -1);
}
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "editable", TRUE, "model", compose->h_headers,
"text-column", 1, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_field_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_HEADER, NULL);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_VALUE, NULL);
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_tree_view_column_set_expand(column, TRUE);
#endif
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
/* default to 8-bits transfers with UTF-8 encoding */
compose_set_header(compose, "Content-Transfer-Encoding:", "8bit",
FALSE);
compose_set_header(compose, "Content-Type:",
"text/plain; charset=UTF-8", FALSE);
compose_add_field(compose, "To:", NULL);
gtk_container_add(GTK_CONTAINER(widget), compose->h_view);
gtk_paned_add1(GTK_PANED(vpaned), widget);
/* paned */
vbox2 = gtk_vbox_new(FALSE, 0);
/* subject */
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("Subject: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
compose->subject = gtk_entry_new();
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->subject);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0);
/* view */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->view = _new_text_view(compose);
compose_set_font(compose, _compose_get_font(compose));
gtk_container_add(GTK_CONTAINER(widget), compose->view);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
gtk_paned_add2(GTK_PANED(vpaned), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
/* attachments */
compose->a_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(
compose->a_store));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view),
CAC_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view),
CAC_BASENAME);
gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view);
gtk_widget_show_all(compose->a_view);
gtk_widget_set_no_show_all(compose->a_window, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0);
/* statusbar */
compose->statusbar = gtk_statusbar_new();
compose->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(compose->window), vbox);
/* about dialog */
compose->ab_window = NULL;
/* signature */
compose_append_signature(compose);
compose_set_modified(compose, FALSE);
compose_scroll_to_offset(compose, 0);
/* display */
gtk_widget_grab_focus(compose->view);
gtk_widget_show_all(vbox);
gtk_widget_show(compose->window);
return compose;
}
static GtkWidget *create_window(void)
{
// Basic window
stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
// banner
{
GdkPixbuf *pixbuf = load_banner();
stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);
// Tab control
stwidgets.tabs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);
// layout table of config page
stwidgets.configtlayout = gtk_table_new(6, 3, FALSE);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);
// 3D video mode LabelText
stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
}
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
// Fullscreen checkbox
stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0);
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0);
#ifdef POLYMER
// Polymer checkbox
stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0);
#endif
// Input devices LabelText
stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 0);
// Input devices combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
// Custom mod LabelText
stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, (GtkAttachOptions)0, 4, 7);
// Custom mod combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 7);
// Empty horizontal layout
stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, (GtkAttachOptions)0,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 4, 0);
// Autoload checkbox
stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, (GtkAttachOptions)0, 2, 2);
// Always show config checkbox
stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, (GtkAttachOptions)0, 2, 2);
// Configuration tab
stwidgets.configtab = gtk_label_new("Configuration");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);
// Game data layout
stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4);
// Game data field LabelText
stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:");
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5);
// Game data scrollable area
stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN);
// Game data list
{
GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);
stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
gtk_tree_view_column_set_min_width(col, 64);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
}
gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
// Game tab
stwidgets.gametab = gtk_label_new("Game");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab);
// Messages scrollable area
stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
stwidgets.messagestext = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
// Messages tab
stwidgets.messagestab = gtk_label_new("Messages");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab);
// Dialogue box buttons layout
stwidgets.buttons = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);
// Cancel button
stwidgets.cancelbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);
stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);
stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);
stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);
stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
stwidgets.startbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton);
stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);
stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);
stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);
stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
#ifdef POLYMER
g_signal_connect((gpointer) stwidgets.polymercheck, "toggled",
G_CALLBACK(on_polymercheck_toggled),
NULL);
#endif
g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed",
G_CALLBACK(on_inputdevcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.custommodcombo, "changed",
G_CALLBACK(on_custommodcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled",
G_CALLBACK(on_autoloadcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
g_signal_connect((gpointer) sel, "changed",
G_CALLBACK(on_gamelist_selection_changed),
NULL);
}
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist);
return stwidgets.startwin;
}
static GtkWidget *
key_dialog_treeview_new (GtkWidget *box)
{
GtkWidget *scroll;
GtkListStore *store, *combostore;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
int i;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key-press-event",
G_CALLBACK (key_dialog_keypress), NULL);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))),
"changed", G_CALLBACK (key_dialog_selection_changed), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_accel_new ();
g_object_set (render, "editable", TRUE,
#ifndef WIN32
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
#endif
NULL);
g_signal_connect (G_OBJECT (render), "accel-edited",
G_CALLBACK (key_dialog_set_key), NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN,
"Key", render,
"text", KEY_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), ACCEL_COLUMN,
"Accel", render,
"text", ACCEL_COLUMN,
NULL);
combostore = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i <= KEY_MAX_ACTIONS; i++)
{
GtkTreeIter iter;
if (key_actions[i].name[0])
{
gtk_list_store_append (combostore, &iter);
gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1);
}
}
render = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (render), "model", combostore,
"has-entry", FALSE,
"editable", TRUE,
"text-column", 0,
NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN));
g_signal_connect (G_OBJECT (render), "changed",
G_CALLBACK (key_dialog_combo_changed), combostore);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN,
"Action", render,
"text", ACTION_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D1_COLUMN,
"Data1", render,
"text", D1_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D2_COLUMN,
"Data2", render,
"text", D2_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 200);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN);
gtk_tree_view_column_set_visible (col, FALSE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 160);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
return view;
}
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc,
gboolean back)
{
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkRequisition size;
GtkTreePath *path;
GtkTreeIter iter;
int height, width;
/* if there is only one match - don't build the tree view */
if (gtk_tree_model_iter_n_children(model, NULL) == 1) {
char *value;
path = gtk_tree_path_new_from_indices(0, -1);
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1);
/* call the select function */
selfunc(value);
g_free(value);
g_object_unref(model);
return false;
}
}
comp.selfunc = selfunc;
/* prepare the tree view */
comp.win = gtk_scrolled_window_new(NULL, NULL);
comp.tree = gtk_tree_view_new();
#ifndef HAS_GTK3
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
#endif
gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0);
gtk_container_add(GTK_CONTAINER(comp.win), comp.tree);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false);
/* we have only on line per item so we can use the faster fixed heigh mode */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true);
gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model);
g_object_unref(model);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]);
/* prepare the selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL);
/* get window dimension */
gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height);
/* prepare first column */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_MIDDLE,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST);
gtk_tree_view_column_set_min_width(column, 2 * width/3);
/* prepare second column */
#ifdef FEATURE_TITLE_IN_COMPLETION
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND);
#endif
/* to set the height for the treeview the tree must be realized first */
gtk_widget_show(comp.tree);
/* this prevents the first item to be placed out of view if the completion
* is shown */
while (gtk_events_pending()) {
gtk_main_iteration();
}
/* use max 1/3 of window height for the completion */
#ifdef HAS_GTK3
gtk_widget_get_preferred_size(comp.tree, NULL, &size);
height /= 3;
gtk_scrolled_window_set_min_content_height(
GTK_SCROLLED_WINDOW(comp.win),
size.height > height ? height : size.height
);
#else
gtk_widget_size_request(comp.tree, &size);
height /= 3;
if (size.height > height) {
gtk_widget_set_size_request(comp.win, -1, height);
}
#endif
vb.mode->flags |= FLAG_COMPLETION;
/* set to -1 to have the cursor on first or last item set in move_cursor */
comp.active = -1;
completion_next(back);
gtk_widget_show(comp.win);
return true;
}
void Operator_manage(GtkWidget * UNUSED(widget), GtkWindow * parent) {
GtkWidget * dialog;
GtkWidget *hbox;
GtkWidget * bbox;
GtkWidget * sw;
GtkTreeModel * model;
GtkWidget *treeview;
GtkWidget * button;
GtkCellRenderer * renderer;
GtkTreeViewColumn *column;
/** Creation de la fenêtre principale */
dialog = gtk_dialog_new_with_buttons("Gestion des opérateurs", parent, GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
gtk_container_set_border_width(GTK_CONTAINER (dialog), 5);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
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_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX (hbox), sw, TRUE, TRUE, 0);
model = gtk_tree_model_sort_new_with_model(Operator_loadModel());
/* create tree view */
treeview = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW (treeview), 0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Opérateur");
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_min_width(column, 300);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_cell_renderer_set_alignment(renderer, 0, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column);
gtk_widget_set_size_request(sw, 350, 400);
gtk_widget_show(treeview);
g_object_unref(model);
gtk_container_add(GTK_CONTAINER (sw), treeview);
bbox = gtk_vbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX (bbox), 5);
gtk_box_pack_start(GTK_BOX (hbox), bbox, TRUE, TRUE, 0);
gtk_widget_show(bbox);
button = gtk_button_new_with_label("Ajouter");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_add), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show(button);
button = gtk_button_new_with_label("Supprimer");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_delete), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show(button);
button = gtk_button_new_with_label("Modifier");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_modify), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show_all(hbox);
gtk_dialog_run(GTK_DIALOG (dialog));
gtk_widget_destroy(dialog);
}
// Create and bind the tree model to the tree view for the subtitle track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_subtitle_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
g_debug("bind_subtitle_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "subtitle_list"));
selection = gtk_tree_view_get_selection (treeview);
// 6 columns in model. 5 are visible, the other 1 is for storing
// values that I need
// Track, force, burn, default, type, srt offset, track short, source
// force visible, burn visible, offset visible
treestore = gtk_list_store_new(10,
G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_INT, G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
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(
_("Track"), cell, "text", 0, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 350);
gtk_tree_view_column_set_max_width (column, 350);
cell = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(
_("Forced Only"), cell, "active", 1, "visible", 7, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_forced_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Burned In"), cell, "active", 2, "visible", 8, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_burned_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Default"), cell, "active", 3, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_default_toggled_cb, ud);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Srt Offset"), cell, "text", 4, "visible", 9, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", subtitle_list_selection_changed_cb, ud);
// Need to disable remove and update buttons since there are initially
// no selections
widget = GHB_WIDGET (ud->builder, "subtitle_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
/* Create list */
static GtkWidget *
create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/
G_TYPE_STRING, /* SI */
G_TYPE_INT, /* Num MSUs */
G_TYPE_STRING, /* MSUs/sec */
G_TYPE_INT, /* Num Bytes */
G_TYPE_STRING, /* Bytes/MSU */
G_TYPE_STRING); /* Bytes/sec */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, SI_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SI", renderer,
"text", SI_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SI_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 110);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num MSUs", renderer,
"text", NUM_MSUS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("MSUs/sec", renderer,
"text", NUM_MSUS_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_SEC_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 4:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 5:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/MSU", renderer,
"text", NUM_BYTES_MSU_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_MSU_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 6:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/sec", renderer,
"text", NUM_BYTES_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_SEC_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
// Create and bind the tree model to the tree view for the audio track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_audio_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
g_debug("bind_audio_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "audio_list"));
selection = gtk_tree_view_get_selection (treeview);
// 12 columns in model. 6 are visible, the other 6 are for storing
// values that I need
treestore = gtk_list_store_new(7, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Track"), cell, "text", 0, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 200);
gtk_tree_view_column_set_max_width (column, 200);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Codec"), cell, "text", 1, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 110);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Bitrate"), cell, "text", 2, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 50);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Sample Rate"), cell, "text", 3, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 100);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Mix"), cell, "text", 4, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 115);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Gain"), cell, "text", 5, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("DRC"), cell, "text", 6, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", audio_list_selection_changed_cb, ud);
// Need to disable remove and update buttons since there are initially
// no selections
widget = GHB_WIDGET (ud->builder, "audio_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
bool change_function(int vars)
{
/* Clear model */
clear_liststore(function_view);
/* Create the dynamic types array */
GType* types = (GType*) malloc(3 * vars * sizeof(GType));
if(types == NULL) {
return false;
}
/* Set type in the dynamic types array */
for(int i = 0; i < vars; i++) {
types[i] = G_TYPE_INT; /* Coeffs */
types[vars + i] = G_TYPE_STRING; /* Text */
types[2 * vars + i] = G_TYPE_STRING; /* Signs */
}
/* Create and fill the new model */
GtkListStore* function = gtk_list_store_newv(3 * vars, types);
GtkTreeIter iter;
GValue initi = G_VALUE_INIT;
g_value_init(&initi, G_TYPE_INT);
GValue inits = G_VALUE_INIT;
g_value_init(&inits, G_TYPE_STRING);
gtk_list_store_append(function, &iter);
for(int i = 0; i < vars; i++) {
g_value_set_int(&initi, 1);
gtk_list_store_set_value(function, &iter, i, &initi);
char* text = var_name(1, i, false);
g_value_set_string(&inits, text);
gtk_list_store_set_value(function, &iter, vars + i, &inits);
free(text);
g_value_set_string(&inits, PLUS);
gtk_list_store_set_value(function, &iter, 2 * vars + i, &inits);
}
/* Clear the previous columns */
for(int i = gtk_tree_view_get_n_columns(function_view) - 1; i >= 0; i--) {
gtk_tree_view_remove_column(
function_view,
gtk_tree_view_get_column(function_view, i)
);
}
/* Create the new columns */
for(int i = 0; i < vars; i++) {
/* Create sign column */
if(i > 0) {
GtkCellRenderer* sign = gtk_cell_renderer_text_new();
GtkTreeViewColumn* sign_c =
gtk_tree_view_column_new_with_attributes(
"", sign, /* Title, renderer */
"markup", 2 * vars + i,
NULL);
gtk_tree_view_append_column(function_view, sign_c);
}
/* Create text column */
/* Create and configure cell */
GtkCellRenderer* cell = gtk_cell_renderer_spin_new();
gtk_cell_renderer_set_alignment(cell, 1.0, 0.5);
g_object_set(cell, "editable", true, NULL);
/* Configure callbacks */
g_signal_connect(G_OBJECT(cell),
"editing-started", G_CALLBACK(function_edit_started_cb),
GINT_TO_POINTER(i));
function_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(function_edited_cb),
GINT_TO_POINTER(i));
/* Configure column */
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", cell, /* Title, renderer */
"markup", vars + i,
NULL);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column(function_view, column);
}
gtk_tree_view_append_column(function_view, gtk_tree_view_column_new());
/* Set the new model */
gtk_tree_view_set_model(function_view, GTK_TREE_MODEL(function));
/* Free resources */
g_object_unref(G_OBJECT(function));
free(types);
return true;
}
static void
ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
{
GtkWidget *ifopts_edit_dlg, *cur_scr_win, *main_hb, *main_tb,
*cur_opts_fr, *ed_opts_fr, *main_vb,
*if_descr_lb,
*if_hide_lb,
*bbox, *ok_bt, *cancel_bt, *help_bt;
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *list_view;
GtkTreeSelection *selection;
int row = 0;
GtkWidget *caller = gtk_widget_get_toplevel(w);
/* Has an edit dialog box already been opened for that top-level
widget? */
ifopts_edit_dlg = g_object_get_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY);
if (ifopts_edit_dlg != NULL) {
/* Yes. Just re-activate that dialog box. */
reactivate_window(ifopts_edit_dlg);
return;
}
/* create a new dialog */
ifopts_edit_dlg = dlg_conf_window_new("Wireshark: Preferences: Interface Options");
gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), 1000, 440);
main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb);
gtk_widget_show(main_vb);
/* create current options frame */
cur_opts_fr = gtk_frame_new("Interfaces");
gtk_box_pack_start(GTK_BOX(main_vb), cur_opts_fr, TRUE, TRUE, 0);
gtk_widget_show(cur_opts_fr);
/* create a scrolled window to pack the current options TreeView widget into */
cur_scr_win = scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(cur_scr_win), 3);
gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win);
gtk_widget_show(cur_scr_win);
/*
* Create current options TreeView.
*/
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */
G_TYPE_STRING, /* Device */
G_TYPE_STRING, /* Description */
#ifdef HAVE_PCAP_CREATE
G_TYPE_BOOLEAN, /* Monitor mode */
#endif
G_TYPE_STRING, /* Default link-layer */
G_TYPE_STRING, /* Comment */
G_TYPE_BOOLEAN, /* Hide? */
G_TYPE_INT); /* Dlt */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Device", renderer,
"text", DEVICE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
#ifdef _WIN32
gtk_tree_view_column_set_min_width(column, 230);
#else
gtk_tree_view_column_set_min_width(column, 70);
#endif
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Description", renderer,
"text", DESC_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 260);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#ifdef HAVE_PCAP_CREATE
/*
* XXX - for some reason, this doesn't show up.
*/
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Default to monitor mode", renderer,
"active", DEF_MONITOR_MODE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#endif
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer,
"text", DEF_LINK_LAYER_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 230);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Comment", renderer,
"text", COMMENT_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Hide?", renderer,
"active", HIDE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#if 0
/* Don't show the DLT column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("DLT", renderer,
"text", DLT_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 40);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#endif
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(list_view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
cur_list = list;
gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_list);
if_selection = selection;
g_signal_connect (G_OBJECT (selection), "changed", /* select_row */
G_CALLBACK (ifopts_edit_ifsel_cb),
NULL);
gtk_widget_show(cur_list);
/* add interface names to cell */
ifopts_if_liststore_add();
/* create edit options frame */
ed_opts_fr = gtk_frame_new("Properties");
gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0);
gtk_widget_show(ed_opts_fr);
main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(main_hb), 3);
gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb);
gtk_widget_show(main_hb);
/* table to hold description text entry and hide button */
main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE);
gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10);
gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10);
gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10);
gtk_widget_show(main_tb);
if_dev_lb = gtk_label_new("Device:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0f, 0.5f);
gtk_widget_show(if_dev_lb);
if_dev_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0f, 0.5f);
gtk_widget_show(if_dev_lb);
row++;
if_name_lb = gtk_label_new("Description:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0f, 0.5f);
gtk_widget_show(if_name_lb);
if_name_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0f, 0.5f);
gtk_widget_show(if_name_lb);
row++;
#ifdef HAVE_PCAP_CREATE
/* create "monitor mode" label and button */
if_monitor_lb = gtk_label_new("Monitor mode:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_monitor_lb), 1.0f, 0.5f);
gtk_widget_show(if_monitor_lb);
if_monitor_cb = gtk_check_button_new();
g_signal_connect(if_monitor_cb, "toggled", G_CALLBACK(ifopts_edit_monitor_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_cb, 1, 2, row, row+1);
gtk_widget_show(if_monitor_cb);
row++;
#endif
if_linktype_lb = gtk_label_new("Default link-layer header type:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f);
gtk_widget_show(if_linktype_lb);
if_linktype_cb = gtk_combo_box_text_new();
num_linktypes = 0;
interfaces_info_nochange = FALSE;
g_signal_connect(if_linktype_cb, "changed", G_CALLBACK(ifopts_edit_linktype_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_cb, 1, 2, row, row+1);
gtk_widget_show(if_linktype_cb);
row++;
/* create interface description label and text entry */
if_descr_lb = gtk_label_new("Comment:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0f, 0.5f);
gtk_widget_show(if_descr_lb);
if_descr_te = gtk_entry_new();
g_signal_connect(if_descr_te, "changed", G_CALLBACK(ifopts_edit_descr_changed_cb),
cur_list);
gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1);
gtk_widget_show(if_descr_te);
row++;
/* create "hide interface" label and button */
if_hide_lb = gtk_label_new("Hide interface?:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0f, 0.5f);
gtk_widget_show(if_hide_lb);
if_hide_cb = gtk_check_button_new();
g_signal_connect(if_hide_cb, "toggled", G_CALLBACK(ifopts_edit_hide_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1);
gtk_widget_show(if_hide_cb);
if_default_if_lb = gtk_label_new("(Default interface cannot be hidden)");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_default_if_lb, 1, 3, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_default_if_lb), 0.15f, 0.5f);
row++;
/* button row: OK and Cancel buttons */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
gtk_widget_set_tooltip_text(ok_bt, "Save changes and exit dialog");
g_signal_connect(ok_bt, "clicked", G_CALLBACK(ifopts_edit_ok_cb), ifopts_edit_dlg);
cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog");
window_set_cancel_button(ifopts_edit_dlg, cancel_bt, window_cancel_button_cb);
help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb),
(gpointer)HELP_CAPTURE_INTERFACE_OPTIONS_DIALOG);
gtk_widget_set_tooltip_text (help_bt, "Show topic specific help");
gtk_widget_grab_default(ok_bt);
g_signal_connect(ifopts_edit_dlg, "delete_event", G_CALLBACK(window_delete_event_cb),
NULL);
/* Call a handler when we're destroyed, so we can inform
our caller, if any, that we've been destroyed. */
g_signal_connect(ifopts_edit_dlg, "destroy", G_CALLBACK(ifopts_edit_destroy_cb), NULL);
/* Set the key for the new dialog to point to our caller. */
g_object_set_data(G_OBJECT(ifopts_edit_dlg), IFOPTS_CALLER_PTR_KEY, caller);
/* Set the key for the caller to point to us */
g_object_set_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY, ifopts_edit_dlg);
gtk_widget_show(ifopts_edit_dlg); /* triggers ifopts_edit_ifsel_cb() with the */
/* "interfaces" TreeView first row selected */
window_present(ifopts_edit_dlg);
}
static void
history_dialog_setup_view (HistoryDialog *dialog)
{
GtkTreeView *treeview = dialog->priv->treeview;
GtkTreeStore *treestore;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
/* set tree model */
treestore = gtk_tree_store_new (8,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_POINTER,
G_TYPE_INT,
G_TYPE_INT);
dialog->priv->model = GTK_TREE_MODEL(treestore);
gtk_tree_view_set_model (treeview,
GTK_TREE_MODEL (treestore));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview),
TRUE);
g_signal_connect (treeview, "row_activated",
G_CALLBACK (history_dialog_row_activated_cb),
dialog);
selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_enable_model_drag_source (treeview,
GDK_BUTTON1_MASK,
url_drag_types,
G_N_ELEMENTS (url_drag_types),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT(treeview),
"drag_data_get",
G_CALLBACK(treeview_drag_data_get_cb),
dialog);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview,
0, _("Title"),
renderer,
"text", 0,
NULL);
column = gtk_tree_view_get_column (treeview, 0);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 400);
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_insert_column_with_attributes (treeview,
1, _("URL"),
renderer,
"text", 1,
NULL);
column = gtk_tree_view_get_column (treeview, 1);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 500);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_insert_column_with_attributes (treeview,
2, _("Last visited"),
renderer,
"text", 2,
NULL);
column = gtk_tree_view_get_column (treeview, 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, 6);
gtk_tree_view_insert_column_with_attributes (treeview,
3, _("First visited"),
renderer,
"text", 3,
NULL);
column = gtk_tree_view_get_column (treeview, 3);
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, 7);
gtk_tree_view_insert_column_with_attributes (treeview,
4, _("Times visited"),
renderer,
"text", 4,
NULL);
column = gtk_tree_view_get_column (treeview, 4);
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, 4);
}
bool change_restrictions(int vars)
{
/* Clear model */
clear_liststore(restrictions_view);
/* Create the dynamic types array */
int size = vars + 2;
GType* types = (GType*) malloc(3 * size * sizeof(GType));
if(types == NULL) {
return false;
}
/* Set type in the dynamic types array */
for(int i = 0; i < size; i++) {
types[i] = G_TYPE_INT; /* Coeffs */
types[size + i] = G_TYPE_STRING; /* Text */
types[2 * size + i] = G_TYPE_STRING; /* Signs */
}
/* Create the new model */
GtkListStore* restrictions = gtk_list_store_newv(3 * size, types);
/* Clear the previous columns */
for(int i = gtk_tree_view_get_n_columns(restrictions_view) - 1; i >= 0; i--) {
gtk_tree_view_remove_column(
restrictions_view,
gtk_tree_view_get_column(restrictions_view, i)
);
}
/* Create the new columns */
for(int i = 0; i < size; i++) {
/* Especial column for type */
if(i == (size - 2)) {
GtkCellRenderer* type = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", type, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_append_column(restrictions_view, column);
continue;
}
/* Create sign column */
if((i != 0) && (i != size - 1)) {
GtkCellRenderer* sign = gtk_cell_renderer_text_new();
GtkTreeViewColumn* sign_c =
gtk_tree_view_column_new_with_attributes(
"", sign, /* Title, renderer */
"markup", 2 * size + i,
NULL);
gtk_tree_view_append_column(restrictions_view, sign_c);
}
/* Create text column */
/* Create and configure cell */
GtkCellRenderer* cell = gtk_cell_renderer_spin_new();
gtk_cell_renderer_set_alignment(cell, 1.0, 0.5);
g_object_set(cell, "editable", true, NULL);
/* Configure callbacks */
g_signal_connect(G_OBJECT(cell),
"editing-started", G_CALLBACK(restrictions_edit_started_cb),
GINT_TO_POINTER(i));
restrictions_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i));
if(i < size - 2) {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(restrictions_edited_cb),
GINT_TO_POINTER(i));
} else {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(num_edited_cb),
GINT_TO_POINTER(i));
}
/* Configure column */
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", cell, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column(restrictions_view, column);
}
gtk_tree_view_append_column(restrictions_view, gtk_tree_view_column_new());
/* Set the new model */
gtk_tree_view_set_model(restrictions_view, GTK_TREE_MODEL(restrictions));
/* Free resources */
g_object_unref(G_OBJECT(restrictions));
free(types);
return true;
}
