static void remmina_ftp_client_init(RemminaFTPClient *client)
{
RemminaFTPClientPriv *priv;
GtkWidget *vpaned;
GtkWidget *scrolledwindow;
GtkWidget *widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *vbox;
priv = g_new0(RemminaFTPClientPriv, 1);
client->priv = priv;
/* Main container */
gtk_box_set_homogeneous(GTK_BOX(client), FALSE);
gtk_box_set_spacing(GTK_BOX(client), 4);
/* Toolbar */
remmina_ftp_client_create_toolbar(client);
/* The Paned to separate File List and Task List */
#if GTK_VERSION == 3
vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#elif GTK_VERSION == 2
vpaned = gtk_vpaned_new();
#endif
gtk_widget_show(vpaned);
gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0);
priv->vpaned = vpaned;
/* Remote */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_widget_show(vbox);
gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE);
/* Remote Directory */
widget = gtk_combo_box_text_new_with_entry();
gtk_widget_show(widget);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/");
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
priv->directory_combo = widget;
/* Remote File List */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
widget = gtk_tree_view_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE);
priv->file_list_view = widget;
/* Remote File List - Columns */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("File Name"));
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
/* Remote File List - Model */
priv->file_list_model = GTK_TREE_MODEL(
gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING));
priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter),
(GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL);
priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort);
/* Task List */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE);
widget = gtk_tree_view_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
g_object_set(widget, "has-tooltip", TRUE, NULL);
priv->task_list_view = widget;
/* Task List - Columns */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("File Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = remmina_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL);
g_object_set(G_OBJECT(renderer), "stock-id", "_Cancel", NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client);
/* Task List - Model */
priv->task_list_model = GTK_TREE_MODEL(
gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT,
G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING));
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model);
/* Setup the internal signals */
g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL);
g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate",
G_CALLBACK(remmina_ftp_client_dir_on_activate), client);
g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client);
g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event",
G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client);
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed",
G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client);
g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip",
G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client);
}
static inline void create_list_view(FmFolderView* fv, GList* sels)
{
GtkTreeViewColumn* col;
GtkTreeSelection* ts;
GList *l;
GtkCellRenderer* render;
FmFolderModel* model = (FmFolderModel*)fv->model;
int icon_size = 0;
fv->view = exo_tree_view_new();
render = fm_cell_renderer_pixbuf_new();
fv->renderer_pixbuf = render;
// fv->icon_size_changed_handler = g_signal_connect(fm_config, "changed::small_icon_size", G_CALLBACK(on_small_icon_size_changed), fv);
icon_size = fm_config->small_icon_size;
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(fv->renderer_pixbuf), icon_size, icon_size);
if(model)
fm_folder_model_set_icon_size(model, icon_size);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(fv->view), TRUE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Name"));
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render,
"pixbuf", COL_FILE_ICON,
"info", COL_FILE_INFO, 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_FILE_NAME, NULL);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_NAME);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(col, 200);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
/* only this column is activable */
exo_tree_view_set_activable_column((ExoTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Description"), render, "text", COL_FILE_DESC, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_DESC);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
g_object_set(render, "xalign", 1.0, NULL);
col = gtk_tree_view_column_new_with_attributes(_("Size"), render, "text", COL_FILE_SIZE, NULL);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_SIZE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Modified"), render, "text", COL_FILE_MTIME, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_MTIME);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
gtk_tree_view_set_search_column((GtkTreeView*)fv->view, COL_FILE_NAME);
gtk_tree_view_set_rubber_banding((GtkTreeView*)fv->view, TRUE);
exo_tree_view_set_single_click((ExoTreeView*)fv->view, fm_config->single_click);
exo_tree_view_set_single_click_timeout((ExoTreeView*)fv->view, SINGLE_CLICK_TIMEOUT);
ts = gtk_tree_view_get_selection((GtkTreeView*)fv->view);
g_signal_connect(fv->view, "row-activated", G_CALLBACK(on_tree_view_row_activated), fv);
g_signal_connect(ts, "changed", G_CALLBACK(on_sel_changed), fv);
/*cancel_pending_row_activated(fv);*/ /* FIXME: is this needed? */
gtk_tree_view_set_model((GtkTreeView*)fv->view, fv->model);
gtk_tree_selection_set_mode(ts, fv->sel_mode);
for(l = sels;l;l=l->next)
gtk_tree_selection_select_path(ts, (GtkTreePath*)l->data);
}
void gTree::setColumnResizable(int ind, bool vl)
{
GtkTreeViewColumn *col=gt_tree_view_find_column(GTK_TREE_VIEW(widget),ind);
if (!col) return;
gtk_tree_view_column_set_resizable(col,vl);
}
static void config_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *group;
GtkWidget *subgroup;
GtkWidget *button;
GtkWidget *tabcomp;
GtkWidget *ct_button;
GtkWidget *table;
GtkWidget *spin;
GtkWidget *scrolled;
GtkWidget *viewport;
GtkWidget *filter_view;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
configwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT (configwindow), "delete_event",
G_CALLBACK(config_window_delete), NULL);
gtk_window_set_resizable(GTK_WINDOW(configwindow), FALSE);
gtk_window_set_title(GTK_WINDOW(configwindow), _("GQview Preferences"));
gtk_window_set_wmclass(GTK_WINDOW(configwindow), "config", "GQview");
gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
window_set_icon(configwindow, PIXBUF_INLINE_ICON_CONFIG, NULL);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(configwindow), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
G_CALLBACK(config_window_ok_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
ct_button = button;
button = pref_button_new(NULL, GTK_STOCK_APPLY, NULL, FALSE,
G_CALLBACK(config_window_apply_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
G_CALLBACK(config_window_close_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
if (!generic_dialog_get_alternative_button_order(configwindow))
{
gtk_box_reorder_child(GTK_BOX(hbox), ct_button, -1);
}
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
/* general options tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("General"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Startup"), GTK_ORIENTATION_VERTICAL);
button = pref_checkbox_new_int(group, _("Change to folder:"),
startup_path_enable, &startup_path_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(button, hbox);
tabcomp = tab_completion_new(&startup_path_entry, startup_path, NULL, NULL);
tab_completion_add_select_button(startup_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
button = pref_button_new(hbox, NULL, _("Use current"), FALSE,
G_CALLBACK(startup_path_set_current), NULL);
group = pref_group_new(vbox, FALSE, _("Thumbnails"), GTK_ORIENTATION_VERTICAL);
table = pref_table_new(group, 2, 2, FALSE, FALSE);
add_thumb_size_menu(table, 0, 0, _("Size:"));
add_quality_menu(table, 0, 1, _("Quality:"), thumbnail_quality, &thumbnail_quality_c);
ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
enable_thumb_caching, &enable_thumb_caching_c);
subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity(ct_button, subgroup);
button = pref_checkbox_new_int(subgroup, _("Use shared thumbnail cache"),
thumbnail_spec_standard, &thumbnail_spec_standard_c);
subgroup = pref_box_new(subgroup, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity_swap(button, subgroup);
pref_checkbox_new_int(subgroup, _("Cache thumbnails into .thumbnails"),
enable_thumb_dirs, &enable_thumb_dirs_c);
#if 0
pref_checkbox_new_int(subgroup, _("Use xvpics thumbnails when found (read only)"),
use_xvpics_thumbnails, &use_xvpics_thumbnails_c);
#endif
pref_checkbox_new_int(group, _("Faster jpeg thumbnailing (may reduce quality)"),
thumbnail_fast, &thumbnail_fast_c);
group = pref_group_new(vbox, FALSE, _("Slide show"), GTK_ORIENTATION_VERTICAL);
slideshow_delay_c = slideshow_delay;
spin = pref_spin_new(group, _("Delay between image change:"), _("seconds"),
SLIDESHOW_MIN_SECONDS, SLIDESHOW_MAX_SECONDS, 1.0, 1,
slideshow_delay ? (double)slideshow_delay / SLIDESHOW_SUBSECOND_PRECISION : 10.0,
G_CALLBACK(slideshow_delay_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
pref_checkbox_new_int(group, _("Random"), slideshow_random, &slideshow_random_c);
pref_checkbox_new_int(group, _("Repeat"), slideshow_repeat, &slideshow_repeat_c);
/* image tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Image"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Zoom"), GTK_ORIENTATION_VERTICAL);
#if 0
add_dither_menu(dither_quality, &dither_quality_c, _("Dithering method:"), group);
#endif
table = pref_table_new(group, 2, 1, FALSE, FALSE);
add_quality_menu(table, 0, 0, _("Quality:"), zoom_quality, &zoom_quality_c);
pref_checkbox_new_int(group, _("Two pass zooming"),
two_pass_zoom, &two_pass_zoom_c);
pref_checkbox_new_int(group, _("Allow enlargement of image for zoom to fit"),
zoom_to_fit_expands, &zoom_to_fit_expands_c);
zoom_increment_c = zoom_increment;
spin = pref_spin_new(group, _("Zoom increment:"), NULL,
0.1, 4.0, 1.0, 1, (double)zoom_increment / 10.0,
G_CALLBACK(zoom_increment_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
group = pref_group_new(vbox, FALSE, _("When new image is selected:"), GTK_ORIENTATION_VERTICAL);
zoom_mode_c = zoom_mode;
button = pref_radiobutton_new(group, NULL, _("Zoom to original size"),
(zoom_mode == ZOOM_RESET_ORIGINAL),
G_CALLBACK(zoom_mode_original_cb), NULL);
button = pref_radiobutton_new(group, button, _("Fit image to window"),
(zoom_mode == ZOOM_RESET_FIT_WINDOW),
G_CALLBACK(zoom_mode_fit_cb), NULL);
button = pref_radiobutton_new(group, button, _("Leave Zoom at previous setting"),
(zoom_mode == ZOOM_RESET_NONE),
G_CALLBACK(zoom_mode_none_cb), NULL);
group = pref_group_new(vbox, FALSE, _("Appearance"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Black background"),
black_window_background, &black_window_background_c);
group = pref_group_new(vbox, FALSE, _("Convenience"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Refresh on file change"),
update_on_time_change, &update_on_time_change_c);
pref_checkbox_new_int(group, _("Preload next image"),
enable_read_ahead, &enable_read_ahead_c);
pref_checkbox_new_int(group, _("Auto rotate image using Exif information"),
exif_rotate_enable, &exif_rotate_enable_c);
/* window tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Windows"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("State"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Remember window positions"),
save_window_positions, &save_window_positions_c);
pref_checkbox_new_int(group, _("Remember tool state (float/hidden)"),
restore_tool, &restore_tool_c);
group = pref_group_new(vbox, FALSE, _("Size"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Fit window to image when tools are hidden/floating"),
fit_window, &fit_window_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
ct_button = pref_checkbox_new_int(hbox, _("Limit size when auto-sizing window (%):"),
limit_window_size, &limit_window_size_c);
spin = pref_spin_new_int(hbox, NULL, NULL,
10, 150, 1,
max_window_size, &max_window_size_c);
pref_checkbox_link_sensitivity(ct_button, spin);
group = pref_group_new(vbox, FALSE, _("Layout"), GTK_ORIENTATION_VERTICAL);
layout_widget = layout_config_new();
layout_config_set(layout_widget, layout_style, layout_order);
gtk_box_pack_start(GTK_BOX(group), layout_widget, FALSE, FALSE, 0);
gtk_widget_show(layout_widget);
/* filtering tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER (vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Filtering"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_new_int(group, _("Show entries that begin with a dot"),
show_dot_files, &show_dot_files_c);
pref_checkbox_new_int(group, _("Case sensitive sort"),
file_sort_case_sensitive, &file_sort_case_sensitive_c);
ct_button = pref_checkbox_new_int(group, _("Disable File Filtering"),
file_filter_disable, &file_filter_disable_c);
group = pref_group_new(vbox, TRUE, _("File types"), GTK_ORIENTATION_VERTICAL);
frame = pref_group_parent(group);
g_signal_connect(G_OBJECT(ct_button), "toggled",
G_CALLBACK(filter_disable_cb), frame);
gtk_widget_set_sensitive(frame, !file_filter_disable);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
filter_store = gtk_list_store_new(1, G_TYPE_POINTER);
filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store));
g_object_unref(filter_store);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Filter"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(filter_store_enable_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_ENABLE), NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_ext_edit_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_EXTENSION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Description"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_desc_edit_cb), filter_store);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_DESCRIPTION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
filter_store_populate();
gtk_container_add(GTK_CONTAINER(scrolled), filter_view);
gtk_widget_show(filter_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(filter_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_REMOVE, NULL, FALSE,
G_CALLBACK(filter_remove_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_ADD, NULL, FALSE,
G_CALLBACK(filter_add_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* editor entry tab */
vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Editors"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
table = pref_table_new(vbox, 3, 9, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("#"), 1.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("Command Line"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < GQVIEW_EDITOR_SLOTS; i++)
{
gchar *buf;
buf = g_strdup_printf("%d", i+1);
pref_table_label(table, 0, i+1, buf, 1.0);
g_free(buf);
editor_name_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_name_entry[i]), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i],80,-1);
if (editor_name[i]) gtk_entry_set_text(GTK_ENTRY(editor_name_entry[i]),editor_name[i]);
gtk_table_attach(GTK_TABLE (table),editor_name_entry[i],1,2,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_name_entry[i]);
editor_command_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_command_entry[i]), EDITOR_COMMAND_MAX_LENGTH);
gtk_widget_set_size_request(editor_command_entry[i],160,-1);
tab_completion_add_to_entry(editor_command_entry[i], NULL, NULL);
if (editor_command[i]) gtk_entry_set_text(GTK_ENTRY(editor_command_entry[i]), editor_command[i]);
gtk_table_attach(GTK_TABLE (table),editor_command_entry[i],2,3,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_command_entry[i]);
}
hbox = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(editor_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
G_CALLBACK(editor_help_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* advanced entry tab */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
label = gtk_label_new(_("Advanced"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled, label);
gtk_widget_show(scrolled);
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled), viewport);
gtk_widget_show(viewport);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), vbox);
gtk_widget_show(vbox);
group = pref_group_new(vbox, FALSE, _("Full screen"), GTK_ORIENTATION_VERTICAL);
fullscreen_screen_c = fullscreen_screen;
fullscreen_above_c = fullscreen_above;
hbox = fullscreen_prefs_selection_new(_("Location:"), &fullscreen_screen_c, &fullscreen_above_c);
gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
pref_checkbox_new_int(group, _("Smooth image flip"),
fullscreen_clean_flip, &fullscreen_clean_flip_c);
pref_checkbox_new_int(group, _("Disable screen saver"),
fullscreen_disable_saver, &fullscreen_disable_saver_c);
group = pref_group_new(vbox, FALSE, _("Delete"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Confirm file delete"),
confirm_delete, &confirm_delete_c);
pref_checkbox_new_int(group, _("Enable Delete key"),
enable_delete_key, &enable_delete_key_c);
ct_button = pref_checkbox_new_int(group, _("Safe delete"),
safe_delete_enable, &safe_delete_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
tabcomp = tab_completion_new(&safe_delete_path_entry, safe_delete_path, NULL, NULL);
tab_completion_add_select_button(safe_delete_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_GAP);
pref_spin_new_int(hbox, _("Maximum size:"), _("MB"),
1, 500, 1, safe_delete_size, &safe_delete_size_c);
button = pref_button_new(NULL, NULL, _("View"), FALSE,
G_CALLBACK(safe_delete_view_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CLEAR, NULL, FALSE,
G_CALLBACK(safe_delete_clear_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
group = pref_group_new(vbox, FALSE, _("Behavior"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Rectangular selection in icon view"),
collection_rectangular_selection, &collection_rectangular_selection_c);
pref_checkbox_new_int(group, _("Descend folders in tree view"),
tree_descend_subdirs, &tree_descend_subdirs_c);
pref_checkbox_new_int(group, _("In place renaming"),
enable_in_place_rename, &enable_in_place_rename_c);
group = pref_group_new(vbox, FALSE, _("Navigation"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
progressive_key_scrolling, &progressive_key_scrolling_c);
pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
mousewheel_scrolls, &mousewheel_scrolls_c);
group = pref_group_new(vbox, FALSE, _("Miscellaneous"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Store keywords and comments local to source images"),
enable_metadata_dirs, &enable_metadata_dirs_c);
pref_spin_new_int(group, _("Custom similarity threshold:"), NULL,
0, 100, 1, dupe_custom_threshold, &dupe_custom_threshold_c);
pref_spin_new_int(group, _("Offscreen cache size (Mb per image):"), NULL,
0, 128, 1, tile_cache_max, &tile_cache_max_c);
group = pref_group_new(vbox, FALSE, _("Color profiles"), GTK_ORIENTATION_VERTICAL);
#ifndef HAVE_LCMS
gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
#endif
table = pref_table_new(group, 3, COLOR_PROFILE_INPUTS + 2, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("Type"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("File"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
GtkWidget *entry;
gchar *buf;
buf = g_strdup_printf("Input %d:", i + 1);
pref_table_label(table, 0, i + 1, buf, 1.0);
g_free(buf);
entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i], 30, -1);
if (color_profile_input_name[i]) gtk_entry_set_text(GTK_ENTRY(entry), color_profile_input_name[i]);
gtk_table_attach(GTK_TABLE(table), entry, 1, 2, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(entry);
color_profile_input_name_entry[i] = entry;
tabcomp = tab_completion_new(&entry, color_profile_input_file[i], NULL, NULL);
tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
color_profile_input_file_entry[i] = entry;
}
pref_table_label(table, 0, COLOR_PROFILE_INPUTS + 1, _("Screen:"), 1.0);
tabcomp = tab_completion_new(&color_profile_screen_file_entry,
color_profile_screen_file, NULL, NULL);
tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3,
COLOR_PROFILE_INPUTS + 1, COLOR_PROFILE_INPUTS + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
gtk_widget_show(notebook);
gtk_widget_show(configwindow);
}
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);
}
static void
log_window_find_setup (EmpathyLogWindow *window)
{
GtkTreeView *view;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeSortable *sortable;
GtkTreeViewColumn *column;
GtkListStore *store;
GtkCellRenderer *cell;
gint offset;
view = GTK_TREE_VIEW (window->treeview_find);
selection = gtk_tree_view_get_selection (view);
/* New store */
store = gtk_list_store_new (COL_FIND_COUNT,
G_TYPE_STRING, /* account icon name */
G_TYPE_STRING, /* account name */
TP_TYPE_ACCOUNT, /* account */
G_TYPE_STRING, /* chat name */
G_TYPE_STRING, /* chat id */
G_TYPE_BOOLEAN, /* is chatroom */
G_TYPE_STRING, /* date */
G_TYPE_STRING); /* date_readable */
model = GTK_TREE_MODEL (store);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_view_set_model (view, model);
/* New column */
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell,
"icon-name",
COL_FIND_ACCOUNT_ICON);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell,
"text",
COL_FIND_ACCOUNT_NAME);
gtk_tree_view_column_set_title (column, _("Account"));
gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"),
cell, "text", COL_FIND_CHAT_NAME,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"),
cell, "text", COL_FIND_DATE_READABLE,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
/* Set up treeview properties */
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
gtk_tree_sortable_set_sort_column_id (sortable,
COL_FIND_DATE,
GTK_SORT_ASCENDING);
/* Set up signals */
g_signal_connect (selection, "changed",
G_CALLBACK (log_window_find_changed_cb),
window);
g_object_unref (store);
}
void
ephy_permissions_dialog_add_tab (EphyPermissionsDialog *dialog,
const char *type,
const char *title)
{
EphyPermissionsDialogPrivate *priv = dialog->priv;
GtkWidget *hbox, *view, *vbuttonbox, *button;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeView *treeview;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
DialogTab *tab;
tab = g_new0 (DialogTab, 1);
tab->dialog = dialog;
tab->type = g_strdup (type);
tab->qtype = g_quark_from_string (type);
tab->filled = FALSE;
priv->tabs = g_list_prepend (priv->tabs, tab);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
g_object_set_data (G_OBJECT (hbox), TAB_DATA_KEY, tab);
view = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
GTK_POLICY_NEVER /* FIXME? */,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), view, TRUE, TRUE, 0);
tab->store = store = gtk_list_store_new (2,
G_TYPE_STRING,
G_TYPE_STRING);
tab->model = GTK_TREE_MODEL (store);
tab->treeview = treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (tab->model));
g_object_unref (store);
g_signal_connect (treeview, "key-press-event",
G_CALLBACK (treeview_key_press_event_cb), tab);
gtk_tree_view_set_headers_visible (treeview, TRUE);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview,
COL_HOST,
_("Domain"),
renderer,
"text", COL_HOST,
NULL);
column = gtk_tree_view_get_column (treeview, COL_HOST);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, COL_HOST);
gtk_tree_view_insert_column_with_attributes (treeview,
COL_PERM,
_("State"),
renderer,
"text", COL_PERM,
NULL);
column = gtk_tree_view_get_column (treeview, COL_PERM);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, COL_PERM);
gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (treeview));
tab->selection = selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
g_signal_connect (selection, "changed",
G_CALLBACK (treeview_selection_changed_cb), tab);
/* Button box */
vbuttonbox = gtk_vbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox),
GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (hbox), vbuttonbox, FALSE, FALSE, 0);
/* Remove button */
tab->remove_button = button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
g_signal_connect (button, "clicked",
G_CALLBACK (remove_button_clicked_cb), tab);
gtk_box_pack_start (GTK_BOX (vbuttonbox), button, FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->buttons_size_group, button);
gtk_widget_show_all (hbox);
/* And finally insert it in the notebook */
gtk_notebook_append_page (priv->notebook, hbox,
gtk_label_new (title));
}
/* public methods implementation */
GtkWidget *
book_view_gtk_new (Ekiga::BookPtr book)
{
BookViewGtk *result = NULL;
GtkWidget *label = NULL;
GtkWidget *hbox = NULL;
GtkWidget *button = NULL;
GtkTreeSelection *selection = NULL;
GtkListStore *store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
result = (BookViewGtk *) g_object_new (BOOK_VIEW_GTK_TYPE, NULL);
result->priv = new _BookViewGtkPrivate (book);
result->priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_shadow_type (GTK_FRAME (result), GTK_SHADOW_NONE);
/* The Search Box */
boost::shared_ptr<Ekiga::Filterable> filtered = boost::dynamic_pointer_cast<Ekiga::Filterable> (book);
if (filtered) {
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
result->priv->entry = gtk_entry_new ();
button = gtk_button_new_from_stock (GTK_STOCK_FIND);
label = gtk_label_new_with_mnemonic (_("_Search Filter:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), result->priv->entry, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (result->priv->vbox), hbox, FALSE, FALSE, 0);
g_signal_connect (result->priv->entry, "activate",
G_CALLBACK (on_entry_activated_cb), result);
g_signal_connect (button, "clicked",
G_CALLBACK (on_button_clicked_cb), result);
} else {
result->priv->entry = NULL;
}
/* The List Store */
result->priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
(result->priv->scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
result->priv->tree_view = GTK_TREE_VIEW (gtk_tree_view_new ());
gtk_tree_view_set_headers_visible (result->priv->tree_view, FALSE);
gtk_container_add (GTK_CONTAINER (result), GTK_WIDGET (result->priv->vbox));
gtk_box_pack_start (GTK_BOX (result->priv->vbox),
GTK_WIDGET (result->priv->scrolled_window), TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (result->priv->scrolled_window),
GTK_WIDGET (result->priv->tree_view));
selection = gtk_tree_view_get_selection (result->priv->tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), result);
g_signal_connect (result->priv->tree_view, "event-after",
G_CALLBACK (on_contact_clicked), result);
store = gtk_list_store_new (COLUMN_NUMBER,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
G_TYPE_STRING);
gtk_tree_view_set_model (result->priv->tree_view, GTK_TREE_MODEL (store));
g_object_unref (store);
/* Name */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", COLUMN_PIXBUF, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_column_set_title (column, _("Full Name"));
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (column, true);
gtk_tree_view_append_column (GTK_TREE_VIEW (result->priv->tree_view), column);
/* The status bar */
result->priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (result->priv->vbox), result->priv->statusbar, FALSE, TRUE, 0);
/* connect to the signals */
result->priv->connections.add (book->contact_added.connect (boost::bind (&on_contact_added, _1, (gpointer)result)));
result->priv->connections.add (book->contact_updated.connect (boost::bind (&on_contact_updated, _1, (gpointer)result)));
result->priv->connections.add (book->contact_removed.connect (boost::bind (&on_contact_removed, _1, (gpointer)result)));
result->priv->connections.add (book->updated.connect (boost::bind (&on_updated, (gpointer)result)));
/* populate */
book->visit_contacts (boost::bind (&on_visit_contacts, _1, (gpointer)result));
return (GtkWidget *) result;
}
static void
gtr_message_table_init (GtrMessageTable * table)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtrMessageTablePrivate *priv;
priv = gtr_message_table_get_instance_private (table);
gtk_orientable_set_orientation (GTK_ORIENTABLE (table),
GTK_ORIENTATION_VERTICAL);
gtk_widget_init_template (GTK_WIDGET (table));
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (_("Status"),
renderer,
"icon-name",
GTR_MESSAGE_TABLE_MODEL_ICON_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id (column,
GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("ID"),
renderer,
"text",
GTR_MESSAGE_TABLE_MODEL_ID_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id (column,
GTR_MESSAGE_TABLE_MODEL_ID_COLUMN);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
g_object_set (renderer, "xalign", 1.0, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Original Message"),
renderer,
"text",
GTR_MESSAGE_TABLE_MODEL_ORIGINAL_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id (column,
GTR_MESSAGE_TABLE_MODEL_ORIGINAL_COLUMN);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Translated Message"),
renderer,
"text",
GTR_MESSAGE_TABLE_MODEL_TRANSLATION_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id (column,
GTR_MESSAGE_TABLE_MODEL_TRANSLATION_COLUMN);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (gtr_message_table_selection_changed), table);
}
MimeView *mimeview_create(void)
{
MimeView *mimeview;
GtkWidget *paned;
GtkWidget *scrolledwin;
GtkWidget *treeview;
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *mime_vbox;
GtkWidget *popupmenu;
GtkItemFactory *popupfactory;
gint n_entries;
GtkWidget *reply_separator;
GtkWidget *reply_menuitem;
GList *child;
debug_print(_("Creating MIME view...\n"));
mimeview = g_new0(MimeView, 1);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_widget_set_size_request(scrolledwin, -1, 80);
store = gtk_tree_store_new(N_COLS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_NAME);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Data type"), renderer, "text", COL_MIMETYPE, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Size"), renderer, "text", COL_SIZE, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Name"), renderer, "text", COL_NAME, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_enable_model_drag_source
(GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK,
mimeview_mime_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(mimeview_selection_changed), mimeview);
g_signal_connect(G_OBJECT(treeview), "button_press_event",
G_CALLBACK(mimeview_button_pressed), mimeview);
g_signal_connect(G_OBJECT(treeview), "key_press_event",
G_CALLBACK(mimeview_key_pressed), mimeview);
g_signal_connect_after(G_OBJECT (treeview),"drag-begin",
G_CALLBACK (mimeview_drag_begin), mimeview);
g_signal_connect(G_OBJECT (treeview),"drag-end",
G_CALLBACK (mimeview_drag_end), mimeview);
g_signal_connect(G_OBJECT(treeview), "drag-data-get",
G_CALLBACK(mimeview_drag_data_get), mimeview);
mime_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_reallocate_redraws(GTK_CONTAINER(mime_vbox), TRUE);
paned = gtk_vpaned_new();
gtk_paned_add1(GTK_PANED(paned), scrolledwin);
gtk_paned_add2(GTK_PANED(paned), mime_vbox);
n_entries = sizeof(mimeview_popup_entries) /
sizeof(mimeview_popup_entries[0]);
popupmenu = menu_create_items(mimeview_popup_entries, n_entries,
"<MimeView>", &popupfactory, mimeview);
reply_menuitem = gtk_item_factory_get_item(popupfactory, "/Reply");
child = g_list_find(GTK_MENU_SHELL(popupmenu)->children,
reply_menuitem);
reply_separator = GTK_WIDGET(child->prev->data);
mimeview->paned = paned;
mimeview->scrolledwin = scrolledwin;
mimeview->treeview = treeview;
mimeview->store = store;
mimeview->selection = selection;
mimeview->mime_vbox = mime_vbox;
mimeview->popupmenu = popupmenu;
mimeview->popupfactory = popupfactory;
mimeview->reply_separator = reply_separator;
mimeview->reply_menuitem = reply_menuitem;
mimeview->type = -1;
return mimeview;
}
/**
* create the page 2 of the assistant
* this page permit to choose the archive to export
*
* \param assistant the GtkWidget assistant
*
* \return a GtkWidget containing the page
* */
static GtkWidget *gsb_assistant_archive_export_page_choose ( GtkWidget *assistant )
{
GtkWidget *vbox_page, *scrolled_window;
GtkWidget *paddingbox;
GtkListStore *archive_model;
gchar *titles[] = {
"", _("Name"), _("Initial date"), _("Final date"), _("Financial year"), _("Report name")
};
gfloat alignment[] = {
COLUMN_CENTER, COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER , COLUMN_CENTER, COLUMN_CENTER
};
gint i;
GSList *tmp_list;
/* create the page */
vbox_page = gtk_vbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER(vbox_page), 12 );
paddingbox = new_paddingbox_with_title (vbox_page, TRUE,
_("Select the archive to export"));
/* Create scrolled window */
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_SHADOW_IN);
gtk_box_pack_start ( GTK_BOX (paddingbox),
scrolled_window,
TRUE, TRUE, 0 );
/* Create tree view */
archive_model = gtk_list_store_new (NUM_ARCHIVES_EXPORT_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT );
archive_export_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (archive_model) );
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (archive_export_treeview), TRUE);
gtk_container_add ( GTK_CONTAINER (scrolled_window),
archive_export_treeview );
/* set the columns */
for (i=0 ; i<6 ; i++)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_sizing ( column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE );
gtk_tree_view_column_set_alignment ( column,
alignment[i] );
gtk_tree_view_column_set_title ( column, titles[i] );
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_column_set_resizable ( column,
TRUE );
if (i)
{
/* we are on a text column */
renderer = gtk_cell_renderer_text_new ();
g_object_set ( G_OBJECT (renderer),
"xalign", alignment[i],
NULL );
gtk_tree_view_column_pack_start ( column, renderer, TRUE );
gtk_tree_view_column_set_attributes (column, renderer,
"text", i,
NULL);
}
else
{
/* we are on the select column */
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer,
"toggled",
G_CALLBACK (gsb_assistant_archive_export_toggled),
assistant );
gtk_tree_view_column_pack_start ( column, renderer, TRUE );
gtk_tree_view_column_set_attributes (column, renderer,
"active", i,
NULL);
}
gtk_tree_view_append_column ( GTK_TREE_VIEW(archive_export_treeview), column);
}
/* fill the list */
tmp_list = gsb_data_archive_get_archives_list ();
while ( tmp_list )
{
gint archive_number;
GtkTreeIter iter;
gchar *init_date;
gchar *final_date;
archive_number = gsb_data_archive_get_no_archive (tmp_list -> data);
init_date = gsb_format_gdate (gsb_data_archive_get_beginning_date (archive_number));
final_date = gsb_format_gdate (gsb_data_archive_get_end_date (archive_number));
gtk_list_store_append ( GTK_LIST_STORE (archive_model),
&iter );
gtk_list_store_set ( GTK_LIST_STORE (archive_model),
&iter,
ARCHIVES_EXPORT_NAME_COLUMN, gsb_data_archive_get_name (archive_number),
ARCHIVES_EXPORT_INIT_DATE, init_date,
ARCHIVES_EXPORT_FINAL_DATE, final_date,
ARCHIVES_EXPORT_FYEAR_NAME, gsb_data_fyear_get_name (gsb_data_archive_get_fyear (archive_number)),
ARCHIVES_EXPORT_REPORT_TITLE, gsb_data_archive_get_report_title (archive_number),
ARCHIVES_EXPORT_NUMBER, archive_number,
-1 );
if (init_date)
g_free (init_date);
if (final_date)
g_free (final_date);
tmp_list = tmp_list -> next;
}
gtk_widget_show_all (vbox_page);
return ( vbox_page );
}
/*
* inits stack trace tree
*/
GtkWidget* stree_init(move_to_line_cb cb)
{
callback = cb;
/* create tree view */
store = gtk_tree_store_new (
S_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT);
model = GTK_TREE_MODEL(store);
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
/* set tree view properties */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1);
gtk_widget_set_has_tooltip(tree, TRUE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
/* connect signals */
selection_callback = g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree))), "changed", G_CALLBACK (on_selection_changed), NULL);
/* for clicking on already selected frame */
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(on_msgwin_button_press), NULL);
g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL);
/* creating columns */
GtkTreeViewColumn *column;
/* address */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Address"));
GtkCellRenderer *renderer_arrow = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start(column, renderer_arrow, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer_arrow, on_render_icon, NULL, NULL);
GtkCellRenderer *renderer_address = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start(column, renderer_address, TRUE);
gtk_tree_view_column_set_attributes(column, renderer_address, "text", S_ADRESS, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* function */
GtkCellRenderer *renderer_function = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Function"), renderer_function, "text", S_FUNCTION, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* file */
GtkCellRenderer *renderer_file = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("File"), renderer_file, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_cell_data_func(column, renderer_file, on_render_filename, NULL, NULL);
/* line */
GtkCellRenderer *renderer_line = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer_line, "text", S_LINE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer_line, on_render_line, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
GtkCellRenderer *renderer_last = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer_last, "text", S_LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* create threads hash table */
threads = g_hash_table_new_full(
g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)gtk_tree_row_reference_free
);
return tree;
}
static void editor_list_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *scrolled;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkTreeModel *store;
GtkTreeSortable *sortable;
EditorListWindow *ewl;
editor_list_window = ewl = g_new0(EditorListWindow, 1);
ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Plugins"));
DEBUG_NAME(ewl->window);
gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(ewl->window), "delete_event",
G_CALLBACK(editor_list_window_delete), NULL);
gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
G_CALLBACK(editor_list_window_help_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE,
G_CALLBACK(editor_list_window_new_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE,
G_CALLBACK(editor_list_window_edit_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->edit_button = button;
button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE,
G_CALLBACK(editor_list_window_delete_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->delete_button = button;
button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
G_CALLBACK(editor_list_window_close_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Disabled"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(plugin_disable_cb), ewl);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, plugin_disable_set_func,
NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_DISABLED);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Hidden"));
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_column_set_alignment(column, 0.5);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Desktop file"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Path"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH);
/* set up sorting */
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_DISABLED, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_DISABLED), NULL);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_NAME, GTK_SORT_ASCENDING);
gtk_container_add(GTK_CONTAINER(scrolled), ewl->view);
gtk_widget_show(ewl->view);
gtk_widget_show(ewl->window);
}
GtkWidget *
create_directory_treeview (void)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
GtkWidget *scrolled;
GtkWidget *tvw = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "treeview1"));
g_signal_connect (tvw, "row-expanded",
G_CALLBACK (on_tv_row_expanded), NULL);
g_signal_connect (tvw, "cursor-changed",
G_CALLBACK (on_tv_cur_changed), NULL);
g_signal_connect (tvw, "button-press-event",
G_CALLBACK (on_tv_button_press), NULL);
/* dir name column */
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tvw)), "changed",
G_CALLBACK (on_tv_selection_changed), NULL);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_NAME, "text",
COL_DIR_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_DIR_NAME);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Folder"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* percentage bar & text column */
col = gtk_tree_view_column_new ();
cell = baobab_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_attributes (col, cell, "perc",
COL_H_PERC, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (col, cell,
perc_cell_data_func,
NULL, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_PERC);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Usage"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* directory size column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_SIZE, "text",
COL_DIR_SIZE, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col,
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Size"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* store this column, we need it when toggling 'allocated' */
g_object_set_data (G_OBJECT (tvw), "baobab_size_col", col);
/* objects column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_ELEMENTS, "text",
COL_ELEMENTS, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_ELEMENTS);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Contents"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* hardlink column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_HARDLINK, "text",
COL_HARDLINK, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (tvw));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tvw), FALSE);
scrolled = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "scrolledwindow1"));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tvw),
baobab_treeview_equal_func,
NULL, NULL);
baobab.model = create_model ();
/* By default, sort by size */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE,
GTK_SORT_DESCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tvw),
GTK_TREE_MODEL (baobab.model));
g_object_unref (baobab.model);
return tvw;
}
static void tree_gui_init_treeview(tree_gui_t *gui)
{
//GtkTooltips *tooltips;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* Get tooltips engine */
//tooltips = gtk_object_get_data(GTK_OBJECT(gui->window), "tooltips");
/* Create test tree */
gui->tree_model = gtk_tree_store_new(TREE_GUI_NCOLS,
/* TREE_GUI_COL_TYPE_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_NAME */ G_TYPE_STRING,
/* TREE_GUI_COL_BRKPT_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_BRKPT */ G_TYPE_INT,
/* TREE_GUI_COL_FLAGS_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_SKIP */ G_TYPE_INT,
/* TREE_GUI_COL_VERDICT_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_CRITICITY */ G_TYPE_STRING,
/* TREE_GUI_COL_CRITICITY_COLOR */ G_TYPE_STRING,
/* TREE_GUI_COL_BACKGROUND */ GDK_TYPE_COLOR,
/* TREE_GUI_COL_STYLE */ PANGO_TYPE_STYLE,
/* TREE_GUI_COL_KEY */ G_TYPE_ULONG,
/* TREE_GUI_COL_OBJECT */ G_TYPE_POINTER);
gui->tree_view = GTK_TREE_VIEW(lookup_widget(gui->window, "tree_view"));
gtk_tree_view_set_model(gui->tree_view, GTK_TREE_MODEL(gui->tree_model));
/* Setup tree selection handler */
gui->tree_selection = gtk_tree_view_get_selection(gui->tree_view);
gtk_tree_selection_set_mode(gui->tree_selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(gui->tree_selection,
(GtkTreeSelectionFunc) tree_gui_select, gui,
NULL);
/* Set up row activation handler */
gtk_signal_connect(GTK_OBJECT(gui->tree_view), "row-activated",
GTK_SIGNAL_FUNC(tree_gui_row_activated), gui);
/* Column #0: breakpoint flag */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Brk", renderer,
"pixbuf", TREE_GUI_COL_BRKPT_PIXBUF,
"cell-background-gdk", TREE_GUI_COL_BACKGROUND,
NULL);
/* Setup breakpoints clear button */
column = gtk_tree_view_get_column(gui->tree_view, 0);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_clickable(column, TRUE);
// TODO: gtk_tooltips_set_tip (tooltips, w, "Clear all breakpoints", NULL);
gtk_signal_connect_object(GTK_OBJECT(column), "clicked",
GTK_SIGNAL_FUNC(tree_gui_breakpoint_clear_clicked), gui);
/* Column #1: Node pix and name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Test Tree");
gtk_tree_view_column_set_expand(column, TRUE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_TYPE_PIXBUF);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
renderer = gtk_cell_renderer_text_new();
//gtk_object_set(GTK_OBJECT(renderer), "family", "Monospace", NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_NAME);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
gtk_tree_view_column_add_attribute(column, renderer, "style", TREE_GUI_COL_STYLE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(gui->tree_view, column);
gtk_tree_view_set_expander_column(gui->tree_view, column);
/* Setup selection clear button */
gtk_tree_view_column_set_clickable(column, TRUE);
// TODO: gtk_tooltips_set_tip (tooltips, w, "Clear selection", NULL);
gtk_signal_connect_object(GTK_OBJECT(column), "clicked",
GTK_SIGNAL_FUNC(tree_gui_unselect), gui);
/* Column #2: runtime flag */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Flg", renderer,
"pixbuf", TREE_GUI_COL_FLAGS_PIXBUF,
"cell-background-gdk", TREE_GUI_COL_BACKGROUND,
NULL);
/* Column #3: verdict and criticity */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Verdict");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_VERDICT_PIXBUF);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.6, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_CRITICITY);
gtk_tree_view_column_add_attribute(column, renderer, "foreground", TREE_GUI_COL_CRITICITY_COLOR);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(gui->tree_view, column);
}
static void xmi_msim_gui_layer_dialog_init(XmiMsimGuiLayerDialog *dialog) {
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_dialog_add_buttons(GTK_DIALOG(dialog), "_Ok", GTK_RESPONSE_ACCEPT, "_Cancel", GTK_RESPONSE_REJECT, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_default_size(GTK_WINDOW(dialog), 200, 200);
GtkWidget *contentArea = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *mainVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous(GTK_BOX(mainVBox), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(mainVBox),5);
gtk_container_add(GTK_CONTAINER(contentArea), mainVBox);
GtkListStore *store = gtk_list_store_new(N_COLUMNS_LAYER, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_INT);
//construct tree
GtkWidget *HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
GtkWidget *compositionTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Element", renderer, "text", SYMBOL_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);
renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
column = gtk_tree_view_column_new_with_attributes("Weight fraction (%)", renderer, "text", WEIGHT_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);
GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(scrolledWindow, 220, 150);
gtk_container_add(GTK_CONTAINER(scrolledWindow), compositionTreeView);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_container_add(GTK_CONTAINER(frame), scrolledWindow);
gtk_box_pack_start(GTK_BOX(HBox), frame, FALSE, FALSE, 3);
//selections
GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(compositionTreeView));
gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(element_selection_changed), (gpointer) dialog);
//add/edit/remove
GtkWidget *VBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous(GTK_BOX(VBox), FALSE);
GtkWidget *addButton = gtk_button_new_with_mnemonic("_Add");
GtkWidget *editButton = gtk_button_new_with_mnemonic("_Edit");
GtkWidget *removeButton = gtk_button_new_with_mnemonic("_Remove");
GtkWidget *predefButton = gtk_button_new_with_label("Load from catalog");
GtkWidget *addToCatalogButton = gtk_button_new_with_label("Add to catalog");
gtk_widget_set_sensitive(addButton, TRUE);
gtk_widget_set_sensitive(editButton, FALSE);
gtk_widget_set_sensitive(removeButton, FALSE);
gtk_widget_set_sensitive(predefButton, TRUE);
gtk_widget_set_sensitive(addToCatalogButton, FALSE);
gtk_box_pack_start(GTK_BOX(VBox), addButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), editButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), removeButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), predefButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), addToCatalogButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(HBox),VBox, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(addButton), "clicked", G_CALLBACK(add_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(editButton), "clicked", G_CALLBACK(edit_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(removeButton), "clicked", G_CALLBACK(remove_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(predefButton), "clicked", G_CALLBACK(predef_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(addToCatalogButton), "clicked", G_CALLBACK(add_to_catalog_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(compositionTreeView), "row-activated", G_CALLBACK(element_row_activated), (gpointer) dialog);
//Sum and normalize
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
GtkWidget *label = gtk_label_new("Weights sum (%)");
GtkWidget *sumLabel = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(sumLabel), GTK_JUSTIFY_CENTER);
GtkWidget *normalizeButton = gtk_button_new_with_label("Normalize");
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(HBox), sumLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(HBox), normalizeButton, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(normalizeButton), "clicked", G_CALLBACK(normalize_button_clicked), (gpointer) dialog);
//separator
GtkWidget *separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(mainVBox), separator, FALSE, FALSE, 3);
//Density and thickness
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),"Density (g/cm<sup>3</sup>)");
GtkWidget *densityEntry = gtk_entry_new();
gtk_widget_set_name(densityEntry, "color_entry");
gtk_entry_set_activates_default(GTK_ENTRY(densityEntry), TRUE);
gulong density_changed = g_signal_connect(G_OBJECT(densityEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), densityEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
label = gtk_label_new("Thickness (cm)");
GtkWidget *thicknessEntry = gtk_entry_new();
gtk_widget_set_name(thicknessEntry, "color_entry");
gtk_entry_set_activates_default(GTK_ENTRY(thicknessEntry), TRUE);
gulong thickness_changed = g_signal_connect(G_OBJECT(thicknessEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), thicknessEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
dialog->addButton = addButton;
dialog->editButton = editButton;
dialog->removeButton = removeButton;
dialog->predefButton = predefButton;
dialog->addToCatalogButton = addToCatalogButton;
dialog->normalizeButton = normalizeButton;
dialog->sumLabel = sumLabel;
dialog->densityEntry = densityEntry;
dialog->thicknessEntry = thicknessEntry;
dialog->compositionTreeView = compositionTreeView;
dialog->density_changed = density_changed;
dialog->thickness_changed = thickness_changed;
g_signal_connect(G_OBJECT(compositionTreeView), "key-press-event", G_CALLBACK(backspace_key_clicked), (gpointer) dialog);
gtk_widget_show_all(contentArea);
}
static void remmina_main_init(RemminaMain *remminamain)
{
RemminaMainPriv *priv;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *quickconnect;
GtkWidget *tool_item;
GtkUIManager *uimanager;
GtkActionGroup *action_group;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GError *error;
priv = g_new0(RemminaMainPriv, 1);
remminamain->priv = priv;
remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
/* Create main window */
g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL);
g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL);
g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0);
gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client"));
gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height);
gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER);
if (remmina_pref.main_maximize)
{
gtk_window_maximize(GTK_WINDOW(remminamain));
}
/* Create the main container */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_container_add(GTK_CONTAINER(remminamain), vbox);
gtk_widget_show(vbox);
/* Create the menubar and toolbar */
uimanager = gtk_ui_manager_new();
priv->uimanager = uimanager;
action_group = gtk_action_group_new("RemminaMainActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries),
remminamain);
gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries,
G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain);
gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries,
G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode,
G_CALLBACK(remmina_main_action_view_file_mode), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->main_group = action_group;
action_group = gtk_action_group_new("RemminaMainFileSensitiveActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries,
G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->file_sensitive_group = action_group;
error = NULL;
gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
}
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar");
#if GTK_VERSION == 3
gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
remmina_main_create_quick_search(remminamain);
gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager));
gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE);
/* Add a Fast Connection box */
#if GTK_VERSION == 3
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif GTK_VERSION == 2
hbox = gtk_hbox_new(FALSE, 0);
#endif
priv->quickconnect_protocol = gtk_combo_box_text_new();
#if GTK_VERSION == 3
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH");
#elif GTK_VERSION == 2
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0);
gtk_widget_show(priv->quickconnect_protocol);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0);
priv->quickconnect_server = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25);
gtk_widget_show(priv->quickconnect_server);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain);
quickconnect = gtk_button_new_with_label("Connect !");
gtk_widget_show(quickconnect);
gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
gtk_widget_show(hbox);
/* Create the scrolled window for the file list */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
/* Create the remmina file list */
tree = gtk_tree_view_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN);
g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
priv->group_column = column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
gtk_widget_show(tree);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func,
remminamain, NULL);
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain);
priv->file_list = tree;
/* Create statusbar */
priv->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show(priv->statusbar);
/* Prepare the data */
remmina_main_load_files(remminamain, FALSE);
/* Load the preferences */
if (remmina_pref.hide_toolbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")),
FALSE);
}
if (remmina_pref.hide_statusbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")),
FALSE);
}
if (remmina_pref.show_quick_search)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE);
}
if (remmina_pref.small_toolbutton)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE);
}
/* Drag-n-drop support */
gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL);
priv->initialized = TRUE;
remmina_widget_pool_register(GTK_WIDGET(remminamain));
}
static int build_table_from_csv_fh(FILE *in, GtkWidget **ret_view, GtkTreeModel **ret_store, GtkProgressBar *progress)
{
GType *column_types;
int n, ncol, nrow=0;
int sep = ',';
GtkListStore *store=NULL;
GtkWidget *view=NULL;
if (csv_row_fread(in,
(unsigned char *)csv_buf,
CSV_BUFSIZE,
(unsigned char **)csv_row,
CSV_COLS,
sep,
CSV_QUOTES) > 0) {
/* Create model with number of columns matching the csv input */
for(ncol=0; csv_row[ncol]; ncol++);
column_types = malloc(sizeof(GType) * ncol);
for (n=0; n<ncol; n++) {
column_types[n] = G_TYPE_STRING;
}
store = gtk_list_store_newv(ncol, column_types);
free(column_types);
/* Create view, add colums */
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
for (n = 0; n < ncol; n++) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(csv_row[n], renderer, "text", n, NULL);
/* gtk_tree_view_column_set_sort_column_id(column, n); */
/* gtk_tree_view_column_set_reorderable(column, TRUE); */
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, n);
}
/* Populate model */
GtkTreeIter iter;
if (progress) {
gtk_progress_bar_set_fraction(progress, 0.0);
}
while (csv_row_fread(in,
(unsigned char *)csv_buf,
CSV_BUFSIZE,
(unsigned char **)csv_row,
CSV_COLS,
sep,
CSV_QUOTES) > 0) {
gtk_list_store_append(store, &iter);
for(n = 0; n < ncol; n++) {
gtk_list_store_set(store, &iter, n, csv_row[n], -1);
}
if (!(nrow % 256)) {
while (gtk_events_pending()) gtk_main_iteration();
}
gtk_main_iteration_do(FALSE);
nrow++;
if (progress) {};
}
}
g_object_unref(store); /* So only the treeview ref remains - it should be deleted when treeview is destroyed */
if (ret_store) *ret_store = GTK_TREE_MODEL(store);
if (ret_view) *ret_view = view;
return nrow;
}
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);
}
void clist_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER
);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, "",
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"),
renderer, "text",
COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"),
renderer, "text",
COLUMN_DATE, NULL);
for (i = 0; i < CLIST_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(tree_selection_changed), NULL);
}
void create_plugins_gui(Sven *sven,GtkWidget *vbox1)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *scrolled_win;
GtkWidget *hbbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *label;
DEBUG_MSG("Start create_plugins_gui\n");
gtk_box_pack_start (GTK_BOX (vbox1), create_header(_("Plugins")), FALSE, FALSE, 0);
plugins_model = gtk_tree_store_new (3,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING);
plugins_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (plugins_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (plugins_tree_view), TRUE);
plugins_selection = G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (plugins_tree_view)));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (plugins_selection), GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (plugins_selection),"changed",G_CALLBACK (prefs_plugins_list_clicked),sven);
g_signal_connect(G_OBJECT(plugins_tree_view), "button-press-event",G_CALLBACK(plugin_list_event_mouseclick), sven);
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_win), plugins_tree_view);
gtk_container_border_width(GTK_CONTAINER(scrolled_win), 5);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1), scrolled_win, TRUE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start(GTK_BOX(vbox1), frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
gtk_frame_set_label_align (GTK_FRAME (frame), 0.05, 0.5);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
label = gtk_label_new (_("Description"));
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_container_set_border_width (GTK_CONTAINER (alignment), 2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
infotext = gtk_label_new (_("Not information"));
gtk_widget_show (infotext);
gtk_container_add (GTK_CONTAINER (alignment), infotext);
GTK_WIDGET_SET_FLAGS (infotext, GTK_CAN_FOCUS);
gtk_label_set_line_wrap (GTK_LABEL (infotext), TRUE);
gtk_label_set_selectable (GTK_LABEL (infotext), TRUE);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 5);
hbbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_START);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 10);
gtk_button_box_set_child_size(GTK_BUTTON_BOX(hbbox), 85, 17);
gtk_box_pack_start(GTK_BOX(hbox), hbbox, TRUE, TRUE, 0);
prefs_plugins_config_wid = gtk_button_new_with_label(_("Configure"));
g_signal_connect(G_OBJECT(prefs_plugins_config_wid ), "clicked", G_CALLBACK(prefs_plugins_configure),sven);
gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_config_wid, TRUE, TRUE, 0);
prefs_plugins_about_wid = gtk_button_new_with_label(_("About"));
g_signal_connect(G_OBJECT(prefs_plugins_about_wid), "clicked", G_CALLBACK(prefs_plugins_about), sven);
gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_about_wid, TRUE, TRUE, 0);
cell = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (_("Status"), cell, "active",0, NULL);
gtk_tree_view_column_set_clickable (column, TRUE);
g_signal_connect (G_OBJECT (cell), "toggled",G_CALLBACK (plugin_fixed_toggled),sven);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"), cell, "markup", 1, NULL);
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Module"), cell, "markup",2, NULL);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
gtk_widget_show(plugins_tree_view);
add_print_plugins(GTK_TREE_VIEW (plugins_tree_view),sven);
}
/* 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;
}
gboolean edit_bookmarks( GtkWindow* parent )
{
GList* l;
GtkWidget* dlg;
GtkWidget* btn_box;
GtkWidget* add_btn;
GtkWidget* delete_btn;
GtkWidget* scroll;
GtkWidget* list_view;
GtkListStore* list;
GtkTreeViewColumn* col;
GtkTreeIter it;
GtkTreeSelection* sel;
gchar *name, *path, *item;
gboolean ret = FALSE;
PtkBookmarks* bookmarks;
GtkCellRenderer *renderer, *icon_renderer;
GdkPixbuf* icon;
dlg = gtk_dialog_new_with_buttons ( _("Edit Bookmarks"),
parent,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL );
gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
list = gtk_list_store_new( NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING );
icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(),
"gnome-fs-directory",
20, 0, NULL );
bookmarks = ptk_bookmarks_get();
for( l = bookmarks->list; l; l = l->next )
{
gtk_list_store_append( list, &it );
gtk_list_store_set( list, &it,
COL_ICON, icon,
COL_NAME, l->data,
COL_DIRPATH, ptk_bookmarks_item_get_path((char*)l->data),
-1);
}
if( icon )
g_object_unref( icon );
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_IN);
list_view = gtk_tree_view_new_with_model( GTK_TREE_MODEL(list) );
g_object_set_data( G_OBJECT(dlg), "list_view", list_view );
sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(list_view) );
gtk_tree_selection_set_mode( sel, GTK_SELECTION_BROWSE );
if( gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(list), &it ) )
{
gtk_tree_selection_select_iter( sel, &it );
}
icon_renderer = gtk_cell_renderer_pixbuf_new();
renderer = gtk_cell_renderer_text_new();
g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL );
g_signal_connect( renderer, "edited", G_CALLBACK(on_name_edited), list );
col = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", COL_ICON, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
col = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", COL_NAME, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 160);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
renderer = gtk_cell_renderer_text_new();
g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL );
g_signal_connect( renderer, "edited", G_CALLBACK(on_path_edited), list );
col = gtk_tree_view_column_new_with_attributes(_("Path"),
renderer, "text", COL_DIRPATH, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
gtk_tree_view_set_reorderable ( GTK_TREE_VIEW(list_view), TRUE );
gtk_container_add( GTK_CONTAINER(scroll), list_view);
btn_box = gtk_hbutton_box_new();
gtk_button_box_set_layout ( GTK_BUTTON_BOX(btn_box), GTK_BUTTONBOX_START );
add_btn = gtk_button_new_from_stock ( GTK_STOCK_ADD );
g_signal_connect( add_btn, "clicked", G_CALLBACK(on_add), dlg );
gtk_box_pack_start_defaults ( GTK_BOX(btn_box), add_btn );
delete_btn = gtk_button_new_from_stock ( GTK_STOCK_DELETE );
g_signal_connect( delete_btn, "clicked", G_CALLBACK(on_delete), dlg );
gtk_box_pack_start_defaults ( GTK_BOX(btn_box), delete_btn );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dlg)->vbox), btn_box,
FALSE, FALSE, 4 );
gtk_box_pack_start_defaults( GTK_BOX(GTK_DIALOG(dlg)->vbox), scroll );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dlg)->vbox),
gtk_label_new(_("Use drag & drop to sort the items")),
FALSE, FALSE, 4 );
gtk_window_set_default_size ( GTK_WINDOW(dlg), 480, 400 );
gtk_widget_show_all( dlg );
gtk_widget_grab_focus( list_view );
pcmanfm_ref();
if( gtk_dialog_run( GTK_DIALOG(dlg) ) == GTK_RESPONSE_OK )
{
l = NULL;
if( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(list), &it ) )
{
do
{
gtk_tree_model_get( GTK_TREE_MODEL(list), &it,
COL_NAME, &name,
COL_DIRPATH, &path,
-1 );
if( ! name )
name = g_path_get_basename( path );
item = ptk_bookmarks_item_new( name, strlen(name),
path ? path : "", path ? strlen(path) : 0 );
l = g_list_append( l, item );
g_free(name);
g_free(path);
}
while( gtk_tree_model_iter_next( GTK_TREE_MODEL(list), &it) );
}
ptk_bookmarks_set( l );
ret = TRUE;
}
ptk_bookmarks_unref();
gtk_widget_destroy( dlg );
pcmanfm_unref();
return ret;
}
static void
ft_manager_build_ui (EmpathyFTManager *manager)
{
GtkBuilder *gui;
GtkTreeView *view;
GtkListStore *liststore;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gchar *filename;
EmpathyFTManagerPriv *priv = GET_PRIV (manager);
filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
gui = tpaw_builder_get_file (filename,
"ft_manager_dialog", &priv->window,
"ft_list", &priv->treeview,
"clear_button", &priv->clear_button,
"open_button", &priv->open_button,
"abort_button", &priv->abort_button,
NULL);
g_free (filename);
tpaw_builder_connect (gui, manager,
"ft_manager_dialog", "destroy", ft_manager_destroy_cb,
"ft_manager_dialog", "response", ft_manager_response_cb,
"ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
"ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb,
NULL);
tpaw_builder_unref_and_keep_widget (gui, priv->window);
/* Window geometry. */
empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager");
/* Setup the tree view */
view = GTK_TREE_VIEW (priv->treeview);
selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (ft_manager_selection_changed), manager);
g_signal_connect (view, "button-press-event",
G_CALLBACK (ft_view_button_press_event_cb),
manager);
gtk_tree_view_set_headers_visible (view, TRUE);
gtk_tree_view_set_enable_search (view, FALSE);
/* Setup the model */
liststore = gtk_list_store_new (5,
G_TYPE_INT, /* percent */
G_TYPE_ICON, /* icon */
G_TYPE_STRING, /* message */
G_TYPE_STRING, /* remaining */
G_TYPE_OBJECT); /* ft_handler */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
priv->model = GTK_TREE_MODEL (liststore);
g_object_unref (liststore);
/* Progress column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("%"));
gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ft_manager_progress_cell_data_func, NULL, NULL);
/* Icon and filename column*/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("File"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
gtk_tree_view_column_set_spacing (column, 3);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 3,
"stock-size", GTK_ICON_SIZE_DND, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COL_ICON, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_MESSAGE, NULL);
/* Remaining time column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Remaining"));
gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_REMAINING, NULL);
/* clear button should be sensitive only if there are completed/cancelled
* handlers in the store.
*/
gtk_widget_set_sensitive (priv->clear_button, FALSE);
}
GtkWidget *pref_start_filter()
{
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *scroll;
GtkCellRenderer *renderer;
LOG(LOG_DEBUG, "IN : pref_start_dictgroup()");
// Left half
vbox = gtk_vbox_new(FALSE,0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(vbox)
, frame,TRUE, TRUE, 0);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), scroll);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(filter_view), TRUE);
gtk_tree_view_expand_all(GTK_TREE_VIEW(filter_view));
gtk_container_add (GTK_CONTAINER (scroll), filter_view);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(cell_edited), NULL);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_EXT_COLUMN);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view),
-1, _("Extension"), renderer,
"text", FILTER_EXT_COLUMN,
"editable", FILTER_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(cell_edited), NULL);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_FILTER_COMMAND_COLUMN);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view),
-1, _("Filter Command"), renderer,
"text", FILTER_FILTER_COMMAND_COLUMN,
"editable", FILTER_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(cell_edited), NULL);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_OPEN_COMMAND_COLUMN);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view),
-1, _("Open Command"), renderer,
"text", FILTER_OPEN_COMMAND_COLUMN,
"editable", FILTER_EDITABLE_COLUMN,
NULL);
// Enable resizing all column
{
gint i;
GtkTreeViewColumn *column;
for(i=0;;i++){
column = gtk_tree_view_get_column(GTK_TREE_VIEW(filter_view), i);
if(column == NULL)
break;
gtk_tree_view_column_set_resizable(column, TRUE);
}
}
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
hbox,FALSE, FALSE, 2);
button = gtk_button_new_with_label(_("Add"));
gtk_box_pack_start(GTK_BOX(hbox),
button,FALSE,FALSE, 2);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK(add_filter), (gpointer)button);
button = gtk_button_new_with_label(_("Remove"));
gtk_box_pack_start(GTK_BOX(hbox),
button,FALSE,FALSE, 2);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK(remove_filter), (gpointer)button);
LOG(LOG_DEBUG, "OUT : pref_start_dictgroup()");
return(vbox);
}
static
GtkWidget *create_list(void)
{
GtkListStore *list_store;
GtkWidget * list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *list_view;
GtkTreeSelection *selection;
list_store = gtk_list_store_new(N_COLUMN,
G_TYPE_UINT, /* Port1*/
G_TYPE_UINT, /* Port2*/
G_TYPE_UINT, /* number of packets */
G_TYPE_STRING, /* checksum type */
G_TYPE_UINT, /* number of checksum errors */
G_TYPE_UINT, /* number of data chunks */
G_TYPE_UINT, /* number of data bytes */
G_TYPE_UINT, /* vtag1 */
G_TYPE_UINT); /* vtag2 */
/* Create a view */
list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));
list_view = GTK_TREE_VIEW(list);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
gtk_tree_view_set_headers_clickable(list_view, TRUE);
/* 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("Port 1", renderer,
"text", PORT1_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PORT1_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);
/* 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("Port 2", renderer,
"text", PORT2_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PORT2_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);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("No of Packets", renderer,
"text", PACKETS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PACKETS_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, 120);
gtk_tree_view_append_column(list_view, column);
/* 4:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Checksum", renderer,
"text", CHECKSUM_TYPE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_TYPE_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, 120);
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("No of Errors", renderer,
"text", CHECKSUM_ERRORS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_ERRORS_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, 120);
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("Data Chunks", renderer,
"text", DATA_CHUNKS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DATA_CHUNKS_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, 120);
gtk_tree_view_append_column(list_view, column);
/* 7:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Data Bytes", renderer,
"text", DATA_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DATA_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, 120);
gtk_tree_view_append_column(list_view, column);
/* 8:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("VTag 1", renderer,
"text", VTAG1_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, VTAG1_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, 120);
gtk_tree_view_append_column(list_view, column);
/* 9:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("VTag 2", renderer,
"text", VTAG2_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, VTAG2_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, 120);
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);
g_signal_connect(selection, "changed", G_CALLBACK(sctp_stat_on_select_row), NULL);
return list;
}
/* 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;
}
/* 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, /* IEI */
G_TYPE_STRING, /* Message Name */
G_TYPE_UINT); /* Count */
/* 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, IEI_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
*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IEI", renderer,
"text", IEI_COLUMN,
NULL);
/* gtk_tree_view_column_set_cell_data_func(column, renderer, present_as_hex_func,
GINT_TO_POINTER(IEI_COLUMN), NULL);
*/
gtk_tree_view_column_set_sort_column_id(column, IEI_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, 50);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* Second column.. Message Name. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Message Name", renderer,
"text", MSG_NAME_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, MSG_NAME_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, 280);
gtk_tree_view_append_column (list_view, column);
/* Third column.. Count. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Count", renderer,
"text", COUNT_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, COUNT_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, 50);
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;
}
void init_right_tree(void)
{
GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
GtkCellRenderer *renderer;
GtkTreeSelection *sel;
GtkTreeViewColumn *column;
gint i;
gtk_tree_view_set_model(view, model2);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, _("Options"));
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"pixbuf", COL_PIXBUF,
"visible", COL_PIXVIS, NULL);
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"active", COL_BTNACT,
"inconsistent", COL_BTNINC,
"visible", COL_BTNVIS,
"radio", COL_BTNRAD, NULL);
/*g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(renderer_toggled), NULL); */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"text", COL_OPTION,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Name"), renderer,
"text", COL_NAME,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"N", renderer,
"text", COL_NO,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"M", renderer,
"text", COL_MOD,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"Y", renderer,
"text", COL_YES,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Value"), renderer,
"text", COL_VALUE,
"editable",
COL_EDIT,
"foreground-gdk",
COL_COLOR, NULL);
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(renderer_edited), NULL);
column = gtk_tree_view_get_column(view, COL_NAME);
gtk_tree_view_column_set_visible(column, show_name);
column = gtk_tree_view_get_column(view, COL_NO);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_MOD);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_YES);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_VALUE);
gtk_tree_view_column_set_visible(column, show_value);
if (resizeable) {
for (i = 0; i < COL_VALUE; i++) {
column = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(column, TRUE);
}
}
sel = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
}
/* Public API */
GtkWidget *
accounts_window_new (boost::shared_ptr<Ekiga::AccountCore> account_core,
boost::shared_ptr<Ekiga::PersonalDetails> details)
{
AccountsWindow *self = NULL;
boost::signals::connection conn;
GtkWidget *vbox = NULL;
GtkWidget *menu_bar = NULL;
GtkWidget *menu_item = NULL;
GtkWidget *menu = NULL;
GtkWidget *item = NULL;
GtkWidget *event_box = NULL;
GtkWidget *scroll_window = NULL;
GtkWidget* button_box = NULL;
GtkWidget* button = NULL;
GtkWidget *frame = NULL;
GtkWidget *hbox = NULL;
GtkCellRenderer *renderer = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkTreeSelection* selection = NULL;
AtkObject *aobj;
const gchar *column_names [] = {
"",
"",
"",
"",
_("Account Name"),
_("Status")
};
/* The window */
self = (AccountsWindow *) g_object_new (ACCOUNTS_WINDOW_TYPE, NULL);
self->priv = new AccountsWindowPrivate;
self->priv->details = details;
self->priv->account_core = account_core;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_window_set_title (GTK_WINDOW (self), _("Accounts"));
/* The menu */
menu_bar = gtk_menu_bar_new ();
self->priv->accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
g_object_unref (self->priv->accel);
self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("_Accounts"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core);
g_object_ref (self->priv->menu_item_core);
menu_item = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), menu_item);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect (item, "activate", G_CALLBACK (help_callback), NULL);
/* The accounts list store */
list_store = gtk_list_store_new (COLUMN_ACCOUNT_NUMBER,
G_TYPE_POINTER,
G_TYPE_STRING, /* Icon */
G_TYPE_BOOLEAN, /* Is account active? */
G_TYPE_INT,
G_TYPE_STRING, /* Account Name */
G_TYPE_STRING, /* Error Message */
G_TYPE_INT); /* State */
self->priv->accounts_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->accounts_list), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->accounts_list), TRUE);
aobj = gtk_widget_get_accessible (GTK_WIDGET (self->priv->accounts_list));
atk_object_set_name (aobj, _("Accounts"));
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"icon-name", COLUMN_ACCOUNT_ICON);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column);
/* Add all text renderers */
for (int i = COLUMN_ACCOUNT_ACCOUNT_NAME ; i < COLUMN_ACCOUNT_NUMBER ; i++) {
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (column_names [i],
renderer,
"text",
i,
"weight",
COLUMN_ACCOUNT_WEIGHT,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column);
gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, i);
}
g_signal_connect (self->priv->accounts_list, "event_after",
G_CALLBACK (account_clicked_cb), self);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->accounts_list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), self);
/* The scrolled window with the accounts list store */
scroll_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
event_box = gtk_event_box_new ();
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_container_add (GTK_CONTAINER (event_box), hbox);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), 250, 150);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), scroll_window);
gtk_container_add (GTK_CONTAINER (scroll_window), self->priv->accounts_list);
gtk_container_set_border_width (GTK_CONTAINER (self->priv->accounts_list), 0);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
/* setting up a horizontal button box
* (each button with be dynamically disabled/enabled as needed)
*/
button_box = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_CENTER);
button = gtk_button_new_with_mnemonic (_("_Enable"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("user-available", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("_Disable"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("user-offline", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("Edi_t"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("edit", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("_Remove"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("remove", GTK_BUTTON (button));
gtk_box_pack_start (GTK_BOX (hbox), button_box, FALSE, FALSE, 10);
populate_menu (GTK_WIDGET (self)); // This will add static and dynamic actions
gtk_box_pack_start (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), event_box, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show_all (GTK_WIDGET (vbox));
/* Engine Signals callbacks */
conn = self->priv->account_core->bank_added.connect (boost::bind (&on_bank_added, _1, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_added.connect (boost::bind (&on_account_added, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_updated.connect (boost::bind (&on_account_updated, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_removed.connect (boost::bind (&on_account_removed, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self));
self->priv->connections.add (conn);
self->priv->presence = self->priv->details->get_presence ();
conn = self->priv->details->updated.connect (boost::bind (&on_personal_details_updated, self, self->priv->details));
self->priv->connections.add (conn);
self->priv->account_core->visit_banks (boost::bind (&on_visit_banks, _1, self));
return GTK_WIDGET (self);
}
