JNIEXPORT jint JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1action
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkFileChooserAction result;
jint _result;
GtkFileChooser* self;
// convert parameter self
self = (GtkFileChooser*) _self;
// call function
result = gtk_file_chooser_get_action(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jint) result;
// and finally
return _result;
}
static void
test_action_widgets (void)
{
GtkWidget *dialog;
GtkFileChooserAction action;
gboolean passed;
dialog = gtk_file_chooser_dialog_new ("Test file chooser",
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_widget_show_now (dialog);
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog));
passed = test_widgets_for_current_action (GTK_FILE_CHOOSER_DIALOG (dialog), action);
log_test (passed, "test_action_widgets(): widgets for initial action %s", get_action_name (action));
g_assert (passed);
passed = foreach_action (GTK_FILE_CHOOSER_DIALOG (dialog), switch_from_action_cb, NULL);
log_test (passed, "test_action_widgets(): all transitions through property change");
g_assert (passed);
gtk_widget_destroy (dialog);
}
static gboolean
test_widgets_for_current_action (GtkFileChooserDialog *dialog,
GtkFileChooserAction expected_action)
{
GtkFileChooserDefault *impl;
gboolean passed;
if (gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog)) != expected_action)
return FALSE;
impl = get_impl_from_dialog (GTK_WIDGET (dialog));
g_assert (impl->action == expected_action);
passed = TRUE;
/* OPEN implies that the "new folder" button is hidden; otherwise it is shown */
if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
passed = passed && !gtk_widget_get_visible (impl->browse_new_folder_button);
else
passed = passed && gtk_widget_get_visible (impl->browse_new_folder_button);
/* Check that the widgets are present/visible or not */
if (has_action (open_actions, G_N_ELEMENTS (open_actions), impl->action))
{
passed = passed && (impl->save_widgets == NULL
&& (impl->location_mode == LOCATION_MODE_PATH_BAR
? impl->location_entry == NULL
: impl->location_entry != NULL)
&& impl->save_folder_label == NULL
&& impl->save_folder_combo == NULL
&& impl->save_expander == NULL
&& GTK_IS_CONTAINER (impl->browse_widgets) && gtk_widget_is_drawable (impl->browse_widgets));
}
else if (has_action (save_actions, G_N_ELEMENTS (save_actions), impl->action))
{
/* FIXME: we can't use GTK_IS_FILE_CHOOSER_ENTRY() because it uses
* _gtk_file_chooser_entry_get_type(), which is a non-exported symbol.
* So, we just test impl->location_entry for being non-NULL
*/
passed = passed && (GTK_IS_CONTAINER (impl->save_widgets) && gtk_widget_is_drawable (impl->save_widgets)
&& impl->location_entry != NULL && gtk_widget_is_drawable (impl->location_entry)
&& GTK_IS_LABEL (impl->save_folder_label) && gtk_widget_is_drawable (impl->save_folder_label)
&& GTK_IS_COMBO_BOX (impl->save_folder_combo) && gtk_widget_is_drawable (impl->save_folder_combo)
&& GTK_IS_EXPANDER (impl->save_expander) && gtk_widget_is_drawable (impl->save_expander)
&& GTK_IS_CONTAINER (impl->browse_widgets));
/* FIXME: we are in a SAVE mode; test the visibility and sensitivity of
* the children that change depending on the state of the expander.
*/
}
else
{
g_error ("BAD TEST: test_widgets_for_current_action() doesn't know about %s", get_action_name (impl->action));
passed = FALSE;
}
return passed;
}
static int is_directory_member(lua_State *L)
{
lua_file_chooser_button file_chooser_button;
luaA_to(L,lua_file_chooser_button,&file_chooser_button,1);
if(lua_gettop(L) > 2) {
const gboolean is_directory = lua_toboolean(L,3);
gtk_file_chooser_set_action(GTK_FILE_CHOOSER(file_chooser_button->widget),is_directory?GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:GTK_FILE_CHOOSER_ACTION_OPEN);
return 0;
}
lua_pushboolean(L,gtk_file_chooser_get_action(GTK_FILE_CHOOSER(file_chooser_button->widget)) == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
return 1;
}
int
clip_GTK_FILECHOOSERGETACTION(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
_clip_retni(ClipMachineMemory, (int) gtk_file_chooser_get_action(GTK_FILE_CHOOSER(cchooser->object)));
return 0;
err:
return 1;
}
static void run_dialog(GtkWidget *dialog, GtkWidget *entry)
{
/* set filename in the file chooser dialog */
const gchar *utf8_filename = gtk_entry_get_text(GTK_ENTRY(entry));
gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename);
if (g_path_is_absolute(locale_filename))
{
if (g_file_test(locale_filename, G_FILE_TEST_EXISTS))
{
/* if the current filename is a directory, we must use
* gtk_file_chooser_set_current_folder(which expects a locale filename) otherwise
* we end up in the parent directory */
if (g_file_test(locale_filename, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_filename);
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), utf8_filename);
}
else /* if the file doesn't yet exist, use at least the current directory */
{
gchar *locale_dir = g_path_get_dirname(locale_filename);
gchar *name = g_path_get_basename(utf8_filename);
if (g_file_test(locale_dir, G_FILE_TEST_EXISTS))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), name);
g_free(name);
g_free(locale_dir);
}
}
else if (gtk_file_chooser_get_action(GTK_FILE_CHOOSER(dialog)) != GTK_FILE_CHOOSER_ACTION_OPEN)
{
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), utf8_filename);
}
g_free(locale_filename);
/* run it */
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
gchar *tmp_utf8_filename = utils_get_utf8_from_locale(filename);
gtk_entry_set_text(GTK_ENTRY(entry), tmp_utf8_filename);
g_free(tmp_utf8_filename);
g_free(filename);
}
gtk_widget_destroy(dialog);
}
static void
show_dialog (GtkFileChooserNative *self)
{
GtkFileChooserAction action;
const char *accept_label, *cancel_label;
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self->dialog));
accept_label = self->accept_label;
if (accept_label == NULL)
accept_label = (action == GTK_FILE_CHOOSER_ACTION_SAVE) ? _("_Save") : _("_Open");
gtk_button_set_label (GTK_BUTTON (self->accept_button), accept_label);
cancel_label = self->cancel_label;
if (cancel_label == NULL)
cancel_label = _("_Cancel");
gtk_button_set_label (GTK_BUTTON (self->cancel_button), cancel_label);
gtk_window_set_title (GTK_WINDOW (self->dialog),
gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)));
gtk_window_set_transient_for (GTK_WINDOW (self->dialog),
gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self)));
gtk_window_set_modal (GTK_WINDOW (self->dialog),
gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)));
g_signal_connect (self->dialog,
"response",
G_CALLBACK (dialog_response_cb),
self);
g_signal_connect (self->dialog,
"update-preview",
G_CALLBACK (dialog_update_preview_cb),
self);
gtk_window_present (GTK_WINDOW (self->dialog));
}
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;
}
Php::Value GtkFileChooserDialog_::get_action()
{
GtkFileChooserAction ret = gtk_file_chooser_get_action (GTK_FILE_CHOOSER(instance));
return ret;
}
gboolean
gtk_file_chooser_native_portal_show (GtkFileChooserNative *self)
{
FilechooserPortalData *data;
GtkWindow *transient_for;
GDBusConnection *connection;
char *parent_window_str;
GDBusMessage *message;
GVariantBuilder opt_builder;
GtkFileChooserAction action;
gboolean multiple;
const char *method_name;
if (!gtk_should_use_portal ())
return FALSE;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
if (connection == NULL)
return FALSE;
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self));
multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self));
if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
method_name = "OpenFile";
else if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
method_name = "SaveFile";
else
{
g_warning ("GTK_FILE_CHOOSER_ACTION_%s is not supported by GtkFileChooserNativePortal", action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ? "SELECT_FOLDER" : "CREATE_FOLDER");
return FALSE;
}
data = g_new0 (FilechooserPortalData, 1);
data->self = g_object_ref (self);
data->connection = connection;
message = g_dbus_message_new_method_call ("org.freedesktop.portal.Desktop",
"/org/freedesktop/portal/desktop",
"org.freedesktop.portal.FileChooser",
method_name);
parent_window_str = NULL;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for != NULL && gtk_widget_is_visible (GTK_WIDGET (transient_for)))
{
GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (transient_for));
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_WINDOW(window))
parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window));
#endif
}
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
if (data->modal && transient_for != NULL)
{
data->grab_widget = gtk_invisible_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (transient_for)));
gtk_grab_add (GTK_WIDGET (data->grab_widget));
}
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&opt_builder, "{sv}", "multiple",
g_variant_new_boolean (multiple));
if (self->accept_label)
g_variant_builder_add (&opt_builder, "{sv}", "accept_label",
g_variant_new_string (self->accept_label));
if (self->cancel_label)
g_variant_builder_add (&opt_builder, "{sv}", "cancel_label",
g_variant_new_string (self->cancel_label));
g_variant_builder_add (&opt_builder, "{sv}", "modal",
g_variant_new_boolean (data->modal));
g_variant_builder_add (&opt_builder, "{sv}", "filters", get_filters (GTK_FILE_CHOOSER (self)));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_name)
g_variant_builder_add (&opt_builder, "{sv}", "current_name",
g_variant_new_string (GTK_FILE_CHOOSER_NATIVE (self)->current_name));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_folder)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_folder);
g_variant_builder_add (&opt_builder, "{sv}", "current_folder",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->current_file)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_file);
g_variant_builder_add (&opt_builder, "{sv}", "current_file",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->choices)
g_variant_builder_add (&opt_builder, "{sv}", "choices",
serialize_choices (GTK_FILE_CHOOSER_NATIVE (self)));
g_dbus_message_set_body (message,
g_variant_new ("(ss@a{sv})",
parent_window_str ? parent_window_str : "",
gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)),
g_variant_builder_end (&opt_builder)));
g_free (parent_window_str);
g_dbus_connection_send_message_with_reply (data->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
G_MAXINT,
NULL,
NULL,
open_file_msg_cb,
data);
g_object_unref (message);
self->mode_data = data;
return TRUE;
}
void
ghb_update_widget(GtkWidget *widget, const GValue *value)
{
GType type;
gchar *str;
gint ival;
gdouble dval;
g_debug("ghb_update_widget");
type = G_VALUE_TYPE(value);
if (type == ghb_array_get_type() || type == ghb_dict_get_type())
return;
if (value == NULL) return;
str = ghb_value_string(value);
ival = ghb_value_int(value);
dval = ghb_value_double(value);
type = G_OBJECT_TYPE(widget);
if (type == GTK_TYPE_ENTRY)
{
g_debug("entry");
gtk_entry_set_text((GtkEntry*)widget, str);
}
else if (type == GTK_TYPE_RADIO_BUTTON)
{
g_debug("radio button");
if (ival)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), !!ival);
}
else if (type == GTK_TYPE_CHECK_BUTTON)
{
g_debug("check button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
{
g_debug("toggle button");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_BUTTON)
{
g_debug("toggle button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_CHECK_MENU_ITEM)
{
g_debug("check menu item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival);
}
else if (type == GTK_TYPE_COMBO_BOX)
{
GtkTreeModel *store;
GtkTreeIter iter;
gchar *shortOpt;
gdouble ivalue;
gboolean foundit = FALSE;
g_debug("combo (%s)", str);
store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
if (strcasecmp(shortOpt, str) == 0)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
g_free(shortOpt);
foundit = TRUE;
break;
}
g_free(shortOpt);
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
if ((gint)ivalue == ival || ivalue == dval)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
foundit = TRUE;
break;
}
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit)
{
if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget)))
{
GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)));
if (entry)
{
gtk_entry_set_text (entry, str);
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
}
else if (type == GTK_TYPE_SPIN_BUTTON)
{
g_debug("spin (%s)", str);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_SCALE)
{
g_debug("hscale");
gtk_range_set_value(GTK_RANGE(widget), dval);
}
else if (type == GTK_TYPE_SCALE_BUTTON)
{
g_debug("scale_button");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_TEXT_VIEW)
{
g_debug("textview (%s)", str);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(widget));
gtk_text_buffer_set_text (buffer, str, -1);
}
else if (type == GTK_TYPE_LABEL)
{
gtk_label_set_markup (GTK_LABEL(widget), str);
}
else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
{
GtkFileChooserAction act;
act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget));
if (str[0] == 0)
{
// Do nothing
;
}
else if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else if (act == GTK_FILE_CHOOSER_ACTION_SAVE)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
if (g_file_test(str, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), str);
}
else if (g_file_test(str, G_FILE_TEST_EXISTS))
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
gchar *dirname;
dirname = g_path_get_dirname(str);
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), dirname);
g_free(dirname);
}
}
}
else
{
g_debug("Attempt to set unknown widget type");
}
g_free(str);
}
static void
gimp_file_dialog_proc_changed (GimpFileProcView *view,
GimpFileDialog *dialog)
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
gchar *name;
dialog->file_proc = gimp_file_proc_view_get_proc (view, &name);
if (name)
{
gchar *label = g_strdup_printf (_("Select File _Type (%s)"), name);
gtk_expander_set_label (GTK_EXPANDER (dialog->proc_expander), label);
g_free (label);
g_free (name);
}
if (gtk_file_chooser_get_action (chooser) == GTK_FILE_CHOOSER_ACTION_SAVE)
{
GimpPlugInProcedure *proc = dialog->file_proc;
if (proc && proc->extensions_list)
{
gchar *uri = gtk_file_chooser_get_uri (chooser);
if (uri && strlen (uri))
{
const gchar *last_dot = strrchr (uri, '.');
/* if the dot is before the last slash, ignore it */
if (last_dot && strrchr (uri, '/') > last_dot)
last_dot = NULL;
/* check if the uri has a "meta extension" (e.g. foo.bar.gz)
* and try to truncate both extensions away.
*/
if (last_dot && last_dot != uri)
{
GList *list;
for (list = view->meta_extensions;
list;
list = g_list_next (list))
{
const gchar *ext = list->data;
if (! strcmp (ext, last_dot + 1))
{
const gchar *p = last_dot - 1;
while (p > uri && *p != '.')
p--;
if (p != uri && *p == '.')
{
last_dot = p;
break;
}
}
}
}
if (last_dot != uri)
{
GString *s = g_string_new (uri);
gchar *basename;
if (last_dot)
g_string_truncate (s, last_dot - uri);
g_string_append (s, ".");
g_string_append (s, (gchar *) proc->extensions_list->data);
gtk_file_chooser_set_uri (chooser, s->str);
basename = file_utils_uri_display_basename (s->str);
gtk_file_chooser_set_current_name (chooser, basename);
g_free (basename);
g_string_free (s, TRUE);
}
}
g_free (uri);
}
}
}
