static void
response_cb (GtkDialog *dialog,
gint response_id)
{
if (response_id == GTK_RESPONSE_OK)
{
GSList *list;
list = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
if (list)
{
GSList *l;
g_print ("Selected files:\n");
for (l = list; l; l = l->next)
{
g_print ("%s\n", (char *) l->data);
g_free (l->data);
}
g_slist_free (list);
}
else
g_print ("No selected files\n");
}
else
g_print ("Dialog was closed\n");
gtk_main_quit ();
}
int
clip_GTK_FILECHOOSERGETURIS(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
GSList *list;
ClipVar *cv = RETPTR(ClipMachineMemory);
long l;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
list = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(cchooser->object));
l = g_slist_length(list);
_clip_array(ClipMachineMemory, cv, 1, &l);
for (l = 0; list; list = g_slist_next(list), l++)
{
ClipVar c;
gchar *str;
memset(&c, 0, sizeof(c));
str = (gchar *) list->data;
_clip_var_str(str, strlen(str), &c);
_clip_aset(ClipMachineMemory, cv, &c, 1, &l);
_clip_destroy(ClipMachineMemory, &c);
}
g_slist_free(list);
return 0;
err:
return 1;
}
static void
handle_file_chooser_open_response (GtkWidget *widget,
int response,
gpointer user_data)
{
FileDialogHandle *handle = user_data;
switch (response)
{
default:
g_warning ("Unexpected response: %d", response);
/* Fall through */
case GTK_RESPONSE_DELETE_EVENT:
handle->response = 2;
handle->uris = NULL;
break;
case GTK_RESPONSE_CANCEL:
handle->response = 1;
handle->uris = NULL;
break;
case GTK_RESPONSE_OK:
handle->response = 0;
handle->uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (widget));
break;
}
send_response (handle);
}
void
gnac_ui_file_chooser_response_cb(GtkDialog *dialog,
gint response,
gpointer user_data)
{
switch (response) {
/* Add button */
case GTK_RESPONSE_NONE: {
GSList *files = NULL;
GSList *paths = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog));
/* Add the different files */
g_slist_foreach(paths, (GFunc) gnac_ui_file_chooser_foreach, &files);
g_slist_free(paths);
gnac_add_files(files);
gchar *current_folder = gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(dialog));
gnac_ui_file_chooser_set_last_used_folder(current_folder);
/* Do we have to close the file chooser? */
if (!gnac_ui_file_chooser_close_on_add_button_is_active()) return;
break;
}
case GTK_RESPONSE_CLOSE:
default:
break;
}
gtk_widget_hide(GTK_WIDGET(dialog));
}
static void
ag_app_import_cb(GSimpleAction *action, GVariant *parameter, gpointer user_data)
{
gint response;
GtkWidget *fs;
GtkFileFilter *filter;
GSList *filenames = NULL;
const gchar *target_type = g_variant_get_string(parameter, NULL);
AgAppImportType type = AG_APP_IMPORT_NONE;
AgApp *app = AG_APP(user_data);
if (strncmp("agc", target_type, 3) == 0) {
type = AG_APP_IMPORT_AGC;
filter = filter_chart;
} else if (strncmp("hor", target_type, 3) == 0) {
type = AG_APP_IMPORT_HOR;
filter = filter_hor;
} else {
g_error("Unknown import type!");
}
fs = gtk_file_chooser_dialog_new(
_("Select charts"),
gtk_application_get_active_window(GTK_APPLICATION(app)),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Import"), GTK_RESPONSE_ACCEPT,
NULL
);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter_all);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fs), filter);
gtk_dialog_set_default_response(GTK_DIALOG(fs), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fs), TRUE);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fs), FALSE);
response = gtk_dialog_run(GTK_DIALOG(fs));
if (response == GTK_RESPONSE_ACCEPT) {
filenames = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(fs));
}
if (filenames != NULL) {
GSList *l;
for (l = filenames; l; l = g_slist_next(l)) {
GFile *file;
char *data = l->data;
if (data == NULL) {
continue;
}
file = g_file_new_for_commandline_arg(data);
ag_app_import_file(AG_APP(user_data), file, type);
}
}
gtk_widget_destroy(fs);
}
void show_file_choice(GtkFileChooserAction flags)
{
GtkWidget *dialog = gtk_file_chooser_dialog_new("File(s)",
GTK_WINDOW(winMain),
/*
* GTK_FILE_CHOOSER_ACTION_OPEN
* GTK_FILE_CHOOSER_ACTION_SAVE
* GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
* GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
*/
flags,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT){
GSList *lst = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog));
GSList *iter;
for(iter = lst; iter; iter = iter->next){
char *dup = g_strdup(iter->data);
queue_add_html(dup);
g_free(dup);
g_free(iter->data);
}
g_slist_free(lst);
}
gtk_widget_destroy(dialog);
}
static void
gimp_file_dialog_selection_changed (GtkFileChooser *chooser,
GimpFileDialog *dialog)
{
gimp_thumb_box_take_uris (GIMP_THUMB_BOX (dialog->thumb_box),
gtk_file_chooser_get_uris (chooser));
}
Php::Value GtkFileChooserDialog_::get_uris()
{
GSList *ret = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER(instance));
Php::Value ret_arr;
for(int index=0; GSList *item=g_slist_nth(ret, index); index++) {
ret_arr[index] = (char *) item->data;
}
return ret_arr;
}
void open_file_ok(GtkFileChooser *file_selection)
{
GSList *filenames;
GSList *walk;
// Extract filename from the file selection dialog
filenames = gtk_file_chooser_get_uris(file_selection);
for(walk = filenames; walk!= NULL; walk = g_slist_next(walk)) {
document_manager_switch_to_file_or_open(main_window.docmg, walk->data, 0);
}
g_slist_free(filenames);
}
static void
print_selected (GtkFileChooser *chooser)
{
GSList *uris = gtk_file_chooser_get_uris (chooser);
GSList *tmp_list;
g_print ("Selection changed :\n");
for (tmp_list = uris; tmp_list; tmp_list = tmp_list->next)
{
gchar *uri = tmp_list->data;
g_print (" %s\n", uri);
g_free (uri);
}
g_print ("\n");
g_slist_free (uris);
}
static void on_toolbutton_add_clicked(void)
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER(
gtk_file_chooser_dialog_new(_("Select Files"), gui.window,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL));
gtk_file_chooser_set_select_multiple(chooser, true);
gtk_file_chooser_set_local_only(chooser, false);
if (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
GSList *uris = gtk_file_chooser_get_uris(chooser);
gui_add_uris(uris, GUI_VIEW_FILE_LIST);
g_slist_free_full(uris, g_free);
}
gtk_widget_destroy(GTK_WIDGET(chooser));
}
static void
gtr_po_parse_files_from_dialog (GtkWidget * dialog, GtrWindow * window)
{
GSList *po_files, *l;
GSList *locations = NULL;
GFile *file, *parent;
gchar *uri;
po_files = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
for (l = po_files; l != NULL; l = g_slist_next (l))
{
GFile *file;
file = g_file_new_for_uri (l->data);
locations = g_slist_prepend (locations, file);
}
/*
* We store latest directory
*/
file = g_file_new_for_uri (po_files->data);
g_slist_free_full (po_files, g_free);
parent = g_file_get_parent (file);
g_object_unref (file);
uri = g_file_get_uri (parent);
g_object_unref (parent);
_gtr_application_set_last_dir (GTR_APP, uri);
g_free (uri);
/*
* Open the file via our centralized opening function.
*/
load_file_list (window, (const GSList *) locations);
g_slist_free_full (locations, g_object_unref);
/*
* Destroy the dialog
*/
gtk_widget_destroy (dialog);
}
static void
action_button_cb(GtkWidget *widget, gpointer data)
{
GtkWidget *window = g_object_get_data(data, "window");
GtkWidget *chooser = g_object_get_data(data, "chooser");
GtkWidget *toggle = g_object_get_data(data, "toggle-button");
GSList * files = gtk_file_chooser_get_uris ((GtkFileChooser *) chooser);
filebrowser_add_files ((GtkFileChooser *) chooser, files, GPOINTER_TO_INT
(g_object_get_data (data, "play-button")));
g_slist_foreach(files, (GFunc) g_free, NULL);
g_slist_free(files);
gboolean close_dialog = gtk_toggle_button_get_active ((GtkToggleButton *) toggle);
aud_set_bool ("audgui", "close_dialog_open", close_dialog);
if (close_dialog)
gtk_widget_destroy (window);
}
static void
on_open_filesel_response (GtkDialog* dialog, gint id, AnjutaDocman *docman)
{
gchar *uri;
// unused gchar *entry_filename = NULL;
int i;
GSList * list;
int elements;
if (id != GTK_RESPONSE_ACCEPT)
{
gtk_widget_hide (docman->priv->fileselection);
return;
}
list = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog));
if (list != NULL)
{
elements = g_slist_length(list);
for (i = 0; i < elements; i++)
{
uri = g_slist_nth_data (list, i);
if (uri)
{
GFile* file = g_file_new_for_uri (uri);
anjuta_docman_goto_file_line (docman, file, -1);
g_object_unref (file);
g_free (uri);
}
}
g_slist_free (list);
/* if (entry_filename)
{
list = g_slist_remove(list, entry_filename);
g_free(entry_filename);
}
*/
}
}
static GSList *
do_filechooser (void)
{
GSList *ret = NULL;
GtkWidget *dialog;
GtkWidget *ro_checkbutton;
ret = NULL;
dialog = gtk_file_chooser_dialog_new (_("Select Disk Image(s) to Mount"),
NULL, /* parent window */
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Mount"), GTK_RESPONSE_ACCEPT,
NULL);
gdu_utils_configure_file_chooser_for_disk_images (GTK_FILE_CHOOSER (dialog),
TRUE, /* set_file_types */
FALSE); /* allow_compressed */
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
/* Add a RO check button that defaults to RO */
ro_checkbutton = gtk_check_button_new_with_mnemonic (_("Set up _read-only mount"));
gtk_widget_set_tooltip_markup (ro_checkbutton, _("If checked, the mount will be read-only. This is useful if you don’t want the underlying disk image to be modified"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ro_checkbutton), !opt_writable);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), ro_checkbutton);
//gtk_widget_show_all (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT)
goto out;
ret = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
opt_writable = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ro_checkbutton));
out:
gtk_widget_destroy (dialog);
return ret;
}
static void
file_chooser_response (GtkDialog *chooser,
gint response,
CcBackgroundPanel *panel)
{
GSList *selected, *l;
if (response != GTK_RESPONSE_ACCEPT)
{
gtk_widget_destroy (GTK_WIDGET (chooser));
return;
}
selected = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser));
gtk_widget_destroy (GTK_WIDGET (chooser));
for (l = selected; l != NULL; l = l->next)
{
char *uri = l->data;
add_custom_wallpaper (panel, uri);
g_free (uri);
}
g_slist_free (selected);
}
static int
file_sel_response_cb (GtkWidget *widget,
int response,
DialogData *data)
{
GtkFileChooser *file_sel = GTK_FILE_CHOOSER (widget);
FrWindow *window = data->window;
char *current_folder;
char *uri;
gboolean update;
GSList *selections, *iter;
GList *item_list = NULL;
current_folder = gtk_file_chooser_get_current_folder_uri (file_sel);
uri = gtk_file_chooser_get_uri (file_sel);
if (current_folder != NULL) {
g_settings_set_string (data->settings, PREF_ADD_CURRENT_FOLDER, current_folder);
fr_window_set_add_default_dir (window, current_folder);
}
if (uri != NULL) {
g_settings_set_string (data->settings, PREF_ADD_FILENAME, uri);
g_free (uri);
}
if ((response == GTK_RESPONSE_CANCEL) || (response == GTK_RESPONSE_DELETE_EVENT)) {
gtk_widget_destroy (data->dialog);
g_free (current_folder);
return TRUE;
}
if (response == GTK_RESPONSE_HELP) {
show_help_dialog (GTK_WINDOW (data->dialog), "archive-edit");
g_free (current_folder);
return TRUE;
}
/* check folder permissions. */
if (uri_is_dir (current_folder) && ! check_permissions (current_folder, R_OK)) {
GtkWidget *d;
char *utf8_path;
utf8_path = g_filename_display_name (current_folder);
d = _gtk_error_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL,
NULL,
_("Could not add the files to the archive"),
_("You don't have the right permissions to read files from folder \"%s\""),
utf8_path);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
g_free (utf8_path);
g_free (current_folder);
return FALSE;
}
update = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->add_if_newer_checkbutton));
/**/
selections = gtk_file_chooser_get_uris (file_sel);
for (iter = selections; iter != NULL; iter = iter->next) {
char *uri = iter->data;
item_list = g_list_prepend (item_list, g_file_new_for_uri (uri));
}
if (item_list != NULL)
fr_window_archive_add_files (window, item_list, update);
gio_file_list_free (item_list);
g_slist_foreach (selections, (GFunc) g_free, NULL);
g_slist_free (selections);
g_free (current_folder);
gtk_widget_destroy (data->dialog);
return TRUE;
}
bool ChooseFiles(
bool inLocalOnly,
std::vector<MFile>& outFiles)
{
GtkWidget* dialog = nil;
try
{
dialog =
gtk_file_chooser_dialog_new(_("Open"), nil,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
THROW_IF_NIL(dialog);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), true);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), inLocalOnly);
if (gApp->GetCurrentFolder().length() > 0)
{
gtk_file_chooser_set_current_folder_uri(
GTK_FILE_CHOOSER(dialog), gApp->GetCurrentFolder().c_str());
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
GSList* uris = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog));
GSList* file = uris;
while (file != nil)
{
MFile url(reinterpret_cast<char*>(file->data), true);
g_free(file->data);
file->data = nil;
outFiles.push_back(url);
file = file->next;
}
g_slist_free(uris);
}
char* cwd = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
if (cwd != nil)
{
gApp->SetCurrentFolder(cwd);
g_free(cwd);
}
}
catch (exception& e)
{
if (dialog)
gtk_widget_destroy(dialog);
throw;
}
gtk_widget_destroy(dialog);
return outFiles.size() > 0;
}
GSList *
totem_add_files (GtkWindow *parent, const char *path)
{
GtkWidget *fs;
int response;
GSList *filenames;
char *mrl, *new_path;
GSettings *settings;
gboolean set_folder;
fs = gtk_file_chooser_dialog_new (_("Select Movies or Playlists"),
parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Add Directory"), OPEN_DIRECTORY_RESPONSE,
GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_all);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_supported);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_audio);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_video);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (fs), filter_supported);
gtk_dialog_set_default_response (GTK_DIALOG (fs), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (fs), TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fs), FALSE);
settings = g_settings_new (TOTEM_GSETTINGS_SCHEMA);
set_folder = TRUE;
if (path != NULL) {
set_folder = gtk_file_chooser_set_current_folder_uri
(GTK_FILE_CHOOSER (fs), path);
} else {
new_path = g_settings_get_string (settings, "open-uri");
if (*new_path != '\0') {
set_folder = gtk_file_chooser_set_current_folder_uri
(GTK_FILE_CHOOSER (fs), new_path);
}
g_free (new_path);
}
/* We didn't manage to change the directory */
if (set_folder == FALSE) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fs),
g_get_home_dir ());
}
totem_add_default_dirs (GTK_FILE_CHOOSER (fs));
response = gtk_dialog_run (GTK_DIALOG (fs));
filenames = NULL;
if (response == OPEN_DIRECTORY_RESPONSE ||
response == GTK_RESPONSE_ACCEPT) {
filenames = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (fs));
}
if (filenames == NULL) {
gtk_widget_destroy (fs);
g_object_unref (settings);
return NULL;
}
gtk_widget_destroy (fs);
mrl = filenames->data;
if (mrl != NULL) {
new_path = g_path_get_dirname (mrl);
g_settings_set_string (settings, "open-uri", new_path);
g_free (new_path);
}
g_object_unref (settings);
return filenames;
}
static void
file_open_dialog_response (GtkWidget *open_dialog,
gint response_id,
Gimp *gimp)
{
GimpFileDialog *dialog = GIMP_FILE_DIALOG (open_dialog);
GSList *uris;
GSList *list;
gboolean success = FALSE;
g_object_set_data_full (G_OBJECT (gimp), "gimp-file-open-dialog-state",
gimp_file_dialog_get_state (dialog),
(GDestroyNotify) gimp_file_dialog_state_destroy);
if (response_id != GTK_RESPONSE_OK)
{
if (! dialog->busy)
gtk_widget_destroy (open_dialog);
return;
}
uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (open_dialog));
if (uris)
g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY,
g_strdup (uris->data), (GDestroyNotify) g_free);
gimp_file_dialog_set_sensitive (dialog, FALSE);
/* When we are going to open new image windows, unset the transient
* window. We don't need it since we will use gdk_window_raise() to
* keep the dialog on top. And if we don't do it, then the dialog
* will pull the image window it was invoked from on top of all the
* new opened image windows, and we don't want that to happen.
*/
if (! dialog->open_as_layers)
gtk_window_set_transient_for (GTK_WINDOW (open_dialog), NULL);
for (list = uris; list; list = g_slist_next (list))
{
gchar *filename = file_utils_filename_from_uri (list->data);
if (filename)
{
gboolean regular = g_file_test (filename, G_FILE_TEST_IS_REGULAR);
g_free (filename);
if (! regular)
continue;
}
if (dialog->open_as_layers)
{
if (! dialog->image)
{
dialog->image = file_open_dialog_open_image (open_dialog,
gimp,
list->data,
dialog->file_proc);
if (dialog->image)
success = TRUE;
}
else if (file_open_dialog_open_layers (open_dialog,
dialog->image,
list->data,
dialog->file_proc))
{
success = TRUE;
}
}
else
{
if (file_open_dialog_open_image (open_dialog,
gimp,
list->data,
dialog->file_proc))
{
success = TRUE;
/* Make the dialog stay on top of all images we open if
* we open say 10 at once
*/
gdk_window_raise (gtk_widget_get_window (open_dialog));
}
}
if (dialog->canceled)
break;
}
if (success)
{
if (dialog->open_as_layers && dialog->image)
gimp_image_flush (dialog->image);
gtk_widget_destroy (open_dialog);
}
else
{
gimp_file_dialog_set_sensitive (dialog, TRUE);
}
g_slist_free_full (uris, (GDestroyNotify) g_free);
}
void
vinagre_cmd_remote_open (GtkAction *action,
VinagreWindow *window)
{
GtkWidget *tab;
VinagreConnection *conn;
GtkWidget *dialog;
GtkFileFilter *filter;
GSList *files, *l;
gchar *uri;
gchar *error = NULL;
GSList *errors = NULL;
gint i = 0;
GHashTable *protocols;
GHashTableIter iter;
VinagreProtocol *protocol;
g_return_if_fail (VINAGRE_IS_WINDOW (window));
dialog = gtk_file_chooser_dialog_new (_("Choose the file"),
GTK_WINDOW (window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
protocols = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ());
g_hash_table_iter_init (&iter, protocols);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&protocol))
{
filter = vinagre_protocol_get_file_filter (protocol);
if (filter)
{
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
i++;
}
}
if (i == 0)
{
vinagre_utils_show_error_dialog (_("There are no supported files"),
_("None of the active plugins support this action. Activate some plugins and try again."),
GTK_WINDOW (window));
goto finalize;
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
files = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
for (l = files; l; l = l->next)
{
uri = (gchar *)l->data;
conn = vinagre_connection_new_from_file (uri, &error, FALSE);
if (conn)
{
tab = vinagre_tab_new (conn, window);
vinagre_notebook_add_tab (VINAGRE_NOTEBOOK (window->priv->notebook),
VINAGRE_TAB (tab),
-1);
g_object_unref (conn);
}
else
{
errors = g_slist_append (errors, g_strdup_printf ("<i>%s</i>: %s", uri, error?error:_("Unknown error")));
g_free (error);
}
g_free (uri);
}
g_slist_free (files);
}
if (errors)
{
vinagre_utils_show_many_errors (ngettext ("The following file could not be opened:",
"The following files could not be opened:",
g_slist_length (errors)),
errors,
GTK_WINDOW (window));
g_slist_free_full (errors, g_free);
}
finalize:
gtk_widget_destroy (dialog);
}