JNIEXPORT jlong JNICALL Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1extra_1widget ( JNIEnv* env, jclass cls, jlong _self ) { GtkWidget* result; jlong _result; GtkFileChooser* self; // convert parameter self self = (GtkFileChooser*) _self; // call function result = gtk_file_chooser_get_extra_widget(self); // cleanup parameter self // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, FALSE); } // and finally return _result; }
static void onOpenDialogResponse( GtkDialog * dialog, int response, gpointer core ) { char * folder; /* remember this folder the next time we use this dialog */ folder = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER( dialog ) ); gtr_pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder ); g_free( folder ); if( response == GTK_RESPONSE_ACCEPT ) { GtkFileChooser * chooser = GTK_FILE_CHOOSER( dialog ); GtkWidget * w = gtk_file_chooser_get_extra_widget( chooser ); GtkToggleButton * tb = GTK_TOGGLE_BUTTON( w ); const gboolean do_start = gtr_pref_flag_get( TR_PREFS_KEY_START ); const gboolean do_prompt = gtk_toggle_button_get_active( tb ); const gboolean do_notify = FALSE; GSList * files = gtk_file_chooser_get_files( chooser ); gtr_core_add_files( core, files, do_start, do_prompt, do_notify ); g_slist_foreach( files, (GFunc)g_object_unref, NULL ); g_slist_free( files ); } gtk_widget_destroy( GTK_WIDGET( dialog ) ); }
Php::Value GtkFileChooserDialog_::get_extra_widget() { GtkWidget *ret = gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER(instance)); GtkWidget_ *return_parsed = new GtkWidget_(); return_parsed->set_instance((gpointer *)ret); return Php::Object("GtkWidget", return_parsed); }
int clip_GTK_FILECHOOSERGETEXTRAWIDGET(ClipMachine * ClipMachineMemory) { C_object *cchooser = _fetch_co_arg(ClipMachineMemory); GtkWidget *wid; C_widget *cwid; CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object)); wid = gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(cchooser->object)); if (wid) { cwid = _list_get_cwidget(ClipMachineMemory, wid); if (!cwid) cwid = _register_widget(ClipMachineMemory, wid, NULL); if (cwid) _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); } return 0; err: return 1; }
void ags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine) { GtkFileChooserDialog *file_chooser; AgsFileSelection *file_selection; GtkCheckButton *overwrite; GtkCheckButton *create; GSList *filenames; gchar *current_folder; GError *error; file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget); if(response == GTK_RESPONSE_ACCEPT){ filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser)); overwrite = g_object_get_data((GObject *) widget, "overwrite"); create = g_object_get_data((GObject *) widget, "create"); current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser)); //TODO:JK: you need to check against recently used //TODO:JK: add more file types to AgsFileSelection /* check for supported packed audio files */ file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser)); if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){ gtk_widget_destroy(GTK_WIDGET(file_selection)); file_selection = NULL; } if(file_selection == NULL || (AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){ if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){ GDir *current_directory; GList *new_entry, *old_entry; GSList *slist; gchar *current_filename; slist = filenames; new_entry = NULL; while(slist != NULL){ if(g_str_has_suffix(slist->data, ".sf2")){ AgsFileSelectionEntry *entry; entry = ags_file_selection_entry_alloc(); entry->filename = slist->data; new_entry = g_list_prepend(new_entry, entry); } slist = slist->next; } old_entry = NULL; if(file_selection == NULL){ if(new_entry != NULL){ file_selection = ags_file_selection_new(); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser), GTK_WIDGET(file_selection)); ags_file_selection_set_entry(file_selection, new_entry); ags_connectable_connect(AGS_CONNECTABLE(file_selection)); gtk_widget_show_all(GTK_WIDGET(file_selection)); return; } }else if(AGS_IS_FILE_SELECTION(file_selection)){ GList *really_new_entry; GList *list; old_entry = file_selection->entry; list = new_entry; really_new_entry = NULL; /* check against existing entries */ if(new_entry != NULL){ while(list != NULL){ if(g_list_find(old_entry, list->data) == NULL){ really_new_entry = g_list_prepend(really_new_entry, list->data); }else{ free(list->data); } list = list->next; } g_list_free(new_entry); } ags_file_selection_set_entry(file_selection, really_new_entry); /* adding lost files */ //TODO:JK: figure out if you need to copy the GSList of filenames gtk_file_chooser_select_all(GTK_FILE_CHOOSER(file_chooser)); current_directory = g_dir_open(current_folder, 0, &error); while((current_filename = (gchar *) g_dir_read_name(current_directory)) != NULL){ if(!g_strcmp0(".", current_filename) || !g_strcmp0("..", current_filename)) continue; if(!ags_file_selection_contains_file(file_selection, current_filename) && g_slist_find(filenames, current_filename) == NULL){ gtk_file_chooser_unselect_filename(GTK_FILE_CHOOSER(file_chooser), current_filename); } } g_dir_close(current_directory); return; } } } //TODO:JK: fix GSList filenames memory leak ags_machine_open_files(machine, filenames, overwrite->toggle_button.active, create->toggle_button.active); } }
gboolean gtk_file_chooser_native_win32_show (GtkFileChooserNative *self) { GThread *thread; FilechooserWin32ThreadData *data; GtkWindow *transient_for; GtkFileChooserAction action; guint update_preview_signal; GSList *filters, *l; int n_filters, i; if (gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (self)) != NULL) return FALSE; update_preview_signal = g_signal_lookup ("update-preview", GTK_TYPE_FILE_CHOOSER); if (g_signal_has_handler_pending (self, update_preview_signal, 0, TRUE)) return FALSE; data = g_new0 (FilechooserWin32ThreadData, 1); filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (self)); n_filters = g_slist_length (filters); if (n_filters > 0) { data->filters = g_new0 (COMDLG_FILTERSPEC, n_filters + 1); for (l = filters, i = 0; l != NULL; l = l->next, i++) { if (!file_filter_to_win32 (l->data, &data->filters[i])) { filechooser_win32_thread_data_free (data); return FALSE; } } self->current_filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (self)); } else { self->current_filter = NULL; } self->mode_data = data; data->self = g_object_ref (self); data->shortcut_uris = gtk_file_chooser_list_shortcut_folder_uris (GTK_FILE_CHOOSER (self->dialog)); data->accept_label = translate_mnemonics (self->accept_label); data->cancel_label = translate_mnemonics (self->cancel_label); action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self->dialog)); if (action == GTK_FILE_CHOOSER_ACTION_SAVE || action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) data->save = TRUE; if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER || action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) data->folder = TRUE; if ((action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER || action == GTK_FILE_CHOOSER_ACTION_OPEN) && gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self->dialog))) data->select_multiple = TRUE; if (gtk_file_chooser_get_do_overwrite_confirmation (GTK_FILE_CHOOSER (self->dialog))) data->overwrite_confirmation = TRUE; if (gtk_file_chooser_get_show_hidden (GTK_FILE_CHOOSER (self->dialog))) data->show_hidden = TRUE; transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self)); if (transient_for) { gtk_widget_realize (GTK_WIDGET (transient_for)); data->parent = gdk_win32_surface_get_handle (gtk_widget_get_surface (GTK_WIDGET (transient_for))); if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self))) data->modal = TRUE; } data->title = g_strdup (gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self))); if (self->current_file) data->current_file = g_object_ref (self->current_file); else { if (self->current_folder) data->current_folder = g_object_ref (self->current_folder); if (action == GTK_FILE_CHOOSER_ACTION_SAVE || action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) data->current_name = g_strdup (self->current_name); } data->events = file_dialog_events_new (!data->modal, data); thread = g_thread_new ("win32 filechooser", filechooser_win32_thread, data); if (thread == NULL) { filechooser_win32_thread_data_free (data); return FALSE; } return TRUE; }
/** * React to <Display>/File/Export */ void file_export_callback(GtkAction *action) { DDisplay *ddisp; Diagram *dia; gchar *filename = NULL; ddisp = ddisplay_active(); if (!ddisp) return; dia = ddisp->diagram; if (!confirm_export_size (dia, GTK_WINDOW(ddisp->shell), CONFIRM_MEMORY|CONFIRM_PAGES)) return; if (!exportdlg) { persistence_register_integer ("export-filter", 0); exportdlg = gtk_file_chooser_dialog_new(_("Export Diagram"), GTK_WINDOW(ddisp->shell), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* export via vfs gives: Permission denied - but only if you do not * have write permissions ;) */ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(exportdlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(exportdlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(exportdlg), "export_diagram"); g_signal_connect(G_OBJECT(exportdlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &exportdlg); } if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(exportdlg))) { GtkWidget *hbox, *label, *omenu, *options; GtkFileFilter* filter; options = gtk_frame_new(_("Export Options")); gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN); hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_container_add(GTK_CONTAINER(options), hbox); gtk_widget_show(hbox); label = gtk_label_new (_("Determine file type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); omenu = create_export_menu(); gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0); gtk_widget_show(omenu); g_object_set_data(G_OBJECT(exportdlg), "export-menu", omenu); gtk_widget_show(options); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(exportdlg), options); /* set up file filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter); /* match the other selections extension */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Supported Formats")); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, matching_extensions_filter, filter_guess_export_filter, NULL); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter); gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("export-filter")); g_signal_connect(GTK_FILE_CHOOSER(exportdlg), "response", G_CALLBACK(file_export_response_callback), omenu); } if (g_object_get_data (G_OBJECT(exportdlg), "user_data")) g_object_unref (g_object_get_data (G_OBJECT(exportdlg), "user_data")); g_object_ref(dia); g_object_set_data (G_OBJECT (exportdlg), "user_data", dia); gtk_widget_set_sensitive(exportdlg, TRUE); if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) { char *folder = g_path_get_dirname (fnabs); char *basename = g_path_get_basename (fnabs); /* can't use gtk_file_chooser_set_filename for various reasons, see e.g. bug #305850 */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(exportdlg), folder); export_adapt_extension (basename, persistence_get_integer ("export-filter") - 1); g_free (folder); g_free (basename); } g_free(fnabs); g_free(filename); } gtk_widget_show(exportdlg); }
static GtkWidget * file_save_as_dialog_prepare (Diagram *dia, DDisplay *ddisp) { gchar *filename = NULL; if (!savedlg) { GtkWidget *compressbutton; savedlg = gtk_file_chooser_dialog_new(_("Save Diagram"), GTK_WINDOW(ddisp->shell), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* vfs saving is as easy - if you see 'bad file descriptor' there is * something wrong with the permissions of the share ;) */ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(savedlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(savedlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(savedlg), "save_diagram"); /* Need better way to make it a reasonable size. Isn't there some*/ /* standard look for them (or is that just Gnome?)*/ compressbutton = gtk_check_button_new_with_label(_("Compress diagram files")); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(savedlg), compressbutton); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton), dia->data->is_compressed); g_signal_connect(G_OBJECT(compressbutton), "toggled", G_CALLBACK(toggle_compress_callback), NULL); gtk_widget_show(compressbutton); gtk_widget_set_tooltip_text (compressbutton, _("Compression reduces file size to less than 1/10th " "size and speeds up loading and saving. Some text " "programs cannot manipulate compressed files.")); g_signal_connect (GTK_FILE_CHOOSER(savedlg), "response", G_CALLBACK(file_save_as_response_callback), compressbutton); g_signal_connect(G_OBJECT(savedlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &savedlg); } else { GtkWidget *compressbutton = gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(savedlg)); gtk_widget_set_sensitive(savedlg, TRUE); g_signal_handlers_block_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton), dia->data->is_compressed); g_signal_handlers_unblock_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL); if (g_object_get_data (G_OBJECT (savedlg), "user_data") != NULL) g_object_unref (g_object_get_data (G_OBJECT (savedlg), "user_data")); #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_get_visible(savedlg)) { #else if (GTK_WIDGET_VISIBLE(savedlg)) { #endif /* keep a refernce to the diagram */ g_object_ref(dia); g_object_set_data (G_OBJECT (savedlg), "user_data", dia); gtk_window_present (GTK_WINDOW(savedlg)); return savedlg; } } if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) { gchar *base = g_path_get_basename(dia->filename); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(savedlg), fnabs); /* FileChooser api insist on exiting files for set_filename */ /* ... and does not use filename encoding on this one. */ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(savedlg), base); g_free(base); } g_free(fnabs); g_free(filename); } g_object_ref(dia); g_object_set_data (G_OBJECT (savedlg), "user_data", dia); return savedlg; } /** * Respond to the File/Save menu entry. * * Delegates to Save As if there is no filename set yet. */ void file_save_callback(GtkAction *action) { Diagram *diagram; diagram = ddisplay_active_diagram(); if (!diagram) return; if (diagram->unsaved) { file_save_as_callback(action); } else { gchar *filename = g_filename_from_utf8(diagram->filename, -1, NULL, NULL, NULL); DiaContext *ctx = dia_context_new (_("Save")); diagram_update_extents(diagram); if (diagram_save(diagram, filename, ctx)) recent_file_history_add(filename); g_free (filename); dia_context_release (ctx); } }
/** * Handle menu click File/Open * * This is either with or without diagram */ void file_open_callback(GtkAction *action) { if (!opendlg) { DDisplay *ddisp; Diagram *dia = NULL; GtkWindow *parent_window; gchar *filename = NULL; /* FIXME: we should not use ddisp_active but instead get the current diagram * from caller. Thus we could offer the option to "load into" if invoked by * <Display/File/Open. It wouldn't make any sense if invoked by * <Toolbox>/File/Open ... */ ddisp = ddisplay_active(); if (ddisp) { dia = ddisp->diagram; parent_window = GTK_WINDOW(ddisp->shell); } else { parent_window = GTK_WINDOW(interface_get_toolbox_shell()); } persistence_register_integer ("import-filter", 0); opendlg = gtk_file_chooser_dialog_new(_("Open Diagram"), parent_window, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); /* is activating gvfs really that easy - at least it works for samba shares*/ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(opendlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(opendlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(opendlg), "open_diagram"); if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(opendlg), fnabs); g_free(fnabs); g_free(filename); } g_signal_connect(G_OBJECT(opendlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &opendlg); } else { gtk_widget_set_sensitive(opendlg, TRUE); #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_get_visible(opendlg)) #else if (GTK_WIDGET_VISIBLE(opendlg)) #endif return; } if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(opendlg))) { GtkWidget *hbox, *label, *omenu, *options; GtkFileFilter* filter; options = gtk_frame_new(_("Open Options")); gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN); hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_container_add(GTK_CONTAINER(options), hbox); gtk_widget_show(hbox); label = gtk_label_new (_("Determine file type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); omenu = create_open_menu(); gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0); gtk_widget_show(omenu); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(opendlg), options); gtk_widget_show(options); g_signal_connect(G_OBJECT(opendlg), "response", G_CALLBACK(file_open_response_callback), omenu); /* set up the gtk file (name) filters */ /* 0 = by extension */ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), build_gtk_file_filter_from_index (0)); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter); gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("import-filter")); } gtk_widget_show(opendlg); }
static void on_file_save_filter_changed(GObject* obj, GParamSpec* pspec, gpointer user_data) { GtkFileChooser* dlg = (GtkFileChooser*)obj; GtkFileFilter* filter = gtk_file_chooser_get_filter( dlg ); const char* type = (const char*)g_object_get_data(G_OBJECT(filter), "type"); GtkWidget* extra = gtk_file_chooser_get_extra_widget(dlg); if(extra) { gtk_file_chooser_set_extra_widget(dlg, NULL); extra = NULL; } if( type ) { GtkWidget* label, *label2; GtkWidget* scale; if( strcmp( type, "jpeg" ) == 0 ) { extra = gtk_hbox_new(FALSE, 12); label = gtk_label_new(_("JPEG Quality:")); label2 = gtk_label_new(_("Lower quality values yield smaller file sizes,\nbut the image quality will be poorer.")); scale = gtk_hscale_new_with_range( 0, 100, 5 ); gtk_range_set_value(GTK_RANGE(scale), pref.jpg_quality); #if GTK_CHECK_VERSION(2, 24, 0) #else gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); #endif g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.jpg_quality); gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE); gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0); } else if( strcmp( type, "png" ) == 0 ) { extra = gtk_hbox_new(FALSE, 12); label = gtk_label_new(_("PNG Compression Level:")); label2 = gtk_label_new(_("Higher compression levels yield smaller file sizes,\nbut takes more time to do the compression.")); scale = gtk_hscale_new_with_range( 0, 9, 1 ); gtk_range_set_value(GTK_RANGE(scale), pref.png_compression); #if GTK_CHECK_VERSION(2, 24, 0) #else gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); #endif g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.png_compression); gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE); gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0); } /* FIXME: provide "depth settings for *.ico files" */ if( extra ) { gtk_widget_show_all(extra); gtk_file_chooser_set_extra_widget(dlg, extra); } } }