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