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); }