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); }
GtkWidget * gimp_file_proc_view_new (Gimp *gimp, GSList *procedures, const gchar *automatic, const gchar *automatic_help_id) { GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkListStore *store; GSList *list; GtkTreeIter iter; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); store = gtk_list_store_new (N_COLUMNS, GIMP_TYPE_PLUG_IN_PROCEDURE, /* COLUMN_PROC */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_EXTENSIONS */ G_TYPE_STRING); /* COLUMN_HELP_ID */ view = g_object_new (GIMP_TYPE_FILE_PROC_VIEW, "model", store, "rules-hint", TRUE, NULL); g_object_unref (store); for (list = procedures; list; list = g_slist_next (list)) { GimpPlugInProcedure *proc = list->data; if (! proc->prefixes_list) /* skip URL loaders */ { const gchar *label = gimp_procedure_get_label (GIMP_PROCEDURE (proc)); const gchar *help_id = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc)); GSList *list2; if (label) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLUMN_PROC, proc, COLUMN_LABEL, label, COLUMN_EXTENSIONS, proc->extensions, COLUMN_HELP_ID, help_id, -1); } for (list2 = proc->extensions_list; list2; list2 = g_slist_next (list2)) { GimpFileProcView *proc_view = GIMP_FILE_PROC_VIEW (view); const gchar *ext = list2->data; const gchar *dot = strchr (ext, '.'); if (dot && dot != ext) proc_view->meta_extensions = g_list_append (proc_view->meta_extensions, g_strdup (dot + 1)); } } } if (automatic) { gtk_list_store_prepend (store, &iter); gtk_list_store_set (store, &iter, COLUMN_PROC, NULL, COLUMN_LABEL, automatic, COLUMN_HELP_ID, automatic_help_id, -1); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("File Type")); gtk_tree_view_column_set_expand (column, TRUE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Extensions")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_EXTENSIONS, NULL); gtk_tree_view_append_column (view, column); g_signal_connect (gtk_tree_view_get_selection (view), "changed", G_CALLBACK (gimp_file_proc_view_selection_changed), view); return GTK_WIDGET (view); }
static void import_widget_set_up_account_list (EmpathyImportWidget *self) { EmpathyImportWidgetPriv *priv = GET_PRIV (self); GtkListStore *store; GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; priv->accounts = empathy_import_accounts_load (priv->app_id); store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (store)); g_object_unref (store); view = GTK_TREE_VIEW (priv->treeview); gtk_tree_view_set_headers_visible (view, TRUE); /* Import column */ cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (view, -1, /* Translators: this is the header of a treeview column */ _("Import"), cell, "active", COL_IMPORT, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (import_widget_cell_toggled_cb), self); /* Protocol column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Protocol")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL); /* Account column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME); if (priv->app_id == EMPATHY_IMPORT_APPLICATION_ALL) { /* Source column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Source")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE); } import_widget_add_accounts_to_model (self); }
static GtkWidget * create_action_treeview (GActionGroup *group) { GtkWidget *tv; GtkListStore *store; GtkListStore *values; GtkTreeIter iter; GtkTreeViewColumn *column; GtkCellRenderer *cell; gchar **actions; gint i; store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); actions = g_action_group_list_actions (group); for (i = 0; actions[i]; i++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, actions[i], -1); } g_strfreev (actions); g_object_set_data (G_OBJECT (store), "group", group); tv = gtk_tree_view_new (); g_signal_connect_swapped (group, "action-enabled-changed", G_CALLBACK (gtk_widget_queue_draw), tv); g_signal_connect_swapped (group, "action-state-changed", G_CALLBACK (gtk_widget_queue_draw), tv); gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store)); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Action", cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Enabled"); cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_cell_data_func (column, cell, enabled_cell_func, group, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (enabled_cell_toggled), store); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "State"); cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (state_cell_toggled), store); cell = gtk_cell_renderer_combo_new (); values = gtk_list_store_new (1, G_TYPE_STRING); gtk_list_store_append (values, &iter); gtk_list_store_set (values, &iter, 0, "latin", -1); gtk_list_store_append (values, &iter); gtk_list_store_set (values, &iter, 0, "greek", -1); gtk_list_store_append (values, &iter); gtk_list_store_set (values, &iter, 0, "urdu", -1); gtk_list_store_append (values, &iter); gtk_list_store_set (values, &iter, 0, "sumerian", -1); g_object_set (cell, "has-entry", FALSE, "model", values, "text-column", 0, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL); g_signal_connect (cell, "edited", G_CALLBACK (state_cell_edited), store); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); return tv; }
/** * callback called by the button to launch the automatic association * between transactions and reconcile * * \param button * \param assistant * * \return FALSE * */ static gboolean gsb_assistant_reconcile_config_lauch_manu_asso ( GtkWidget *button, GtkWidget *assistant ) { GList *tmp_list; GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; GList *path_list; gint account_number = -1; GtkWidget *dialog; GtkWidget *label; GtkWidget *scrolled_window; GtkWidget *dialog_tree_view; GtkListStore *dialog_store; gint return_value; gint i; enum dialog_column { DIALOG_NAME = 0, DIALOG_INIT_DATE, DIALOG_FINAL_DATE, DIALOG_RECONCILE_NUMBER, DIALOG_NB_COL }; gint selected_reconcile_number; gint transaction_number; /* get the selection */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link)); /* get the selected transactions */ path_list = gtk_tree_selection_get_selected_rows ( GTK_TREE_SELECTION (selection), &model ); if (!path_list) return FALSE; /* ok, we have a selection, before continuing, * we check that all the transactions are on the same account */ tmp_list = path_list; while (tmp_list) { GtkTreePath *path; path = tmp_list -> data; if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model), &iter, path )) { gtk_tree_model_get ( GTK_TREE_MODEL (model), &iter, TRANSACTION_NUMBER, &transaction_number, -1 ); if (account_number == -1) account_number = gsb_data_transaction_get_account_number (transaction_number); else { if (gsb_data_transaction_get_account_number (transaction_number) != account_number) { dialogue_error (_("All the selected transactions have to belong to the same account !")); /* erase the path_list */ g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL); g_list_free (path_list); return FALSE; } } } tmp_list = tmp_list -> next; } if (account_number == -1) { /* erase the path_list */ g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL); g_list_free (path_list); return FALSE; } /* ok, all the transactions belong to the same account, we can * show a dialog to select the reconcile */ dialog = gtk_dialog_new_with_buttons ( _("Selection of a reconciliation"), GTK_WINDOW ( assistant ), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-ok", GTK_RESPONSE_OK, NULL ); gtk_window_set_default_size ( GTK_WINDOW ( dialog ), 770, 412 ); gtk_window_set_position ( GTK_WINDOW ( dialog ), GTK_WIN_POS_CENTER_ON_PARENT ); gtk_window_set_resizable ( GTK_WINDOW ( dialog ), TRUE ); gtk_container_set_border_width ( GTK_CONTAINER ( dialog ), 12 ); label = gtk_label_new ( _("Select the reconciliation to associate to the selected transactions: ") ); gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 ); gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ), label, FALSE, FALSE, 10 ); /* make the list */ scrolled_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ), scrolled_window, TRUE, TRUE, 0 ); dialog_store = gtk_list_store_new ( DIALOG_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT ); dialog_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog_store)); g_object_unref (G_OBJECT(dialog_store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog_tree_view), TRUE); gtk_container_add ( GTK_CONTAINER (scrolled_window), dialog_tree_view ); /* set the columns */ for (i=DIALOG_NAME ; i<DIALOG_RECONCILE_NUMBER ; i++) { GtkTreeViewColumn *column; GtkCellRenderer *cell; gchar *titles[] = { _("Reconciliation reference"), _("Initial date"), _("Final date") }; gfloat alignment[] = { COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER }; cell = gtk_cell_renderer_text_new (); g_object_set ( G_OBJECT (cell), "xalign", alignment[i], NULL ); 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_pack_start ( column, cell, TRUE ); gtk_tree_view_column_set_title ( column, titles[i] ); gtk_tree_view_column_set_attributes (column, cell, "text", i, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); gtk_tree_view_column_set_resizable ( column, TRUE ); gtk_tree_view_append_column ( GTK_TREE_VIEW(dialog_tree_view), column); } /* fill the tree view */ tmp_list = gsb_data_reconcile_get_reconcile_list (); while (tmp_list) { gint reconcile_number; reconcile_number = gsb_data_reconcile_get_no_reconcile (tmp_list -> data); if (gsb_data_reconcile_get_account (reconcile_number) == account_number) { gchar *init_date_str; gchar *final_date_str; init_date_str = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number)); final_date_str = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number)); gtk_list_store_append ( GTK_LIST_STORE (dialog_store), &iter ); gtk_list_store_set ( GTK_LIST_STORE (dialog_store), &iter, DIALOG_NAME, gsb_data_reconcile_get_name (reconcile_number), DIALOG_INIT_DATE, init_date_str, DIALOG_FINAL_DATE, final_date_str, DIALOG_RECONCILE_NUMBER, reconcile_number, -1 ); g_free (init_date_str); g_free (final_date_str); } tmp_list = tmp_list -> next; } gtk_widget_show_all (dialog); /* launch the dialog */ return_value = gtk_dialog_run (GTK_DIALOG (dialog)); if (return_value != GTK_RESPONSE_OK) { gtk_widget_destroy (dialog); return FALSE; } /* we get the selected reconcile */ if (!gtk_tree_selection_get_selected ( gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog_tree_view)), NULL, &iter )) { dialogue_warning (_("No selection found, the transactions are not modified.")); gtk_widget_destroy (dialog); return FALSE; } gtk_tree_model_get ( GTK_TREE_MODEL (dialog_store), &iter, DIALOG_RECONCILE_NUMBER, &selected_reconcile_number, -1 ); /* ok we have the reconcile number, we can destroy the dialog */ gtk_widget_destroy (dialog); /* and now, fill the selected transactions with that reconcile number */ tmp_list = g_list_last (path_list); while (tmp_list) { GtkTreePath *path; path = tmp_list -> data; if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model), &iter, path )) { gtk_tree_model_get ( GTK_TREE_MODEL (model), &iter, TRANSACTION_NUMBER, &transaction_number, -1 ); gtk_list_store_remove ( GTK_LIST_STORE (model), &iter ); gsb_data_transaction_set_reconcile_number ( transaction_number, selected_reconcile_number ); transactions_to_link--; } tmp_list = tmp_list -> prev; } /* erase the path_list */ g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL); g_list_free (path_list); /* now there is 2 way : * either transactions_to_link is 0, we go directly to the succes page * either it's not null, and the user should create more reconciles */ if (transactions_to_link) { gchar *string; /* update the labels */ string = g_strdup_printf (_("Still %d transactions to link with a reconciliation."), transactions_to_link); gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_1), string); gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_3), string); g_free (string); gtk_widget_grab_focus (treeview_transactions_to_link); } else { /* go to the success page */ gsb_assistant_set_next ( assistant, RECONCILE_ASSISTANT_MANUALLY_ASSOCIATE, RECONCILE_ASSISTANT_SUCCESS ); gsb_assistant_next_page (assistant); } return FALSE; }
GtkWidget * color_create_widget (GtkWidget *dlg) { GtkWidget *w; #if !GTK_CHECK_VERSION(3,0,0) w = gtk_vbox_new (FALSE, 2); #else w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); #endif color = gtk_color_selection_new (); gtk_widget_set_name (color, "yad-color-widget"); gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (color), settings.show_gtk_palette); if (options.color_data.init_color) { GdkColor c; if (gdk_color_parse (options.color_data.init_color, &c)) gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (color), &c); } gtk_box_pack_start (GTK_BOX (w), color, FALSE, FALSE, 2); if (options.color_data.use_palette) { GtkTreeModel *model; if ((model = create_palette ()) != NULL) { GtkWidget *exp, *sw, *list; GtkCellRenderer *r; GtkTreeViewColumn *col; GtkTreeSelection *sel; /* create expander */ exp = gtk_expander_new (_("Palette")); gtk_expander_set_expanded (GTK_EXPANDER (exp), settings.expand_palette); gtk_container_set_border_width (GTK_CONTAINER (exp), 5); gtk_box_pack_start (GTK_BOX (w), exp, TRUE, TRUE, 2); /* create color list */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (exp), sw); list = gtk_tree_view_new_with_model (model); gtk_widget_set_name (list, "yad-color-palette"); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), settings.rules_hint); g_object_unref (model); gtk_container_add (GTK_CONTAINER (sw), list); /* add first columns */ col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, _("Color")); /* pixbuf */ r = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, r, FALSE); gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL); /* color value */ r = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, r, TRUE); gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id (col, 1); gtk_tree_view_append_column (GTK_TREE_VIEW (list), col); /* add second column */ r = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Name"), r, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id (col, 2); gtk_tree_view_append_column (GTK_TREE_VIEW (list), col); /* enable searching on Name column */ gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), 2); /* setup the selection handler */ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (palette_changed), NULL); gtk_widget_show_all (exp); } } return w; }
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); }
/** * pk_treeview_add_general_columns: **/ static void pk_treeview_add_general_columns (GtkTreeView *treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; /* --- column for date --- */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "yalign", 0.0, NULL); /* TRANSLATORS: column for the date */ column = gtk_tree_view_column_new_with_attributes (_("Date"), renderer, "markup", GPK_LOG_COLUMN_DATE_TEXT, NULL); gtk_tree_view_append_column (treeview, column); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_column_set_sort_column_id (column, GPK_LOG_COLUMN_DATE); /* --- column for image and text --- */ column = gtk_tree_view_column_new (); /* TRANSLATORS: column for what was done, e.g. update-system */ gtk_tree_view_column_set_title (column, _("Action")); /* image */ renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL); g_object_set (renderer, "yalign", 0.0, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "icon-name", GPK_LOG_COLUMN_ICON); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "yalign", 0.0, NULL); /* text */ gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "markup", GPK_LOG_COLUMN_ROLE); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_column_set_sort_column_id (column, GPK_LOG_COLUMN_ROLE); gtk_tree_view_append_column (treeview, GTK_TREE_VIEW_COLUMN(column)); /* --- column for details --- */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "yalign", 0.0, NULL); g_object_set (renderer, "wrap-mode", PANGO_WRAP_WORD, NULL); g_object_set (renderer, "wrap-width", 400, NULL); g_signal_connect (treeview, "size-allocate", G_CALLBACK (gpk_log_treeview_size_allocate_cb), renderer); /* TRANSLATORS: column for what packages were upgraded */ column = gtk_tree_view_column_new_with_attributes (_("Details"), renderer, "markup", GPK_LOG_COLUMN_DETAILS, NULL); gtk_tree_view_append_column (treeview, column); gtk_tree_view_column_set_expand (column, TRUE); /* TRANSLATORS: column for the user name, e.g. Richard Hughes */ column = gtk_tree_view_column_new_with_attributes (_("User name"), renderer, "markup", GPK_LOG_COLUMN_USER, NULL); gtk_tree_view_append_column (treeview, column); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_column_set_sort_column_id (column, GPK_LOG_COLUMN_USER); /* TRANSLATORS: column for the application used for the install, e.g. Add/Remove Programs */ column = gtk_tree_view_column_new_with_attributes (_("Application"), renderer, "markup", GPK_LOG_COLUMN_TOOL, NULL); gtk_tree_view_append_column (treeview, column); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_column_set_sort_column_id (column, GPK_LOG_COLUMN_TOOL); }
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); }
CMatchingDlg::CMatchingDlg(GtkWindow *pParent):m_pParent(pParent), m_FileList(NULL), m_FrameCols(NULL), m_CatalogCols(NULL), m_ChartData(NULL), m_ImageData(NULL), m_CatFile(NULL), m_SelectionName(NULL), m_Updating(false) { int i, w, width, mon; GtkWidget *tbox, *tbar, *frame, *hbox; GdkRectangle rc; GSList *group; m_Negative = CConfig::GetBool(CConfig::NEGATIVE_CHARTS); m_RowsUpward = CConfig::GetBool(CConfig::ROWS_UPWARD); // Dialog with buttons m_pDlg = gtk_dialog_new_with_buttons("Match stars", pParent, (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg)); gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Start the process"); g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this); // Dialog icon gchar *icon = get_icon_file("matchstars"); gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL)); g_free(icon); // Dialog layout GtkWidget *vbox = gtk_vbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), vbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); // Dialog size GdkScreen *scr = gtk_window_get_screen(pParent); mon = gdk_screen_get_monitor_at_window(scr, GTK_WIDGET(pParent)->window); gdk_screen_get_monitor_geometry(scr, mon, &rc); if (rc.width>0 && rc.height>0) gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.7*rc.width), RoundToInt(0.7*rc.height)); // Initial state m_SelectMode = (tSelectMode)g_Project->GetInt("MatchingDlg", "Select", REFERENCE_FRAME); m_DMFrame = (tDisplayMode)g_Project->GetInt("MatchingDlg", "Display", DISPLAY_CHART); m_DMCatalog = (tDisplayMode)g_Project->GetInt("MatchingDlg", "Display2", DISPLAY_CHART); m_FrameSort = g_Project->GetInt("MatchingDlg", "Sort", FCOL_STARS); // List of frames m_Frames = gtk_list_store_new(FNCOLS, G_TYPE_INT, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_INT); // List of catalog files m_Catalogs = gtk_list_store_new(CNCOLS, G_TYPE_STRING, G_TYPE_STRING); // Reference frame or catalog file? m_UseFrame = gtk_vbox_new(TRUE, 4); gtk_box_pack_start(GTK_BOX(vbox), m_UseFrame, FALSE, TRUE, 0); GtkWidget *label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), "<b>As a reference file, use:</b>"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(m_UseFrame), label, FALSE, TRUE, 0); m_FrameBtn = gtk_radio_button_new_with_label(NULL, "a frame from the current project"); gtk_widget_set_tooltip_text(m_FrameBtn, "Use one of the source frames as a reference frame"); g_signal_connect(G_OBJECT(m_FrameBtn), "toggled", G_CALLBACK(button_clicked), this); gtk_box_pack_start(GTK_BOX(m_UseFrame), m_FrameBtn, TRUE, TRUE, 0); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_FrameBtn)); m_CatalogBtn = gtk_radio_button_new_with_label(group, "a catalog file from the disk"); gtk_widget_set_tooltip_text(m_CatalogBtn, "Use a catalog file as a reference frame"); g_signal_connect(G_OBJECT(m_CatalogBtn), "toggled", G_CALLBACK(button_clicked), this); gtk_box_pack_start(GTK_BOX(m_UseFrame), m_CatalogBtn, TRUE, TRUE, 0); // Separator gtk_box_pack_start(GTK_BOX(m_UseFrame), gtk_label_new(NULL), FALSE, TRUE, 0); m_SelLabel = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(m_SelLabel), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), m_SelLabel, FALSE, TRUE, 0); tbox = gtk_table_new(2, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(tbox), 0); gtk_table_set_col_spacing(GTK_TABLE(tbox), 1, 8); gtk_table_set_row_spacings(GTK_TABLE(tbox), 0); gtk_table_set_row_spacing(GTK_TABLE(tbox), 1, 8); gtk_box_pack_start(GTK_BOX(vbox), tbox, TRUE, TRUE, 0); // List of reference frames m_FrameView = gtk_tree_view_new(); width = 8; for (i=0; FrameColumns[i].caption!=NULL; i++) { GtkTreeViewColumn *col = gtk_tree_view_column_new(); // Set column name and alignment gtk_tree_view_column_set_title(col, FrameColumns[i].caption); gtk_tree_view_append_column(GTK_TREE_VIEW(m_FrameView), col); // Add text renderer GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); g_object_set(renderer, "xalign", FrameColumns[i].align, NULL); if (FrameColumns[i].datafn) gtk_tree_view_column_set_cell_data_func(col, renderer, FrameColumns[i].datafn, NULL, NULL); else gtk_tree_view_column_add_attribute(col, renderer, "text", FrameColumns[i].column); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(frame_column_clicked), this); tColData *data = (tColData*)g_malloc(sizeof(tColData)); data->col = col; data->data = &FrameColumns[i]; m_FrameCols = g_slist_append(m_FrameCols, data); if (FrameColumns[i].maxtext) w = text_width(m_FrameView, FrameColumns[i].maxtext); else w = text_width(m_FrameView, FrameColumns[i].caption); width += w + 24; } gtk_tree_view_set_model(GTK_TREE_VIEW(m_FrameView), GTK_TREE_MODEL(m_Frames)); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(m_FrameView), true); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_FrameView)), GTK_SELECTION_SINGLE); m_FrameBox = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_FrameBox), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(m_FrameBox), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(m_FrameBox), m_FrameView); gtk_widget_set_size_request(m_FrameView, width, -1); gtk_table_attach(GTK_TABLE(tbox), m_FrameBox, 0, 1, 0, 2, GTK_FILL, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0); // Register callback for selection change GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_FrameView)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this); // Catalog files m_CatalogView = gtk_tree_view_new(); for (i=0; CatalogColumns[i].caption!=NULL; i++) { GtkTreeViewColumn *col = gtk_tree_view_column_new(); // Set column name and alignment gtk_tree_view_column_set_title(col, CatalogColumns[i].caption); gtk_tree_view_append_column(GTK_TREE_VIEW(m_CatalogView), col); // Add text renderer GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); g_object_set(renderer, "xalign", CatalogColumns[i].align, NULL); if (CatalogColumns[i].datafn) gtk_tree_view_column_set_cell_data_func(col, renderer, CatalogColumns[i].datafn, NULL, NULL); else gtk_tree_view_column_add_attribute(col, renderer, "text", CatalogColumns[i].column); tColData *data = (tColData*)g_malloc(sizeof(tColData)); data->col = col; data->data = &CatalogColumns[i]; m_CatalogCols = g_slist_append(m_CatalogCols, data); } gtk_tree_view_set_model(GTK_TREE_VIEW(m_CatalogView), GTK_TREE_MODEL(m_Catalogs)); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(m_CatalogView), true); m_CatalogBox = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_CatalogBox), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(m_CatalogBox), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(m_CatalogBox), m_CatalogView); gtk_widget_set_size_request(m_CatalogView, width, -1); gtk_table_attach(GTK_TABLE(tbox), m_CatalogBox, 1, 2, 0, 2, GTK_FILL, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0); // Register callback for selection change selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_CatalogView)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this); // Toolbox tbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_TEXT); m_ShowChart = toolbar_new_radio_button(tbar, NULL, "Chart", "Display objects on a flat background"); g_signal_connect(G_OBJECT(m_ShowChart), "toggled", G_CALLBACK(button_clicked), this); m_ShowImage = toolbar_new_radio_button(tbar, m_ShowChart, "Image", "Display an image only"); g_signal_connect(G_OBJECT(m_ShowImage), "toggled", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(tbox), tbar, 2, 3, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0); // Frame preview frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); m_Preview = cmpack_chart_view_new(); gtk_container_add(GTK_CONTAINER(frame), m_Preview); gtk_widget_set_size_request(frame, 160, 120); gtk_table_attach_defaults(GTK_TABLE(tbox), frame, 2, 3, 1, 2); // Bottom toolbox hbox = gtk_hbox_new(FALSE, 8); m_OptionsBtn = gtk_button_new_with_label("Options"); gtk_widget_set_tooltip_text(m_OptionsBtn, "Edit project settings"); gtk_box_pack_start(GTK_BOX(hbox), m_OptionsBtn, 0, 0, 0); g_signal_connect(G_OBJECT(m_OptionsBtn), "clicked", G_CALLBACK(button_clicked), this); m_PathLabel = gtk_label_new("Search path:"); gtk_box_pack_start(GTK_BOX(hbox), m_PathLabel, FALSE, TRUE, 0); m_PathEntry = gtk_entry_new(); gtk_widget_set_tooltip_text(m_PathEntry, "Path to the folder with catalog files"); gtk_editable_set_editable(GTK_EDITABLE(m_PathEntry), false); gtk_box_pack_start(GTK_BOX(hbox), m_PathEntry, TRUE, TRUE, 0); m_PathBtn = gtk_button_new_with_label("Change folder"); gtk_widget_set_tooltip_text(m_PathBtn, "Change folder with catalog files"); g_signal_connect(G_OBJECT(m_PathBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_box_pack_start(GTK_BOX(hbox), m_PathBtn, FALSE, TRUE, 0); gtk_table_attach(GTK_TABLE(tbox), hbox, 0, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox); }
/* Constrcut side bar widget. */ static GtkWidget * libre_impuesto_window_construct_sidebar (LibreImpuesto *impuesto, LibreImpuestoWindow *impuesto_window) { GtkStack * stack; GtkWidget *switcher; GtkTreePath *tree_path; GtkTreeStore * tree_store; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *cell_renderer; GtkWidget *paned, *box_switcher, *widget, *frame, *scroll; paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); g_object_bind_property (impuesto_window, "sidebar-visible", paned, "visible", G_BINDING_SYNC_CREATE); box_switcher = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); switcher = gtk_stack_switcher_new (); g_object_set_data(G_OBJECT(impuesto_window), "switcher", switcher); gtk_orientable_set_orientation (GTK_ORIENTABLE (switcher), GTK_ORIENTATION_VERTICAL); gtk_box_pack_end (GTK_BOX (box_switcher), switcher, FALSE, FALSE, 0); stack = GTK_STACK (gtk_stack_new ()); gtk_stack_set_homogeneous ( stack, TRUE); gtk_box_pack_end (GTK_BOX (box_switcher), GTK_WIDGET(stack), TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); tree_store = libre_impuesto_get_tree_data_general( impuesto ); widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL(tree_store)); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (column,_( "Libre Impuestos")); cell_renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell_renderer, FALSE); gtk_tree_view_column_add_attribute (column, cell_renderer, "pixbuf", 0); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_add_attribute (column, cell_renderer, "text", 1); gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column); gtk_tree_view_expand_all(GTK_TREE_VIEW(widget)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)); g_signal_connect_swapped ( selection, "changed", G_CALLBACK (node_tree_selection_changed_cb), G_OBJECT (impuesto_window)); gtk_container_add (GTK_CONTAINER (scroll), widget); gtk_container_add_with_properties (GTK_CONTAINER (stack), scroll, "name", _("Generales"), "title",_("General Options"), "icon-name", GTK_STOCK_HOME, NULL); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); tree_store = libre_impuesto_get_tree_data_formulario( impuesto ); widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL(tree_store)); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (column, _("Electronic Forms")); cell_renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell_renderer, FALSE); gtk_tree_view_column_add_attribute (column, cell_renderer, "pixbuf", 0); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_add_attribute (column, cell_renderer, "text", 1); gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)); g_signal_connect_swapped ( selection, "changed", G_CALLBACK (node_tree_selection_changed_cb), G_OBJECT (impuesto_window)); gtk_container_add (GTK_CONTAINER (scroll), widget); gtk_container_add_with_properties (GTK_CONTAINER (stack), scroll, "name", _("Modulos"), "title",_( "Electronic Forms"), "icon-name", GTK_STOCK_HOME, NULL); tree_path = gtk_tree_path_new_from_string ("0"); gtk_tree_view_expand_row (GTK_TREE_VIEW(widget), tree_path, FALSE); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); tree_store = libre_impuesto_get_tree_data_consultor( impuesto ); widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL(tree_store)); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (column,_("Consultores")); cell_renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell_renderer, FALSE); gtk_tree_view_column_add_attribute (column, cell_renderer, "pixbuf", 0); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_add_attribute (column, cell_renderer, "text", 1); gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)); g_signal_connect_swapped ( selection, "changed", G_CALLBACK (node_tree_selection_changed_cb), G_OBJECT (impuesto_window)); gtk_container_add (GTK_CONTAINER (scroll), widget); gtk_container_add_with_properties (GTK_CONTAINER (stack), scroll, "name", _("Consultores"), "title",_( "Consultores"), "icon-name", GTK_STOCK_HOME, NULL); tree_path = gtk_tree_path_new_from_string ("0"); gtk_tree_view_expand_row (GTK_TREE_VIEW(widget), tree_path, FALSE); gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (stack)); gtk_paned_pack1 ( GTK_PANED(paned), box_switcher, TRUE, FALSE ); gtk_widget_show_all (box_switcher); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); widget = gtk_drawing_area_new (); gtk_widget_set_name (widget, "logo"); /*gtk_widget_set_size_request (widget, gdk_pixbuf_get_width (logo), gdk_pixbuf_get_height (logo));*/ gtk_widget_set_size_request (widget, -1, 50); g_signal_connect (widget, "draw", G_CALLBACK (draw_area_cb), NULL); gtk_container_add (GTK_CONTAINER (frame), widget); gtk_paned_pack2 (GTK_PANED(paned), frame, TRUE, FALSE); return paned; }
void gui_init(dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); // gtk_widget_set_size_request(self->widget, DT_PIXEL_APPLY_DPI(100), -1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->current), _("attached tags,\ndoubleclick to detach")); g_signal_connect(G_OBJECT(d->current), "row-activated", G_CALLBACK(detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; gtk_widget_set_tooltip_text(button, _("attach tag to all selected images")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; gtk_widget_set_tooltip_text(button, _("detach tag from all selected images")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); gtk_widget_set_tooltip_text(w, _("enter tag name")); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->related), _("related tags,\ndoubleclick to attach")); g_signal_connect(G_OBJECT(d->related), "row-activated", G_CALLBACK(attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; gtk_widget_set_tooltip_text(button, _("create a new tag with the\nname you entered")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; gtk_widget_set_tooltip_text(button, _("delete selected tag")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED, G_CALLBACK(_lib_tagging_tags_changed_callback), self); update(self, 0); set_keyword(self, d); }
static void gth_metadata_chooser_instance_init (GthMetadataChooser *self) { GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTH_TYPE_METADATA_CHOOSER, GthMetadataChooserPrivate); /* the list view */ store = gtk_list_store_new (N_COLUMNS, PANGO_TYPE_WEIGHT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); gtk_tree_view_set_model (GTK_TREE_VIEW (self), GTK_TREE_MODEL (store)); g_object_unref (store); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self), FALSE); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (self), row_separator_func, self, NULL); self->priv->row_inserted_event = g_signal_connect (store, "row-inserted", G_CALLBACK (row_inserted_cb), self); self->priv->row_deleted_event = g_signal_connect (store, "row-deleted", G_CALLBACK (row_deleted_cb), self); /* the checkbox column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (cell_renderer_toggle_toggled_cb), self); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "active", USED_COLUMN, "visible", IS_METADATA_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self), column); /* the name column. */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", NAME_COLUMN, "weight", WEIGHT_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (self), column); }
static void tab_panel_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkTreeStore* model; GtkWidget* treeview; GtkTreeViewColumn* column; GtkCellRenderer* renderer_pixbuf; GtkCellRenderer* renderer_text; GtkWidget* panel; GtkWidget* toolbar; gint i; /* GtkToolItem* toolitem; */ g_object_set (browser, "show-tabs", FALSE, NULL); panel = katze_object_get_object (browser, "panel"); model = gtk_tree_store_new (7, MIDORI_TYPE_VIEW, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_COLOR); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-model", model); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (treeview), FALSE); #if GTK_CHECK_VERSION (2, 12, 0) g_signal_connect (treeview, "query-tooltip", G_CALLBACK (tab_panel_treeview_query_tooltip_cb), NULL); gtk_widget_set_has_tooltip (treeview, TRUE); #endif column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "pixbuf", 3, "cell-background-gdk", 6, NULL); renderer_text = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer_text, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_text, "text", 4, "ellipsize", 5, "cell-background-gdk", 6, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "stock-id", 1, "follow-state", 2, "visible", 2, "cell-background-gdk", 6, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); g_object_connect (treeview, "signal::row-activated", midori_extension_row_activated_cb, extension, "signal::cursor-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::columns-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::button-release-event", midori_extension_button_release_event_cb, extension, "signal::key-release-event", midori_extension_key_release_event_cb, extension, "signal::popup-menu", midori_extension_popup_menu_cb, extension, NULL); gtk_widget_show (treeview); toolbar = gtk_toolbar_new (); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-toolbar", toolbar); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON); gtk_widget_show (toolbar); /* TODO: Implement optional thumbnail images toolitem = gtk_toggle_tool_button_new_from_stock (STOCK_IMAGE); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "toggled", G_CALLBACK (tab_panel_button_thumbnail_toggled_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); */ i = midori_panel_append_widget (MIDORI_PANEL (panel), treeview, STOCK_TAB_PANEL, _("Tab Panel"), toolbar); if (gtk_widget_get_visible (GTK_WIDGET (browser))) midori_panel_set_current_page (MIDORI_PANEL (panel), i); g_object_unref (panel); midori_browser_foreach (browser, (GtkCallback)tab_panel_browser_foreach_cb, treeview); g_signal_connect_after (browser, "add-tab", G_CALLBACK (tab_panel_browser_add_tab_cb), extension); g_signal_connect (browser, "remove-tab", G_CALLBACK (tab_panel_browser_remove_tab_cb), extension); g_signal_connect (browser, "notify::tab", G_CALLBACK (tab_panel_browser_notify_tab_cb), treeview); g_signal_connect (extension, "deactivate", G_CALLBACK (tab_panel_deactivate_cb), treeview); }
int main (int argc, char **argv) { GtkWidget *window, *vbox, *hbox, *frame; GtkWidget *button, *scrolled, *table; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GdkRGBA black = {0,0,0,1}; GFile *file; gtk_init (&argc, &argv); main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 0); g_signal_connect (G_OBJECT (window), "delete-event", gtk_main_quit, NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_widget_show (hbox); frame = gtk_frame_new ("GdkWindows"); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 5); gtk_widget_show (frame); darea = gtk_drawing_area_new (); /*gtk_widget_set_double_buffered (darea, FALSE);*/ gtk_widget_add_events (darea, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_widget_set_size_request (darea, 500, 500); g_signal_connect (darea, "button_release_event", G_CALLBACK (darea_button_release_event), NULL); gtk_container_add (GTK_CONTAINER (frame), darea); gtk_widget_realize (darea); gtk_widget_show (darea); gtk_widget_override_background_color (darea, 0, &black); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 5); gtk_widget_show (vbox); window_store = gtk_tree_store_new (1, GDK_TYPE_WINDOW); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (window_store)); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Window"); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, render_window_cell, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scrolled, 200, 400); gtk_container_add (GTK_CONTAINER (scrolled), treeview); gtk_box_pack_start (GTK_BOX (vbox), scrolled, FALSE, FALSE, 5); gtk_widget_show (scrolled); gtk_widget_show (treeview); table = gtk_table_new (5, 4, TRUE); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 2); gtk_widget_show (table); button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (move_window_clicked), GINT_TO_POINTER (GTK_DIR_LEFT)); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 1, 2); gtk_widget_show (button); button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (move_window_clicked), GINT_TO_POINTER (GTK_DIR_UP)); gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 2, 0, 1); gtk_widget_show (button); button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (move_window_clicked), GINT_TO_POINTER (GTK_DIR_RIGHT)); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 1, 2); gtk_widget_show (button); button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (move_window_clicked), GINT_TO_POINTER (GTK_DIR_DOWN)); gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 2, 2, 3); gtk_widget_show (button); button = gtk_button_new_with_label ("Raise"); g_signal_connect (button, "clicked", G_CALLBACK (raise_window_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 0, 1); gtk_widget_show (button); button = gtk_button_new_with_label ("Lower"); g_signal_connect (button, "clicked", G_CALLBACK (lower_window_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 2, 3); gtk_widget_show (button); button = gtk_button_new_with_label ("Smaller"); g_signal_connect (button, "clicked", G_CALLBACK (smaller_window_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 0, 1); gtk_widget_show (button); button = gtk_button_new_with_label ("Larger"); g_signal_connect (button, "clicked", G_CALLBACK (larger_window_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 2, 3); gtk_widget_show (button); button = gtk_button_new_with_label ("Native"); g_signal_connect (button, "clicked", G_CALLBACK (native_window_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 2, 1, 2); gtk_widget_show (button); button = gtk_button_new_with_label ("scroll"); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (scroll_window_clicked), GINT_TO_POINTER (GTK_DIR_UP)); gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 0, 1); gtk_widget_show (button); button = gtk_button_new_with_label ("scroll"); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect (button, "clicked", G_CALLBACK (scroll_window_clicked), GINT_TO_POINTER (GTK_DIR_DOWN)); gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2); gtk_widget_show (button); button = gtk_button_new_with_label ("Manual"); g_signal_connect (button, "clicked", G_CALLBACK (manual_clicked), NULL); gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 2, 3); gtk_widget_show (button); button = gtk_button_new_with_label ("Restack above"); g_signal_connect (button, "clicked", G_CALLBACK (restack_clicked), GINT_TO_POINTER (1)); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 3, 4); gtk_widget_show (button); button = gtk_button_new_with_label ("Restack below"); g_signal_connect (button, "clicked", G_CALLBACK (restack_clicked), 0); gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 3, 4); gtk_widget_show (button); button = gtk_button_new_with_label ("Add window"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (add_window_clicked), NULL); button = gtk_button_new_with_label ("Remove window"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (remove_window_clicked), NULL); button = gtk_button_new_with_label ("Save"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (save_clicked), NULL); gtk_widget_show (window); if (argc == 2) { file = g_file_new_for_commandline_arg (argv[1]); load_file (file); g_object_unref (file); } gtk_main (); return 0; }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ static void pagesel_init (Pagesel *pagesel) { GtkWidget *scrolled_win, *treeview, *label; GtkTreeModel *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; /* dialog initialization */ g_object_set (G_OBJECT (pagesel), /* GtkContainer */ "border-width", 0, /* GtkWindow */ "title", _("Page Manager"), "default-height", 180, "default-width", 515, "modal", FALSE, "window-position", GTK_WIN_POS_NONE, "type-hint", GDK_WINDOW_TYPE_HINT_NORMAL, /* GtkDialog */ "has-separator", TRUE, NULL); /* create the model for the treeview */ store = (GtkTreeModel*)gtk_tree_store_new (NUM_COLUMNS, G_TYPE_POINTER, /* page */ G_TYPE_STRING, /* name */ G_TYPE_BOOLEAN); /* changed */ /* create a scrolled window for the treeview */ scrolled_win = GTK_WIDGET ( g_object_new (GTK_TYPE_SCROLLED_WINDOW, /* GtkContainer */ "border-width", 5, /* GtkScrolledWindow */ "hscrollbar-policy", GTK_POLICY_AUTOMATIC, "vscrollbar-policy", GTK_POLICY_ALWAYS, "shadow-type", GTK_SHADOW_ETCHED_IN, NULL)); /* create the treeview */ treeview = GTK_WIDGET (g_object_new (GTK_TYPE_TREE_VIEW, /* GtkTreeView */ "model", store, "rules-hint", TRUE, NULL)); g_signal_connect (treeview, "button-press-event", G_CALLBACK (pagesel_callback_button_pressed), pagesel); g_signal_connect (treeview, "popup-menu", G_CALLBACK (pagesel_callback_popup_menu), pagesel); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (pagesel_callback_selection_changed), pagesel); /* - first column: page name */ renderer = GTK_CELL_RENDERER ( g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, /* GtkCellRendererText */ "editable", FALSE, NULL)); column = GTK_TREE_VIEW_COLUMN ( g_object_new (GTK_TYPE_TREE_VIEW_COLUMN, /* GtkTreeViewColumn */ "title", _("Filename"), "min-width", 400, "resizable", TRUE, NULL)); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", COLUMN_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); /* - second column: changed */ renderer = GTK_CELL_RENDERER ( g_object_new (GTK_TYPE_CELL_RENDERER_TOGGLE, /* GtkCellRendererToggle */ "activatable", FALSE, NULL)); column = GTK_TREE_VIEW_COLUMN ( g_object_new (GTK_TYPE_TREE_VIEW_COLUMN, /* GtkTreeViewColumn */ "title", _("Changed"), "sizing", GTK_TREE_VIEW_COLUMN_FIXED, NULL)); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "active", COLUMN_CHANGED); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); /* add the treeview to the scrolled window */ gtk_container_add (GTK_CONTAINER (scrolled_win), treeview); /* set treeview of pagesel */ pagesel->treeview = GTK_TREE_VIEW (treeview); /* add the scrolled window to the dialog vbox */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pagesel)->vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show_all (scrolled_win); /* add a label below the scrolled window */ label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, /* GtkLabel */ "label", _("Right click on the filename for more options..."), NULL)); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pagesel)->vbox), label, FALSE, TRUE, 5); gtk_widget_show (label); /* now add buttons in the action area */ gtk_dialog_add_buttons (GTK_DIALOG (pagesel), /* - update button */ GTK_STOCK_REFRESH, PAGESEL_RESPONSE_UPDATE, /* - close button */ GTK_STOCK_CLOSE, PAGESEL_RESPONSE_CLOSE, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(pagesel), PAGESEL_RESPONSE_UPDATE, PAGESEL_RESPONSE_CLOSE, -1); g_signal_connect( pagesel, "notify::gschem-toplevel", G_CALLBACK( notify_gschem_toplevel_cb ), NULL ); }
void pragha_filter_dialog (PraghaPlaylist *playlist) { PraghaPreferences *preferences; GtkWidget *dialog, *scrollwin, *vbox, *search_entry; GtkWidget *filter_view = NULL; GtkListStore *filter_store; GtkTreeModel *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; PraghaFilterDialog *fdialog; fdialog = g_slice_new0(PraghaFilterDialog); preferences = pragha_preferences_get (); /* Crete the filter entry */ search_entry = pragha_search_entry_new(preferences); g_signal_connect (G_OBJECT(search_entry), "changed", G_CALLBACK(simple_filter_search_keyrelease_handler), fdialog); g_signal_connect (G_OBJECT(search_entry), "activate", G_CALLBACK(simple_filter_search_activate_handler), fdialog); /* Create the view */ filter_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", 0, NULL); gtk_tree_view_column_set_spacing (column, 4); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "markup", 1, NULL); gtk_tree_view_column_set_spacing (column, 4); /* Fill the filter tree view with current playlist */ pragha_filter_dialog_fill_model (filter_store, playlist); filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(filter_store), NULL); g_object_unref(filter_store); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_model_visible_func, fdialog, NULL); /* Create the tree view */ filter_view = gtk_tree_view_new_with_model(filter_model); gtk_tree_view_append_column (GTK_TREE_VIEW(filter_view), column); g_object_unref(G_OBJECT(filter_model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(filter_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(filter_view), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(filter_view), FALSE); /* Store references */ fdialog->filter_view = filter_view; fdialog->filter_model = filter_model; fdialog->filter_string = NULL; fdialog->timeout_id = 0; fdialog->cplaylist = playlist; fdialog->preferences = preferences; /* The search dialog */ dialog = gtk_dialog_new_with_buttons (_("Search in playlist"), GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(playlist))), GTK_DIALOG_MODAL, _("_Close"), GTK_RESPONSE_CANCEL, NULL); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Add to playback queue"), GTK_RESPONSE_ACCEPT); gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Jump to"), GTK_RESPONSE_APPLY); gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 500); /* Add to the dialog's main vbox */ vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start (GTK_BOX(vbox), search_entry, FALSE, FALSE, 3); scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER(scrollwin), filter_view); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); /* Connect signals */ g_signal_connect (filter_view, "row-activated", G_CALLBACK(pragha_filter_dialog_activated_cb), dialog); g_signal_connect (filter_view, "key_press_event", G_CALLBACK (pragha_filter_dialog_key_press), fdialog); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(pragha_filter_dialog_response), fdialog); gtk_widget_show_all (dialog); }
GtkWidget * gimp_action_view_new (GimpUIManager *manager, const gchar *select_action, gboolean show_shortcuts) { GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeStore *store; GtkTreeModel *filter; GtkAccelGroup *accel_group; GList *list; GtkTreePath *select_path = NULL; g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL); store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS, G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */ GTK_TYPE_ACTION, /* COLUMN_ACTION */ G_TYPE_STRING, /* COLUMN_ICON_NAME */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */ G_TYPE_STRING, /* COLUMN_NAME */ G_TYPE_UINT, /* COLUMN_ACCEL_KEY */ GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */ G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */ accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager)); for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager)); list; list = g_list_next (list)) { GimpActionGroup *group = list->data; GList *actions; GList *list2; GtkTreeIter group_iter; gtk_tree_store_append (store, &group_iter, NULL); gtk_tree_store_set (store, &group_iter, GIMP_ACTION_VIEW_COLUMN_ICON_NAME, group->icon_name, GIMP_ACTION_VIEW_COLUMN_LABEL, group->label, -1); actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group)); actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare); for (list2 = actions; list2; list2 = g_list_next (list2)) { GtkAction *action = list2->data; const gchar *name = gtk_action_get_name (action); const gchar *icon_name = gtk_action_get_icon_name (action); gchar *label; gchar *label_casefold; guint accel_key = 0; GdkModifierType accel_mask = 0; GClosure *accel_closure = NULL; GtkTreeIter action_iter; if (gimp_action_is_gui_blacklisted (name)) continue; label = gimp_strip_uline (gtk_action_get_label (action)); if (! (label && strlen (label))) { g_free (label); label = g_strdup (name); } label_casefold = g_utf8_casefold (label, -1); if (show_shortcuts) { accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelKey *key; key = gtk_accel_group_find (accel_group, gimp_action_view_accel_find_func, accel_closure); if (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE) { accel_key = key->accel_key; accel_mask = key->accel_mods; } } } gtk_tree_store_append (store, &action_iter, &group_iter); gtk_tree_store_set (store, &action_iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE, GIMP_ACTION_VIEW_COLUMN_ACTION, action, GIMP_ACTION_VIEW_COLUMN_ICON_NAME, icon_name, GIMP_ACTION_VIEW_COLUMN_LABEL, label, GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold, GIMP_ACTION_VIEW_COLUMN_NAME, name, GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key, GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask, GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure, -1); g_free (label); g_free (label_casefold); if (select_action && ! strcmp (select_action, name)) { select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &action_iter); } } g_list_free (actions); } filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); g_object_unref (store); view = g_object_new (GIMP_TYPE_ACTION_VIEW, "model", filter, "rules-hint", TRUE, NULL); g_object_unref (filter); gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), GIMP_ACTION_VIEW_COLUMN_VISIBLE); GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager); GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts; gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), GIMP_ACTION_VIEW_COLUMN_LABEL); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Action")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "icon-name", GIMP_ACTION_VIEW_COLUMN_ICON_NAME, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); if (show_shortcuts) { g_signal_connect (view, "button-press-event", G_CALLBACK (gimp_action_view_button_press), NULL); g_signal_connect (accel_group, "accel-changed", G_CALLBACK (gimp_action_view_accel_changed), view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut")); cell = gtk_cell_renderer_accel_new (); g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "accel-key", GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, "accel-mods", GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, NULL); g_signal_connect (cell, "accel-edited", G_CALLBACK (gimp_action_view_accel_edited), view); g_signal_connect (cell, "accel-cleared", G_CALLBACK (gimp_action_view_accel_cleared), view); gtk_tree_view_append_column (view, column); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Name")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_NAME, NULL); gtk_tree_view_append_column (view, column); if (select_path) { gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path); gtk_tree_path_free (select_path); } return GTK_WIDGET (view); }
static void gimp_controller_list_init (GimpControllerList *list) { GtkWidget *hbox; GtkWidget *sw; GtkWidget *tv; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *vbox; GtkWidget *image; GtkIconSize icon_size; gint icon_width; gint icon_height; GType *controller_types; guint n_controller_types; gint i; gtk_orientable_set_orientation (GTK_ORIENTABLE (list), GTK_ORIENTATION_VERTICAL); list->gimp = NULL; list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_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); gtk_widget_show (sw); list->src = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_GTYPE); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src)); g_object_unref (list->src); gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Available Controllers")); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "icon-name", COLUMN_ICON, NULL); g_object_get (cell, "stock-size", &icon_size, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (tv); g_signal_connect_object (tv, "row-activated", G_CALLBACK (gimp_controller_list_row_activated), G_OBJECT (list), 0); list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE); g_signal_connect_object (list->src_sel, "changed", G_CALLBACK (gimp_controller_list_src_sel_changed), G_OBJECT (list), 0); controller_types = g_type_children (GIMP_TYPE_CONTROLLER, &n_controller_types); for (i = 0; i < n_controller_types; i++) { GimpControllerClass *controller_class; GtkTreeIter iter; controller_class = g_type_class_ref (controller_types[i]); gtk_list_store_append (list->src, &iter); gtk_list_store_set (list->src, &iter, COLUMN_ICON, controller_class->icon_name, COLUMN_NAME, controller_class->name, COLUMN_TYPE, controller_types[i], -1); g_type_class_unref (controller_class); } g_free (controller_types); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); list->add_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->add_button, FALSE); gtk_widget_show (list->add_button); image = gtk_image_new_from_icon_name ("go-next", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->add_button), image); gtk_widget_show (image); g_signal_connect (list->add_button, "clicked", G_CALLBACK (gimp_controller_list_add_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->add_button), (gpointer) &list->add_button); list->remove_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->remove_button, FALSE); gtk_widget_show (list->remove_button); image = gtk_image_new_from_icon_name ("go-previous", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->remove_button), image); gtk_widget_show (image); g_signal_connect (list->remove_button, "clicked", G_CALLBACK (gimp_controller_list_remove_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->remove_button), (gpointer) &list->remove_button); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)), icon_size, &icon_width, &icon_height); list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0); gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest), _("Active Controllers")); gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view, TRUE); gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0); gtk_widget_show (list->dest); g_signal_connect_object (list->dest, "select-item", G_CALLBACK (gimp_controller_list_select_item), G_OBJECT (list), 0); g_signal_connect_object (list->dest, "activate-item", G_CALLBACK (gimp_controller_list_activate_item), G_OBJECT (list), 0); list->edit_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "document-properties", _("Configure the selected controller"), NULL, G_CALLBACK (gimp_controller_list_edit_clicked), NULL, list); list->up_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-up", _("Move the selected controller up"), NULL, G_CALLBACK (gimp_controller_list_up_clicked), NULL, list); list->down_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-down", _("Move the selected controller down"), NULL, G_CALLBACK (gimp_controller_list_down_clicked), NULL, list); gtk_widget_set_sensitive (list->edit_button, FALSE); gtk_widget_set_sensitive (list->up_button, FALSE); gtk_widget_set_sensitive (list->down_button, FALSE); }
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); }
GtkWidget * create_disk_view(ProcData *procdata) { GtkWidget *disk_box; GtkWidget *label; GtkWidget *scrolled; GtkWidget *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; disk_box = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12); label = make_title_label(_("File Systems")); gtk_box_pack_start(GTK_BOX(disk_box), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); procdata->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), disk_tree); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(disk_tree), TRUE); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); cell = gtk_cell_renderer_progress_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); /* numeric sort */ gtk_widget_show_all(disk_box); procman_get_tree_state(procdata->client, disk_tree, "/apps/procman/disktreenew"); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), procdata); return disk_box; }
static ReportDialog * report_dialog_new(GtkTreeModel * model, GtkWidget * parent) { ReportDialog *rd; GtkWidget *dialog; GtkWidget *dialog1_vbox; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *hbuttonbox3; GtkWidget *button3; GtkWidget *button6; GtkWidget *dialog1_action_area; GtkWidget *button8; GtkWidget *button7; GtkWidget *label; GtkWidget *hbox; GtkTreeViewColumn *column; GtkCellRenderer *cr_text, *cr_pbuf, *cr_toggle; rd = g_new0(ReportDialog, 1); dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), "Generate Report"); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); dialog1_vbox = GTK_DIALOG(dialog)->vbox; gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5); gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4); gtk_widget_show(dialog1_vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("<big><b>Generate Report</b></big>\n" "Please choose the information that you wish " "to view in your report:"); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), icon_cache_get_image("report-large.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_widget_show_all(hbox); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow2, -1, 200); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); treeview2 = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE); gtk_widget_show(treeview2); gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column); cr_toggle = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, cr_toggle, FALSE); g_signal_connect(cr_toggle, "toggled", G_CALLBACK(report_dialog_sel_toggle), rd); gtk_tree_view_column_add_attribute(column, cr_toggle, "active", TREE_COL_SEL); cr_pbuf = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, cr_pbuf, FALSE); gtk_tree_view_column_add_attribute(column, cr_pbuf, "pixbuf", TREE_COL_PBUF); cr_text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cr_text, TRUE); gtk_tree_view_column_add_attribute(column, cr_text, "markup", TREE_COL_NAME); hbuttonbox3 = gtk_hbutton_box_new(); gtk_widget_show(hbuttonbox3); gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbuttonbox3, FALSE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox3), GTK_BUTTONBOX_SPREAD); button3 = gtk_button_new_with_mnemonic("Select _None"); gtk_widget_show(button3); gtk_container_add(GTK_CONTAINER(hbuttonbox3), button3); GTK_WIDGET_SET_FLAGS(button3, GTK_CAN_DEFAULT); g_signal_connect(button3, "clicked", G_CALLBACK(report_dialog_sel_none), rd); button6 = gtk_button_new_with_mnemonic("Select _All"); gtk_widget_show(button6); gtk_container_add(GTK_CONTAINER(hbuttonbox3), button6); GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT); g_signal_connect(button6, "clicked", G_CALLBACK(report_dialog_sel_all), rd); dialog1_action_area = GTK_DIALOG(dialog)->action_area; gtk_widget_show(dialog1_action_area); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area), GTK_BUTTONBOX_END); button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(button8); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT); button7 = gtk_button_new_with_mnemonic("_Generate"); gtk_widget_show(button7); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT); rd->dialog = dialog; rd->btn_cancel = button8; rd->btn_generate = button7; rd->btn_sel_all = button6; rd->btn_sel_none = button3; rd->treeview = treeview2; rd->model = model; gtk_tree_view_collapse_all(GTK_TREE_VIEW(treeview2)); set_all_active(rd, TRUE); return rd; }
void create_text_int_tree_view(struct chara_int_clist *ci_clist, GtkTreeView *ci_tree_view, GtkCellRenderer *renderer_text, GtkCellRenderer *renderer_spin) { /* GtkTreeModel *child_model = GTK_TREE_MODEL(user_data);*/ GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *child_model; GtkAdjustment *adjust; int i; /* Construct empty list storage */ child_model = gtk_list_store_new(4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE); g_object_set_data(G_OBJECT(child_model), "selection_list", NULL); /* ソート用のモデルを作成してツリービューにセットする */ model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(child_model)); gtk_tree_view_set_model(GTK_TREE_VIEW(ci_tree_view), model); /* First raw */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(ci_tree_view, column); gtk_tree_view_column_set_title(column, "Index"); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_FIELD_INDEX, NULL); g_object_set(renderer, "width", (gint)60, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_clickable(column, TRUE); g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_INDEX)); g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), ci_tree_view); /* Second row */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(ci_tree_view, column); gtk_tree_view_column_set_title(column, ci_clist->c1_name); g_object_set(G_OBJECT(renderer_text), "editable", TRUE, NULL); gtk_tree_view_column_pack_start(column, renderer_text, TRUE); gtk_tree_view_column_set_attributes(column, renderer_text, "text", COLUMN_FIELD_NAME, NULL); g_object_set(renderer_text, "width", (gint)150, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_clickable(column, TRUE); g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_NAME)); g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), ci_tree_view); /* Third row */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(ci_tree_view, column); gtk_tree_view_column_set_title(column, ci_clist->i1_name); adjust = gtk_adjustment_new(2.5, -1.0e30, 1.0e30, 0.1, 100, 21474836); g_object_set(G_OBJECT(renderer_spin), "adjustment", adjust, "climb-rate", 0.5, "digits", 3, "editable", TRUE, "width", (gint)150, NULL); gtk_tree_view_column_pack_start(column, renderer_spin, TRUE); gtk_tree_view_column_set_attributes(column, renderer_spin, "text", COLUMN_FIELD_VALUE, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_clickable(column, TRUE); g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_VALUE)); g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), ci_tree_view); /* 選択モード */ selection = gtk_tree_view_get_selection(ci_tree_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* sort */ column = gtk_tree_view_get_column(ci_tree_view, COLUMN_FIELD_INDEX); gtk_tree_view_column_set_sort_order(column, GTK_SORT_ASCENDING); gtk_tree_view_column_set_sort_indicator(column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), COLUMN_FIELD_INDEX, GTK_SORT_ASCENDING); }
static void status_menu_clear_status_message_dialog_run (StatusMenu *self) { GtkTreeIter iter, liter; GSList *conf_list [3] = { NULL, NULL, NULL }; GtkWidget *dialog = NULL; GtkWidget *vbox = NULL; GtkWidget *frame = NULL; GtkWidget *tree_view = NULL; GdkPixbuf *pixbuf = NULL; GtkTreeSelection *selection = NULL; GtkListStore *list_store = NULL; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; GtkWidget *label = NULL; bool found = false; bool close = false; int response = 0; int i = 0; gchar *message = NULL; std::string status; // Current status status = self->priv->personal_data_settings->get_string ("long-status"); // Build the dialog dialog = gtk_dialog_new_with_buttons (_("Custom Message"), self->priv->parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_DELETE, GTK_RESPONSE_APPLY, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DELETE); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, false, false, 2); label = gtk_label_new (_("Delete custom messages:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, false, false, 2); list_store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); g_object_unref (list_store); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), false); 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", 0, 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", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); frame = gtk_frame_new (NULL); gtk_container_add (GTK_CONTAINER (frame), tree_view); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 2); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->priv->list_store), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, COL_MESSAGE_TYPE, &i, -1); if (i == TYPE_CUSTOM_AVAILABLE || i == TYPE_CUSTOM_AWAY || i == TYPE_CUSTOM_BUSY) { gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, COL_ICON, &pixbuf, COL_MESSAGE, &message, -1); gtk_list_store_append (GTK_LIST_STORE (list_store), &liter); gtk_list_store_set (GTK_LIST_STORE (list_store), &liter, COL_ICON, pixbuf, COL_MESSAGE, message, COL_MESSAGE_TYPE, i, -1); g_free (message); g_object_unref (pixbuf); } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (self->priv->list_store), &iter)); } // Select the first iter selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) gtk_tree_selection_select_iter (selection, &iter); gtk_widget_show_all (dialog); while (!close) { response = gtk_dialog_run (GTK_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_APPLY: if (gtk_tree_selection_get_selected (selection, NULL, &iter)) gtk_list_store_remove (GTK_LIST_STORE (list_store), &iter); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) gtk_tree_selection_select_iter (selection, &iter); else close = true; break; case GTK_RESPONSE_CLOSE: default: close = true; } } if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, 1, &message, 2, &i, -1); if (!status.empty () && status == message) found = true; conf_list[i - NUM_STATUS_TYPES - 1] = g_slist_append (conf_list[i - NUM_STATUS_TYPES - 1], g_strdup (message)); g_free (message); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter)); } for (int j = 0 ; j < 3 ; j++) { self->priv->personal_data_settings->set_slist (status_types_keys[j], conf_list[j]); g_slist_foreach (conf_list[j], (GFunc) g_free, NULL); g_slist_free (conf_list[j]); } if (!found) { // Reset current config self->priv->personal_details->set_presence_info ("available", ""); } gtk_widget_destroy (dialog); }
/** * create the page to manually associate the transactions to the reconciles * show a complete list of orphans transactions, and for each of them, we propose * to link them to a reconcile * * \param assistant * * \return a GtkWidget, the page to the assistant * */ static GtkWidget *gsb_assistant_reconcile_config_page_manually_associate ( GtkWidget *assistant ) { GtkWidget *page; GtkWidget *label; GtkWidget *separator; GtkWidget *scrolled_window; gint i; GtkWidget *button; GtkWidget *hbox; GtkListStore *store; gchar *titles[] = { _("Date"), _("Payee"), _("Amount"), _("Account") }; gfloat alignment[] = { COLUMN_CENTER, COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER }; page = gtk_box_new ( GTK_ORIENTATION_VERTICAL, 0 ); gtk_container_set_border_width ( GTK_CONTAINER(page), 12 ); /* the number of transactions to link */ label_transactions_to_link_3 = gtk_label_new (NULL); gtk_box_pack_start ( GTK_BOX (page), label_transactions_to_link_3, FALSE, FALSE, 0 ); separator = gtk_separator_new ( GTK_ORIENTATION_HORIZONTAL ); gtk_box_pack_start ( GTK_BOX (page), separator, FALSE, FALSE, 0 ); /* now we can show the list of orphans transactions */ label = gtk_label_new (_("Select the transaction(s) you want to associate with a reconciliation: ")); gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 ); gtk_box_pack_start ( GTK_BOX (page), label, FALSE, FALSE, 10 ); scrolled_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start ( GTK_BOX (page), scrolled_window, TRUE, TRUE, 0 ); gtk_widget_show (scrolled_window); /* set up the tree view */ store = gtk_list_store_new ( TRANSACTION_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT ); treeview_transactions_to_link = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (G_OBJECT(store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview_transactions_to_link), TRUE); gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link)), GTK_SELECTION_MULTIPLE ); gtk_container_add ( GTK_CONTAINER (scrolled_window), treeview_transactions_to_link ); gtk_widget_show (treeview_transactions_to_link); /* set the columns */ for (i=TRANSACTION_DATE ; i<TRANSACTION_NUMBER ; i++) { GtkTreeViewColumn *column; GtkCellRenderer *cell; cell = gtk_cell_renderer_text_new (); g_object_set ( G_OBJECT (cell), "xalign", alignment[i], NULL ); 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_pack_start ( column, cell, TRUE ); gtk_tree_view_column_set_title ( column, titles[i] ); gtk_tree_view_column_set_attributes (column, cell, "text", i, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); gtk_tree_view_column_set_resizable ( column, TRUE ); gtk_tree_view_append_column ( GTK_TREE_VIEW(treeview_transactions_to_link), column); } /* set the button to associate */ hbox = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 0 ); gtk_box_set_homogeneous ( GTK_BOX ( hbox ), TRUE ); gtk_box_pack_start ( GTK_BOX (page), hbox, FALSE, FALSE, 10 ); button = gtk_button_new_with_label ( _("Link the selection to a reconciliation...")); g_signal_connect ( G_OBJECT (button), "clicked", G_CALLBACK (gsb_assistant_reconcile_config_lauch_manu_asso), assistant ); gtk_box_pack_start ( GTK_BOX (hbox), button, TRUE, TRUE, 0 ); gtk_widget_show_all (page); return page; }
static void gedit_documents_panel_init (GeditDocumentsPanel *panel) { GtkWidget *sw; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GIcon *icon; gedit_debug (DEBUG_PANEL); panel->priv = GEDIT_DOCUMENTS_PANEL_GET_PRIVATE (panel); panel->priv->adding_tab = FALSE; panel->priv->is_reodering = FALSE; gtk_orientable_set_orientation (GTK_ORIENTABLE (panel), GTK_ORIENTATION_VERTICAL); /* Create the scrolled window */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0); /* Create the empty model */ panel->priv->model = GTK_TREE_MODEL (gtk_tree_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT)); /* Create the treeview */ panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model); g_object_unref (G_OBJECT (panel->priv->model)); gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* TODO */ gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (panel->priv->treeview), 18); /* Disable search because each time the selection is changed, the active tab is changed which focuses the view, and thus would remove the search entry, rendering it useless */ gtk_tree_view_set_enable_search (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* Disable focus so it doesn't steal focus each time from the view */ gtk_widget_set_can_focus (panel->priv->treeview, FALSE); gtk_widget_set_has_tooltip (panel->priv->treeview, TRUE); gtk_widget_show (panel->priv->treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Documents")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN); gtk_tree_view_column_set_cell_data_func (column, cell, (GtkTreeCellDataFunc)pixbuf_data_func, panel, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview), column); cell = gedit_cell_renderer_button_new (); icon = g_themed_icon_new_with_default_fallbacks ("window-close-symbolic"); g_object_set (cell, "gicon", icon, NULL); g_object_unref (icon); gtk_tree_view_column_pack_end (column, cell, FALSE); g_signal_connect (cell, "clicked", G_CALLBACK (close_button_clicked), panel); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); panel->priv->selection_changed_handler_id = g_signal_connect (selection, "changed", G_CALLBACK (treeview_selection_changed), panel); g_signal_connect (panel->priv->treeview, "button-press-event", G_CALLBACK (panel_button_press_event), panel); g_signal_connect (panel->priv->treeview, "query-tooltip", G_CALLBACK (treeview_query_tooltip), panel); /* g_signal_connect (panel->priv->model, "row-inserted", G_CALLBACK (treeview_row_inserted), panel);*/ }
void gui_init(dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); GtkWidget *w; GtkWidget *scrolled; /* list */ d->list = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->list, FALSE); GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_STYLES_COL_NAME); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL); g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry = GTK_ENTRY(w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL); g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d); g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list)); d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0); g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); g_object_set(d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"), (char *)NULL); GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0); // create GtkWidget *cbutton = gtk_button_new_with_label(_("create")); g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d); g_object_set(G_OBJECT(cbutton), "tooltip-text", _("create styles from history stack of selected images"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0); // edit GtkWidget *widget = gtk_button_new_with_label(_("edit")); d->edit_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d); g_object_set(widget, "tooltip-text", _("edit the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // delete widget = gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d); g_object_set(widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // import button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; g_object_set(importButton, "tooltip-text", _("import style from a style file"), (char *)NULL); g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0); // export button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; g_object_set(exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL); g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); }
static void contact_list_view_setup (EmpathyContactListView *view) { EmpathyContactListViewPriv *priv; GtkCellRenderer *cell; GtkTreeViewColumn *col; gint i; priv = GET_PRIV (view); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (view), empathy_contact_list_store_search_equal_func, NULL, NULL); g_signal_connect (priv->store, "row-has-child-toggled", G_CALLBACK (contact_list_view_row_has_child_toggled_cb), view); gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (priv->store)); /* Setup view */ g_object_set (view, "headers-visible", FALSE, "reorderable", TRUE, "show-expanders", FALSE, NULL); col = gtk_tree_view_column_new (); /* State */ cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func ( col, cell, (GtkTreeCellDataFunc) contact_list_view_pixbuf_cell_data_func, view, NULL); g_object_set (cell, "xpad", 5, "ypad", 1, "visible", FALSE, NULL); /* Name */ cell = empathy_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, cell, TRUE); gtk_tree_view_column_set_cell_data_func ( col, cell, (GtkTreeCellDataFunc) contact_list_view_text_cell_data_func, view, NULL); gtk_tree_view_column_add_attribute (col, cell, "name", EMPATHY_CONTACT_LIST_STORE_COL_NAME); gtk_tree_view_column_add_attribute (col, cell, "status", EMPATHY_CONTACT_LIST_STORE_COL_STATUS); gtk_tree_view_column_add_attribute (col, cell, "is_group", EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP); /* Voip Capability Icon */ cell = empathy_cell_renderer_activatable_new (); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func ( col, cell, (GtkTreeCellDataFunc) contact_list_view_voip_cell_data_func, view, NULL); g_object_set (cell, "visible", FALSE, NULL); g_signal_connect (cell, "path-activated", G_CALLBACK (contact_list_view_voip_activated_cb), view); /* Avatar */ cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func ( col, cell, (GtkTreeCellDataFunc) contact_list_view_avatar_cell_data_func, view, NULL); g_object_set (cell, "xpad", 0, "ypad", 0, "visible", FALSE, "width", 32, "height", 32, NULL); /* Expander */ cell = empathy_cell_renderer_expander_new (); gtk_tree_view_column_pack_end (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func ( col, cell, (GtkTreeCellDataFunc) contact_list_view_expander_cell_data_func, view, NULL); /* Actually add the column now we have added all cell renderers */ gtk_tree_view_append_column (GTK_TREE_VIEW (view), col); /* Drag & Drop. */ for (i = 0; i < G_N_ELEMENTS (drag_types_dest); ++i) { drag_atoms_dest[i] = gdk_atom_intern (drag_types_dest[i].target, FALSE); } for (i = 0; i < G_N_ELEMENTS (drag_types_source); ++i) { drag_atoms_source[i] = gdk_atom_intern (drag_types_source[i].target, FALSE); } }
static void impl_constructed (GObject *object) { RBPodcastAddDialog *dialog; GtkBuilder *builder; GtkWidget *widget; GtkWidget *paned; GtkTreeViewColumn *column; GtkCellRenderer *renderer; RBEntryView *episodes; RBShellPlayer *shell_player; RhythmDBQuery *query; RhythmDBQueryModel *query_model; const char *episode_strings[3]; RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object); dialog = RB_PODCAST_ADD_DIALOG (object); g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL); builder = rb_builder_load ("podcast-add-dialog.ui", NULL); dialog->priv->info_bar_message = gtk_label_new (""); dialog->priv->info_bar = gtk_info_bar_new (); g_object_set (dialog->priv->info_bar, "spacing", 0, NULL); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))), dialog->priv->info_bar_message); gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE); gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0); gtk_widget_show (dialog->priv->info_bar_message); dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button")); g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE); dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view")); g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)), "changed", G_CALLBACK (feed_selection_changed_cb), dialog); dialog->priv->search_entry = rb_search_entry_new (FALSE); gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1); g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL); g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog); g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")), GTK_WIDGET (dialog->priv->search_entry)); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->feed_model = gtk_list_store_new (7, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* author */ GDK_TYPE_PIXBUF, /* image */ G_TYPE_FILE, /* image file */ G_TYPE_INT, /* episode count */ G_TYPE_POINTER, /* RBPodcastChannel */ G_TYPE_ULONG); /* date */ gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model)); column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, 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", FEED_COLUMN_TITLE, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL); episode_strings[0] = "0000"; episode_strings[1] = _("Episodes"); episode_strings[2] = NULL; rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog")); gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0); /* set up episode view */ g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL); episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog); /* date column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); { const char *sample_strings[3]; sample_strings[0] = _("Date"); sample_strings[1] = rb_entry_view_get_time_date_column_sample (); sample_strings[2] = NULL; rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings); } gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) podcast_post_date_cell_data_func, dialog, NULL); rb_entry_view_append_column_custom (episodes, column, _("Date"), "Date", (GCompareDataFunc) podcast_post_date_sort_func, 0, NULL); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE); rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING); g_signal_connect (episodes, "notify::sort-order", G_CALLBACK (episodes_sort_changed_cb), dialog); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH, RHYTHMDB_QUERY_END); query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (episodes, query_model); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query); rhythmdb_query_free (query); g_object_unref (query_model); paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned")); g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (episodes), TRUE, FALSE); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
GtkWidget * call_history_view_gtk_new (boost::shared_ptr<History::Book> book, G_GNUC_UNUSED boost::shared_ptr<Ekiga::CallCore> call_core, G_GNUC_UNUSED boost::shared_ptr<Ekiga::ContactCore> contact_core) { CallHistoryViewGtk* self = NULL; GtkListStore *store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; GtkTreeSelection *selection = NULL; g_return_val_if_fail (book, (GtkWidget*)NULL); self = (CallHistoryViewGtk*)g_object_new (CALL_HISTORY_VIEW_GTK_TYPE, NULL); self->priv = new _CallHistoryViewGtkPrivate (book); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* build the store then the tree */ store = gtk_list_store_new (COLUMN_NUMBER, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); self->priv->tree = (GtkTreeView*)gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->tree), FALSE); gtk_tree_view_set_grid_lines (self->priv->tree, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->tree)); g_object_unref (store); /* one column should be enough for everyone */ column = gtk_tree_view_column_new (); /* show icon */ 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", COLUMN_ERROR_PIXBUF); g_object_set (renderer, "xalign", 0.0, "yalign", 0.5, "xpad", 6, "stock-size", 1, NULL); /* show name and text */ renderer = gm_cell_renderer_bitext_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "primary-text", COLUMN_NAME); gtk_tree_view_column_add_attribute (column, renderer, "secondary-text", COLUMN_INFO); gtk_tree_view_append_column (self->priv->tree, column); /* show icon */ renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_end (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "icon-name", COLUMN_PIXBUF); g_object_set (renderer, "xalign", 1.0, "yalign", 0.5, "xpad", 6, "stock-size", 2, NULL); /* react to user clicks */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self); g_signal_connect (self->priv->tree, "event-after", G_CALLBACK (on_clicked), self); g_signal_connect (GTK_WIDGET (self), "map", G_CALLBACK (on_map_cb), self); /* connect to the signals */ self->priv->conns.add (book->contact_added.connect (boost::bind (&on_book_contact_added, _1, self))); self->priv->conns.add (book->cleared.connect (boost::bind (&on_book_cleared, self))); /* initial populate */ self->priv->book->visit_contacts (boost::bind (&on_visit_contacts, _1, GTK_LIST_STORE (store))); /* register book actions */ self->priv->menu = Ekiga::GActorMenuPtr (new Ekiga::GActorMenu (*book)); return GTK_WIDGET (self); }