X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkfilechooser.c;h=141e8bf76e817d686dfce382828262921ceb1f06;hb=bda5987335b8c7828ebf1d289a91accfe2e74dbe;hp=005d56032e8b1058bd2c2a55a30ea2bb738d2423;hpb=e6589d4e7d2b80398a5baf37ff267640993c9114;p=~andy%2Fgtk diff --git a/gtk/gtkfilechooser.c b/gtk/gtkfilechooser.c index 005d56032..141e8bf76 100644 --- a/gtk/gtkfilechooser.c +++ b/gtk/gtkfilechooser.c @@ -13,49 +13,524 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ -#include +#include "config.h" #include "gtkfilechooser.h" #include "gtkfilechooserprivate.h" -#include "gtkfilesystem.h" #include "gtkintl.h" #include "gtktypebuiltins.h" #include "gtkprivate.h" #include "gtkmarshalers.h" -#include "gtkalias.h" -static void gtk_file_chooser_class_init (gpointer g_iface); -static GtkFilePath *gtk_file_chooser_get_path (GtkFileChooser *chooser); - -GType -gtk_file_chooser_get_type (void) -{ - static GType file_chooser_type = 0; +/** + * SECTION:gtkfilechooser + * @Short_description: File chooser interface used by GtkFileChooserWidget and GtkFileChooserDialog + * @Title: GtkFileChooser + * @See_also: #GtkFileChooserDialog, #GtkFileChooserWidget, #GtkFileChooserButton + * + * #GtkFileChooser is an interface that can be implemented by file + * selection widgets. In GTK+, the main objects that implement this + * interface are #GtkFileChooserWidget, #GtkFileChooserDialog, and + * #GtkFileChooserButton. You do not need to write an object that + * implements the #GtkFileChooser interface unless you are trying to + * adapt an existing file selector to expose a standard programming + * interface. + * + * #GtkFileChooser allows for shortcuts to various places in the filesystem. + * In the default implementation these are displayed in the left pane. It + * may be a bit confusing at first that these shortcuts come from various + * sources and in various flavours, so lets explain the terminology here: + * + * + * Bookmarks + * + * are created by the user, by dragging folders from the + * right pane to the left pane, or by using the "Add". Bookmarks + * can be renamed and deleted by the user. + * + * + * + * Shortcuts + * + * can be provided by the application or by the underlying filesystem + * abstraction (e.g. both the gnome-vfs and the Windows filesystems + * provide "Desktop" shortcuts). Shortcuts cannot be modified by the + * user. + * + * + * + * Volumes + * + * are provided by the underlying filesystem abstraction. They are + * the "roots" of the filesystem. + * + * + * + * + * + * File Names and Encodings + * When the user is finished selecting files in a + * #GtkFileChooser, your program can get the selected names + * either as filenames or as URIs. For URIs, the normal escaping + * rules are applied if the URI contains non-ASCII characters. + * However, filenames are always returned in + * the character set specified by the + * G_FILENAME_ENCODING environment variable. + * Please see the GLib documentation for more details about this + * variable. + * + * This means that while you can pass the result of + * gtk_file_chooser_get_filename() to + * open(2) or + * fopen(3), you may not be able to + * directly set it as the text of a #GtkLabel widget unless you + * convert it first to UTF-8, which all GTK+ widgets expect. + * You should use g_filename_to_utf8() to convert filenames + * into strings that can be passed to GTK+ widgets. + * + * + * + * Adding a Preview Widget + * + * You can add a custom preview widget to a file chooser and then + * get notification about when the preview needs to be updated. + * To install a preview widget, use + * gtk_file_chooser_set_preview_widget(). Then, connect to the + * #GtkFileChooser::update-preview signal to get notified when + * you need to update the contents of the preview. + * + * + * Your callback should use + * gtk_file_chooser_get_preview_filename() to see what needs + * previewing. Once you have generated the preview for the + * corresponding file, you must call + * gtk_file_chooser_set_preview_widget_active() with a boolean + * flag that indicates whether your callback could successfully + * generate a preview. + * + * + * Sample Usage + * + * { + * GtkImage *preview; + * + * ... + * + * preview = gtk_image_new (); + * + * gtk_file_chooser_set_preview_widget (my_file_chooser, preview); + * g_signal_connect (my_file_chooser, "update-preview", + * G_CALLBACK (update_preview_cb), preview); + * } + * + * static void + * update_preview_cb (GtkFileChooser *file_chooser, gpointer data) + * { + * GtkWidget *preview; + * char *filename; + * GdkPixbuf *pixbuf; + * gboolean have_preview; + * + * preview = GTK_WIDGET (data); + * filename = gtk_file_chooser_get_preview_filename (file_chooser); + * + * pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL); + * have_preview = (pixbuf != NULL); + * g_free (filename); + * + * gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); + * if (pixbuf) + * g_object_unref (pixbuf); + * + * gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview); + * } + * + * + * + * + * Adding Extra Widgets + * + * You can add extra widgets to a file chooser to provide options + * that are not present in the default design. For example, you + * can add a toggle button to give the user the option to open a + * file in read-only mode. You can use + * gtk_file_chooser_set_extra_widget() to insert additional + * widgets in a file chooser. + * + * + * Sample Usage + * + * + * GtkWidget *toggle; + * + * ... + * + * toggle = gtk_check_button_new_with_label ("Open file read-only"); + * gtk_widget_show (toggle); + * gtk_file_chooser_set_extra_widget (my_file_chooser, toggle); + * } + * + * + * + * If you want to set more than one extra widget in the file + * chooser, you can a container such as a #GtkBox or a #GtkGrid + * and include your widgets in it. Then, set the container as + * the whole extra widget. + * + * + * + * Key Bindings + * + * Internally, GTK+ implements a file chooser's graphical user + * interface with the private + * GtkFileChooserDefaultClass. This + * widget has several key + * bindings and their associated signals. This section + * describes the available key binding signals. + * + * + * GtkFileChooser key binding example + * + * The default keys that activate the key-binding signals in + * GtkFileChooserDefaultClass are as + * follows: + * + * + * + * + * + * Signal name + * Default key combinations + * + * + * location-popup + * + * ControlL (empty path); + * / (path of "/") + * + * Both the individual / key and the + * numeric keypad's "divide" key are supported. + * ; + * ~ (path of "~") + * + * + * + * up-folder + * + * AltUp; + * AltShiftUp + * + * Both the individual Up key and the numeric + * keypad's Up key are supported. + * ; + * Backspace + * + * + * + * down-folder + * + * AltDown; + * AltShiftDown + * + * Both the individual Down key and the numeric + * keypad's Down key are supported. + * + * + * + * + * home-folder + * AltHome + * + * + * desktop-folder + * AltD + * + * + * quick-bookmark + * Alt1 through Alt0 + * + * + * + * + * + * You can change these defaults to something else. For + * example, to add a Shift modifier to a few + * of the default bindings, you can include the following + * fragment in your .config/gtk-3.0/gtk.css file: + * + * + * @binding-set MyOwnFilechooserBindings + * { + * bind "<Alt><Shift>Up" { "up-folder" () } + * bind "<Alt><Shift>Down" { "down-folder" () } + * bind "<Alt><Shift>Home" { "home-folder" () } + * } + * + * GtkFileChooserDefault + * { + * gtk-key-bindings: MyOwnFilechooserBindings + * } + * + * + * + * The "GtkFileChooserDefault::location-popup" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * const char *path, + * gpointer user_data); + * + * + * This is used to make the file chooser show a "Location" + * dialog which the user can use to manually type the name of + * the file he wishes to select. The + * path argument is a string that gets + * put in the text entry for the file name. By default this is bound to + * ControlL + * with a path string of "" (the empty + * string). It is also bound to / with a + * path string of "/" + * (a slash): this lets you type / and + * immediately type a path name. On Unix systems, this is bound to + * ~ (tilde) with a path string + * of "~" itself for access to home directories. + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * path : + * + * + * default contents for the text entry for the file name + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * You can create your own bindings for the + * #GtkFileChooserDefault::location-popup signal with custom + * path strings, and have a crude form + * of easily-to-type bookmarks. For example, say you access + * the path /home/username/misc very + * frequently. You could then create an + * Alt M + * shortcut by including the following in your + * .config/gtk-3.0/gtk.css: + * + * @binding-set MiscShortcut + * { + * bind "<Alt>M" { "location-popup" ("/home/username/misc") } + * } + * + * GtkFileChooserDefault + * { + * gtk-key-bindings: MiscShortcut + * } + * + * + * + * + * The "GtkFileChooserDefault::up-folder" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * gpointer user_data); + * + * + * This is used to make the file chooser go to the parent of + * the current folder in the file hierarchy. By default this + * is bound to Backspace and + * AltUp + * (the Up key in the numeric keypad also works). + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * + * The "GtkFileChooserDefault::down-folder" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * gpointer user_data); + * + * + * This is used to make the file chooser go to a child of the + * current folder in the file hierarchy. The subfolder that + * will be used is displayed in the path bar widget of the file + * chooser. For example, if the path bar is showing + * "/foo/bar/baz", then this will cause + * the file chooser to switch to the "baz" subfolder. By + * default this is bound to + * AltDown + * (the Down key in the numeric keypad also works). + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * + * The "GtkFileChooserDefault::home-folder" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * gpointer user_data); + * + * + * This is used to make the file chooser show the user's home + * folder in the file list. By default this is bound to + * AltHome + * (the Home key in the numeric keypad also works). + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * + * The "GtkFileChooserDefault::desktop-folder" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * gpointer user_data); + * + * + * This is used to make the file chooser show the user's Desktop + * folder in the file list. By default this is bound to + * AltD. + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * + * The "GtkFileChooserDefault::quick-bookmark" signal + * + * void user_function (GtkFileChooserDefault *chooser, + * gint bookmark_index, + * gpointer user_data); + * + * + * This is used to make the file chooser switch to the bookmark + * specified in the bookmark_index parameter. + * For example, if you have three bookmarks, you can pass 0, 1, 2 to + * this signal to switch to each of them, respectively. By default this is bound to + * Alt1, + * Alt2, + * etc. until + * Alt0. Note + * that in the default binding, + * that Alt1 is + * actually defined to switch to the bookmark at index 0, and so on + * successively; + * Alt0 is + * defined to switch to the bookmark at index 10. + * + * + * + * chooser : + * + * + * the object which received the signal. + * + * + * + * + * bookmark_indes : + * + * + * index of the bookmark to switch to; the indices start at 0. + * + * + * + * + * user_data : + * + * + * user data set when the signal handler was connected. + * + * + * + * + * + * + */ - if (!file_chooser_type) - { - static const GTypeInfo file_chooser_info = - { - sizeof (GtkFileChooserIface), /* class_size */ - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc)gtk_file_chooser_class_init, /* class_init */ - }; - - file_chooser_type = g_type_register_static (G_TYPE_INTERFACE, - I_("GtkFileChooser"), - &file_chooser_info, 0); - - g_type_interface_add_prerequisite (file_chooser_type, GTK_TYPE_WIDGET); - } - return file_chooser_type; -} +typedef GtkFileChooserIface GtkFileChooserInterface; +G_DEFINE_INTERFACE (GtkFileChooser, gtk_file_chooser, GTK_TYPE_WIDGET); static gboolean confirm_overwrite_accumulator (GSignalInvocationHint *ihint, @@ -74,12 +549,12 @@ confirm_overwrite_accumulator (GSignalInvocationHint *ihint, } static void -gtk_file_chooser_class_init (gpointer g_iface) +gtk_file_chooser_default_init (GtkFileChooserInterface *iface) { - GType iface_type = G_TYPE_FROM_INTERFACE (g_iface); + GType iface_type = G_TYPE_FROM_INTERFACE (iface); /** - * GtkFileChooser::current-folder-changed + * GtkFileChooser::current-folder-changed: * @chooser: the object which received the signal. * * This signal is emitted when the current folder in a #GtkFileChooser @@ -105,7 +580,7 @@ gtk_file_chooser_class_init (gpointer g_iface) G_TYPE_NONE, 0); /** - * GtkFileChooser::selection-changed + * GtkFileChooser::selection-changed: * @chooser: the object which received the signal. * * This signal is emitted when there is a change in the set of selected files @@ -132,7 +607,7 @@ gtk_file_chooser_class_init (gpointer g_iface) G_TYPE_NONE, 0); /** - * GtkFileChooser::update-preview + * GtkFileChooser::update-preview: * @chooser: the object which received the signal. * * This signal is emitted when the preview in a file chooser should be @@ -146,7 +621,7 @@ gtk_file_chooser_class_init (gpointer g_iface) * gtk_file_chooser_get_preview_filename() or * gtk_file_chooser_get_preview_uri() to get the name of the file to preview. * Your widget may not be able to preview all kinds of files; your callback - * must call gtk_file_chooser_set_preview_wiget_active() to inform the file + * must call gtk_file_chooser_set_preview_widget_active() to inform the file * chooser about whether the preview was generated successfully or not. * * Please see the example code in . @@ -166,7 +641,7 @@ gtk_file_chooser_class_init (gpointer g_iface) G_TYPE_NONE, 0); /** - * GtkFileChooser::file-activated + * GtkFileChooser::file-activated: * @chooser: the object which received the signal. * * This signal is emitted when the user "activates" a file in the file @@ -189,7 +664,74 @@ gtk_file_chooser_class_init (gpointer g_iface) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - /* Documented in the docbook files */ + /** + * GtkFileChooser::confirm-overwrite: + * @chooser: the object which received the signal. + * + * This signal gets emitted whenever it is appropriate to present a + * confirmation dialog when the user has selected a file name that + * already exists. The signal only gets emitted when the file + * chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode. + * + * Most applications just need to turn on the + * #GtkFileChooser:do-overwrite-confirmation property (or call the + * gtk_file_chooser_set_do_overwrite_confirmation() function), and + * they will automatically get a stock confirmation dialog. + * Applications which need to customize this behavior should do + * that, and also connect to the #GtkFileChooser::confirm-overwrite + * signal. + * + * A signal handler for this signal must return a + * #GtkFileChooserConfirmation value, which indicates the action to + * take. If the handler determines that the user wants to select a + * different filename, it should return + * %GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN. If it determines + * that the user is satisfied with his choice of file name, it + * should return %GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME. + * On the other hand, if it determines that the stock confirmation + * dialog should be used, it should return + * %GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM. The following example + * illustrates this. + * + * Custom confirmation + * + * static GtkFileChooserConfirmation + * confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data) + * { + * char *uri; + * + * uri = gtk_file_chooser_get_uri (chooser); + * + * if (is_uri_read_only (uri)) + * { + * if (user_wants_to_replace_read_only_file (uri)) + * return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME; + * else + * return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN; + * } else + * return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog + * } + * + * ... + * + * chooser = gtk_file_chooser_dialog_new (...); + * + * gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); + * g_signal_connect (chooser, "confirm-overwrite", + * G_CALLBACK (confirm_overwrite_callback), NULL); + * + * if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT) + * save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); + * + * gtk_widget_destroy (chooser); + * + * + * + * Returns: a #GtkFileChooserConfirmation value that indicates which + * action to take after emitting the signal. + * + * Since: 2.8 + */ g_signal_new (I_("confirm-overwrite"), iface_type, G_SIGNAL_RUN_LAST, @@ -198,63 +740,57 @@ gtk_file_chooser_class_init (gpointer g_iface) _gtk_marshal_ENUM__VOID, GTK_TYPE_FILE_CHOOSER_CONFIRMATION, 0); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_enum ("action", P_("Action"), P_("The type of operation that the file selector is performing"), GTK_TYPE_FILE_CHOOSER_ACTION, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, - g_param_spec_string ("file-system-backend", - P_("File System Backend"), - P_("Name of file system backend to use"), - NULL, - GTK_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_object ("filter", P_("Filter"), P_("The current filter for selecting which files are displayed"), GTK_TYPE_FILE_FILTER, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_boolean ("local-only", P_("Local Only"), P_("Whether the selected file(s) should be limited to local file: URLs"), TRUE, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_object ("preview-widget", P_("Preview widget"), P_("Application supplied widget for custom previews."), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_boolean ("preview-widget-active", P_("Preview Widget Active"), P_("Whether the application supplied widget for custom previews should be shown."), TRUE, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_boolean ("use-preview-label", P_("Use Preview Label"), P_("Whether to display a stock label with the name of the previewed file."), TRUE, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_object ("extra-widget", P_("Extra widget"), P_("Application supplied widget for extra options."), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_boolean ("select-multiple", P_("Select Multiple"), P_("Whether to allow multiple files to be selected"), FALSE, GTK_PARAM_READWRITE)); - - g_object_interface_install_property (g_iface, + + g_object_interface_install_property (iface, g_param_spec_boolean ("show-hidden", P_("Show Hidden"), P_("Whether the hidden files and folders should be displayed"), @@ -270,14 +806,30 @@ gtk_file_chooser_class_init (gpointer g_iface) * * Since: 2.8 */ - g_object_interface_install_property (g_iface, + g_object_interface_install_property (iface, g_param_spec_boolean ("do-overwrite-confirmation", P_("Do overwrite confirmation"), - P_("Whether a file chooser in save mode" + P_("Whether a file chooser in save mode " "will present an overwrite confirmation dialog " - " if necessary."), + "if necessary."), FALSE, GTK_PARAM_READWRITE)); + + /** + * GtkFileChooser:create-folders: + * + * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode + * will offer the user to create new folders. + * + * Since: 2.18 + */ + g_object_interface_install_property (iface, + g_param_spec_boolean ("create-folders", + P_("Allow folder creation"), + P_("Whether a file chooser not in open mode " + "will offer the user to create new folders."), + TRUE, + GTK_PARAM_READWRITE)); } /** @@ -292,10 +844,7 @@ gtk_file_chooser_class_init (gpointer g_iface) GQuark gtk_file_chooser_error_quark (void) { - static GQuark quark = 0; - if (quark == 0) - quark = g_quark_from_static_string ("gtk-file-chooser-error-quark"); - return quark; + return g_quark_from_static_string ("gtk-file-chooser-error-quark"); } /** @@ -358,6 +907,10 @@ gtk_file_chooser_get_action (GtkFileChooser *chooser) * rather than the URI functions like * gtk_file_chooser_get_uri(), * + * On some systems non-native files may still be + * available using the native filesystem via a userspace + * filesystem (FUSE). + * * Since: 2.4 **/ void @@ -371,7 +924,7 @@ gtk_file_chooser_set_local_only (GtkFileChooser *chooser, /** * gtk_file_chooser_get_local_only: - * @chooser: a #GtkFileChoosre + * @chooser: a #GtkFileChooser * * Gets whether only local files can be selected in the * file selector. See gtk_file_chooser_set_local_only() @@ -398,9 +951,8 @@ gtk_file_chooser_get_local_only (GtkFileChooser *chooser) * @select_multiple: %TRUE if multiple files can be selected. * * Sets whether multiple files can be selected in the file selector. This is - * only relevant if the action is set to be GTK_FILE_CHOOSER_ACTION_OPEN or - * GTK_FILE_CHOOSER_ACTION_SAVE. It cannot be set with either of the folder - * actions. + * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or + * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER. * * Since: 2.4 **/ @@ -436,18 +988,62 @@ gtk_file_chooser_get_select_multiple (GtkFileChooser *chooser) return select_multiple; } +/** + * gtk_file_chooser_set_create_folders: + * @chooser: a #GtkFileChooser + * @create_folders: %TRUE if the New Folder button should be displayed + * + * Sets whether file choser will offer to create new folders. + * This is only relevant if the action is not set to be + * %GTK_FILE_CHOOSER_ACTION_OPEN. + * + * Since: 2.18 + **/ +void +gtk_file_chooser_set_create_folders (GtkFileChooser *chooser, + gboolean create_folders) +{ + g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser)); + + g_object_set (chooser, "create-folders", create_folders, NULL); +} + +/** + * gtk_file_chooser_get_create_folders: + * @chooser: a #GtkFileChooser + * + * Gets whether file choser will offer to create new folders. + * See gtk_file_chooser_set_create_folders(). + * + * Return value: %TRUE if the New Folder button should be displayed. + * + * Since: 2.18 + **/ +gboolean +gtk_file_chooser_get_create_folders (GtkFileChooser *chooser) +{ + gboolean create_folders; + + g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); + + g_object_get (chooser, "create-folders", &create_folders, NULL); + + return create_folders; +} + /** * gtk_file_chooser_get_filename: * @chooser: a #GtkFileChooser * * Gets the filename for the currently selected file in - * the file selector. If multiple files are selected, - * one of the filenames will be returned at random. + * the file selector. The filename is returned as an absolute path. If + * multiple files are selected, one of the filenames will be returned at + * random. * * If the file chooser is in folder mode, this function returns the selected * folder. * - * Return value: The currently selected filename, or %NULL + * Return value: (type filename): The currently selected filename, or %NULL * if no file is selected, or the selected file can't * be represented with a local filename. Free with g_free(). * @@ -456,18 +1052,17 @@ gtk_file_chooser_get_select_multiple (GtkFileChooser *chooser) gchar * gtk_file_chooser_get_filename (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *result = NULL; - + g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - path = gtk_file_chooser_get_path (chooser); - if (path) + file = gtk_file_chooser_get_file (chooser); + + if (file) { - result = gtk_file_system_path_to_filename (file_system, path); - gtk_file_path_free (path); + result = g_file_get_path (file); + g_object_unref (file); } return result; @@ -476,44 +1071,42 @@ gtk_file_chooser_get_filename (GtkFileChooser *chooser) /** * gtk_file_chooser_set_filename: * @chooser: a #GtkFileChooser - * @filename: the filename to set as current + * @filename: (type filename): the filename to set as current * - * Sets @filename as the current filename for the file chooser, by changing - * to the file's parent folder and actually selecting the file in list. If - * the @chooser is in #GTK_FILE_CHOOSER_ACTION_SAVE mode, the file's base name - * will also appear in the dialog's file name entry. - * - * If the file name isn't in the current folder of @chooser, then the current - * folder of @chooser will be changed to the folder containing @filename. This - * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by - * gtk_file_chooser_select_filename(). + * Sets @filename as the current filename for the file chooser, by changing to + * the file's parent folder and actually selecting the file in list; all other + * files will be unselected. If the @chooser is in + * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file's base name will also appear in + * the dialog's file name entry. * * Note that the file must exist, or nothing will be done except * for the directory change. * - * If you are implementing a File/Save As... dialog, you - * should use this function if you already have a file name to which the user may save; for example, - * when the user opens an existing file and then does File/Save As... - * on it. If you don't have a file name already — for example, if the user just created - * a new file and is saving it for the first time, do not call this function. Instead, use - * something similar to this: - * - * + * You should use this function only when implementing a File/Save + * As... dialog for which you already have a file name to which + * the user may save. For example, when the user opens an existing file and + * then does File/Save As... on it to save a copy or + * a modified version. If you don't have a file name already — for + * example, if the user just created a new file and is saving it for the first + * time, do not call this function. Instead, use something similar to this: + * |[ * if (document_is_new) * { - * /* the user just created a new document */ - * gtk_file_chooser_set_current_folder (chooser, default_folder_for_saving); + * /* the user just created a new document */ * gtk_file_chooser_set_current_name (chooser, "Untitled document"); * } * else * { - * /* the user edited an existing document */ + * /* the user edited an existing document */ * gtk_file_chooser_set_filename (chooser, existing_filename); * } - * + * ]| + * + * In the first case, the file chooser will present the user with useful suggestions + * as to where to save his new file. In the second case, the file's existing location + * is already known, so the file chooser will use it. * - * Return value: %TRUE if both the folder could be changed and the file was - * selected successfully, %FALSE otherwise. + * Return value: Not useful. * * Since: 2.4 **/ @@ -530,14 +1123,15 @@ gtk_file_chooser_set_filename (GtkFileChooser *chooser, /** * gtk_file_chooser_select_filename: * @chooser: a #GtkFileChooser - * @filename: the filename to select + * @filename: (type filename): the filename to select * * Selects a filename. If the file name isn't in the current * folder of @chooser, then the current folder of @chooser will * be changed to the folder containing @filename. * - * Return value: %TRUE if both the folder could be changed and the file was - * selected successfully, %FALSE otherwise. + * Return value: Not useful. + * + * See also: gtk_file_chooser_set_filename() * * Since: 2.4 **/ @@ -545,23 +1139,15 @@ gboolean gtk_file_chooser_select_filename (GtkFileChooser *chooser, const gchar *filename) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (filename != NULL, FALSE); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_filename_to_path (file_system, filename); - if (path) - { - result = _gtk_file_chooser_select_path (chooser, path, NULL); - gtk_file_path_free (path); - } - else - result = FALSE; + file = g_file_new_for_path (filename); + result = gtk_file_chooser_select_file (chooser, file, NULL); + g_object_unref (file); return result; } @@ -569,7 +1155,7 @@ gtk_file_chooser_select_filename (GtkFileChooser *chooser, /** * gtk_file_chooser_unselect_filename: * @chooser: a #GtkFileChooser - * @filename: the filename to unselect + * @filename: (type filename): the filename to unselect * * Unselects a currently selected filename. If the filename * is not in the current directory, does not exist, or @@ -581,39 +1167,32 @@ void gtk_file_chooser_unselect_filename (GtkFileChooser *chooser, const char *filename) { - GtkFileSystem *file_system; - GtkFilePath *path; - + GFile *file; + g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser)); g_return_if_fail (filename != NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_filename_to_path (file_system, filename); - if (path) - { - _gtk_file_chooser_unselect_path (chooser, path); - gtk_file_path_free (path); - } + file = g_file_new_for_path (filename); + gtk_file_chooser_unselect_file (chooser, file); + g_object_unref (file); } -/* Converts a list of GtkFilePath* to a list of strings using the specified function */ +/* Converts a list of GFile* to a list of strings using the specified function */ static GSList * -file_paths_to_strings (GtkFileSystem *fs, - GSList *paths, - gchar * (*convert_func) (GtkFileSystem *fs, const GtkFilePath *path)) +files_to_strings (GSList *files, + gchar * (*convert_func) (GFile *file)) { GSList *strings; strings = NULL; - for (; paths; paths = paths->next) + for (; files; files = files->next) { - GtkFilePath *path; + GFile *file; gchar *string; - path = paths->data; - string = (* convert_func) (fs, path); + file = files->data; + string = (* convert_func) (file); if (string) strings = g_slist_prepend (strings, string); @@ -622,6 +1201,22 @@ file_paths_to_strings (GtkFileSystem *fs, return g_slist_reverse (strings); } +static gchar * +file_to_uri_with_native_path (GFile *file) +{ + gchar *result = NULL; + gchar *native; + + native = g_file_get_path (file); + if (native) + { + result = g_filename_to_uri (native, NULL, NULL); /* NULL-GError */ + g_free (native); + } + + return result; +} + /** * gtk_file_chooser_get_filenames: * @chooser: a #GtkFileChooser @@ -630,41 +1225,44 @@ file_paths_to_strings (GtkFileSystem *fs, * @chooser. The returned names are full absolute paths. If files in the current * folder cannot be represented as local filenames they will be ignored. (See * gtk_file_chooser_get_uris()) - * - * Return value: a #GSList containing the filenames of all selected - * files and subfolders in the current folder. Free the returned list - * with g_slist_free(), and the filenames with g_free(). + * + * Return value: (element-type filename) (transfer full): a #GSList + * containing the filenames of all selected files and subfolders in + * the current folder. Free the returned list with g_slist_free(), + * and the filenames with g_free(). * * Since: 2.4 **/ GSList * gtk_file_chooser_get_filenames (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GSList *paths; - GSList *result; + GSList *files, *result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - paths = _gtk_file_chooser_get_paths (chooser); + files = gtk_file_chooser_get_files (chooser); + + result = files_to_strings (files, g_file_get_path); + g_slist_foreach (files, (GFunc) g_object_unref, NULL); + g_slist_free (files); - result = file_paths_to_strings (file_system, paths, gtk_file_system_path_to_filename); - gtk_file_paths_free (paths); return result; } /** * gtk_file_chooser_set_current_folder: * @chooser: a #GtkFileChooser - * @filename: the full path of the new current folder + * @filename: (type filename): the full path of the new current folder * * Sets the current folder for @chooser from a local filename. * The user will be shown the full contents of the current folder, * plus user interface elements for navigating to other folders. * - * Return value: %TRUE if the folder could be changed successfully, %FALSE - * otherwise. + * In general, you should not use this function. See the section on setting up a file + * chooser dialog for the rationale behind this. + * + * Return value: Not useful. * * Since: 2.4 **/ @@ -672,23 +1270,15 @@ gboolean gtk_file_chooser_set_current_folder (GtkFileChooser *chooser, const gchar *filename) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (filename != NULL, FALSE); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_filename_to_path (file_system, filename); - if (path) - { - result = _gtk_file_chooser_set_current_folder_path (chooser, path, NULL); - gtk_file_path_free (path); - } - else - result = FALSE; + file = g_file_new_for_path (filename); + result = gtk_file_chooser_set_current_folder_file (chooser, file, NULL); + g_object_unref (file); return result; } @@ -699,27 +1289,38 @@ gtk_file_chooser_set_current_folder (GtkFileChooser *chooser, * * Gets the current folder of @chooser as a local filename. * See gtk_file_chooser_set_current_folder(). - * - * Return value: the full path of the current folder, or %NULL - * if the current path cannot be represented as a local filename. - * Free with g_free(). + * + * Note that this is the folder that the file chooser is currently displaying + * (e.g. "/home/username/Documents"), which is not the same + * as the currently-selected folder if the chooser is in + * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode + * (e.g. "/home/username/Documents/selected-folder/". To get the + * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the + * usual way to get the selection. + * + * Return value: (type filename): the full path of the current folder, + * or %NULL if the current path cannot be represented as a local + * filename. Free with g_free(). This function will also return + * %NULL if the file chooser was unable to load the last folder that + * was requested from it; for example, as would be for calling + * gtk_file_chooser_set_current_folder() on a nonexistent folder. * * Since: 2.4 **/ gchar * gtk_file_chooser_get_current_folder (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *filename; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); + file = gtk_file_chooser_get_current_folder_file (chooser); + if (!file) + return NULL; - path = _gtk_file_chooser_get_current_folder_path (chooser); - filename = gtk_file_system_path_to_filename (file_system, path); - gtk_file_path_free (path); + filename = g_file_get_path (file); + g_object_unref (file); return filename; } @@ -727,12 +1328,13 @@ gtk_file_chooser_get_current_folder (GtkFileChooser *chooser) /** * gtk_file_chooser_set_current_name: * @chooser: a #GtkFileChooser - * @name: the filename to use, as a UTF-8 string + * @name: (type filename): the filename to use, as a UTF-8 string * * Sets the current name in the file selector, as if entered * by the user. Note that the name passed in here is a UTF-8 * string rather than a filename. This function is meant for - * such uses as a suggested name in a "Save As..." dialog. + * such uses as a suggested name in a "Save As..." dialog. You can + * pass "Untitled.doc" or a similarly suitable suggestion for the @name. * * If you want to preselect a particular existing file, you should use * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead. @@ -763,25 +1365,29 @@ gtk_file_chooser_set_current_name (GtkFileChooser *chooser, * folder. * * Return value: The currently selected URI, or %NULL - * if no file is selected. Free with g_free() + * if no file is selected. If gtk_file_chooser_set_local_only() is set to %TRUE + * (the default) a local URI will be returned for any FUSE locations. + * Free with g_free() * * Since: 2.4 **/ gchar * gtk_file_chooser_get_uri (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *result = NULL; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - path = gtk_file_chooser_get_path (chooser); - if (path) + file = gtk_file_chooser_get_file (chooser); + if (file) { - result = gtk_file_system_path_to_uri (file_system, path); - gtk_file_path_free (path); + if (gtk_file_chooser_get_local_only (chooser)) + result = file_to_uri_with_native_path (file); + else + result = g_file_get_uri (file); + + g_object_unref (file); } return result; @@ -794,39 +1400,38 @@ gtk_file_chooser_get_uri (GtkFileChooser *chooser) * * Sets the file referred to by @uri as the current file for the file chooser, * by changing to the URI's parent folder and actually selecting the URI in the - * list. If the @chooser is #GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI's base + * list. If the @chooser is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI's base * name will also appear in the dialog's file name entry. * - * If the URI isn't in the current folder of @chooser, then the current folder - * of @chooser will be changed to the folder containing @uri. This is equivalent - * to a sequence of gtk_file_chooser_unselect_all() followed by - * gtk_file_chooser_select_uri(). - * - * Note that the URI must exist, or nothing will be done except - * for the directory change. - * If you are implementing a File/Save As... dialog, you - * should use this function if you already have a file name to which the user may save; for example, - * when the user opens an existing file and then does File/Save As... - * on it. If you don't have a file name already — for example, if the user just created - * a new file and is saving it for the first time, do not call this function. Instead, use - * something similar to this: - * - * + * Note that the URI must exist, or nothing will be done except for the + * directory change. + * + * You should use this function only when implementing a File/Save + * As... dialog for which you already have a file name to which + * the user may save. For example, whenthe user opens an existing file and then + * does File/Save As... on it to save a copy or a + * modified version. If you don't have a file name already — for example, + * if the user just created a new file and is saving it for the first time, do + * not call this function. Instead, use something similar to this: + * |[ * if (document_is_new) * { - * /* the user just created a new document */ - * gtk_file_chooser_set_current_folder_uri (chooser, default_folder_for_saving); + * /* the user just created a new document */ * gtk_file_chooser_set_current_name (chooser, "Untitled document"); * } * else * { - * /* the user edited an existing document */ + * /* the user edited an existing document */ * gtk_file_chooser_set_uri (chooser, existing_uri); * } - * + * ]| + * * - * Return value: %TRUE if both the folder could be changed and the URI was - * selected successfully, %FALSE otherwise. + * In the first case, the file chooser will present the user with useful suggestions + * as to where to save his new file. In the second case, the file's existing location + * is already known, so the file chooser will use it. + * + * Return value: Not useful. * * Since: 2.4 **/ @@ -849,8 +1454,7 @@ gtk_file_chooser_set_uri (GtkFileChooser *chooser, * file in the current folder of @chooser, then the current folder of * @chooser will be changed to the folder containing @filename. * - * Return value: %TRUE if both the folder could be changed and the URI was - * selected successfully, %FALSE otherwise. + * Return value: Not useful. * * Since: 2.4 **/ @@ -858,23 +1462,15 @@ gboolean gtk_file_chooser_select_uri (GtkFileChooser *chooser, const char *uri) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (uri != NULL, FALSE); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_uri_to_path (file_system, uri); - if (path) - { - result = _gtk_file_chooser_select_path (chooser, path, NULL); - gtk_file_path_free (path); - } - else - result = FALSE; + file = g_file_new_for_uri (uri); + result = gtk_file_chooser_select_file (chooser, file, NULL); + g_object_unref (file); return result; } @@ -894,20 +1490,14 @@ void gtk_file_chooser_unselect_uri (GtkFileChooser *chooser, const char *uri) { - GtkFileSystem *file_system; - GtkFilePath *path; - + GFile *file; + g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser)); g_return_if_fail (uri != NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_uri_to_path (file_system, uri); - if (path) - { - _gtk_file_chooser_unselect_path (chooser, path); - gtk_file_path_free (path); - } + file = g_file_new_for_uri (uri); + gtk_file_chooser_unselect_file (chooser, file); + g_object_unref (file); } /** @@ -949,8 +1539,8 @@ gtk_file_chooser_unselect_all (GtkFileChooser *chooser) * * Lists all the selected files and subfolders in the current folder of * @chooser. The returned names are full absolute URIs. - * - * Return value: a #GSList containing the URIs of all selected + * + * Return value: (element-type utf8) (transfer full): a #GSList containing the URIs of all selected * files and subfolders in the current folder. Free the returned list * with g_slist_free(), and the filenames with g_free(). * @@ -959,17 +1549,20 @@ gtk_file_chooser_unselect_all (GtkFileChooser *chooser) GSList * gtk_file_chooser_get_uris (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GSList *paths; - GSList *result; + GSList *files, *result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - paths = _gtk_file_chooser_get_paths (chooser); + files = gtk_file_chooser_get_files (chooser); + + if (gtk_file_chooser_get_local_only (chooser)) + result = files_to_strings (files, file_to_uri_with_native_path); + else + result = files_to_strings (files, g_file_get_uri); + + g_slist_foreach (files, (GFunc) g_object_unref, NULL); + g_slist_free (files); - result = file_paths_to_strings (file_system, paths, gtk_file_system_path_to_uri); - gtk_file_paths_free (paths); return result; } @@ -982,6 +1575,10 @@ gtk_file_chooser_get_uris (GtkFileChooser *chooser) * The user will be shown the full contents of the current folder, * plus user interface elements for navigating to other folders. * + * In general, you should not use this function. See the section on setting up a file + * chooser dialog for the rationale behind this. + * * Return value: %TRUE if the folder could be changed successfully, %FALSE * otherwise. * @@ -991,23 +1588,15 @@ gboolean gtk_file_chooser_set_current_folder_uri (GtkFileChooser *chooser, const gchar *uri) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (uri != NULL, FALSE); - file_system = _gtk_file_chooser_get_file_system (chooser); - - path = gtk_file_system_uri_to_path (file_system, uri); - if (path) - { - result = _gtk_file_chooser_set_current_folder_path (chooser, path, NULL); - gtk_file_path_free (path); - } - else - result = FALSE; + file = g_file_new_for_uri (uri); + result = gtk_file_chooser_set_current_folder_file (chooser, file, NULL); + g_object_unref (file); return result; } @@ -1015,159 +1604,244 @@ gtk_file_chooser_set_current_folder_uri (GtkFileChooser *chooser, /** * gtk_file_chooser_get_current_folder_uri: * @chooser: a #GtkFileChooser - * + * * Gets the current folder of @chooser as an URI. * See gtk_file_chooser_set_current_folder_uri(). + * + * Note that this is the folder that the file chooser is currently displaying + * (e.g. "file:///home/username/Documents"), which is not the same + * as the currently-selected folder if the chooser is in + * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode + * (e.g. "file:///home/username/Documents/selected-folder/". To get the + * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the + * usual way to get the selection. * - * Return value: the URI for the current folder. - * Free with g_free(). + * Return value: the URI for the current folder. Free with g_free(). This + * function will also return %NULL if the file chooser was unable to load the + * last folder that was requested from it; for example, as would be for calling + * gtk_file_chooser_set_current_folder_uri() on a nonexistent folder. * * Since: 2.4 */ gchar * gtk_file_chooser_get_current_folder_uri (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *uri; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); + file = gtk_file_chooser_get_current_folder_file (chooser); + if (!file) + return NULL; - path = _gtk_file_chooser_get_current_folder_path (chooser); - uri = gtk_file_system_path_to_uri (file_system, path); - gtk_file_path_free (path); + uri = g_file_get_uri (file); + g_object_unref (file); return uri; } /** - * _gtk_file_chooser_set_current_folder_path: + * gtk_file_chooser_set_current_folder_file: * @chooser: a #GtkFileChooser - * @path: the #GtkFilePath for the new folder - * @error: location to store error, or %NULL. - * - * Sets the current folder for @chooser from a #GtkFilePath. + * @file: the #GFile for the new folder + * @error: (allow-none): location to store error, or %NULL. + * + * Sets the current folder for @chooser from a #GFile. * Internal function, see gtk_file_chooser_set_current_folder_uri(). * * Return value: %TRUE if the folder could be changed successfully, %FALSE * otherwise. * - * Since: 2.4 + * Since: 2.14 **/ gboolean -_gtk_file_chooser_set_current_folder_path (GtkFileChooser *chooser, - const GtkFilePath *path, - GError **error) +gtk_file_chooser_set_current_folder_file (GtkFileChooser *chooser, + GFile *file, + GError **error) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); - g_return_val_if_fail (path != NULL, FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->set_current_folder (chooser, path, error); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->set_current_folder (chooser, file, error); } /** - * _gtk_file_chooser_get_current_folder_path: + * gtk_file_chooser_get_current_folder_file: * @chooser: a #GtkFileChooser - * - * Gets the current folder of @chooser as #GtkFilePath. + * + * Gets the current folder of @chooser as #GFile. * See gtk_file_chooser_get_current_folder_uri(). - * - * Return value: the #GtkFilePath for the current folder. - * Free with gtk_file_path_free(). * - * Since: 2.4 + * Return value: (transfer full): the #GFile for the current folder. + * + * Since: 2.14 */ -GtkFilePath * -_gtk_file_chooser_get_current_folder_path (GtkFileChooser *chooser) +GFile * +gtk_file_chooser_get_current_folder_file (GtkFileChooser *chooser) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_current_folder (chooser); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_current_folder (chooser); } /** - * _gtk_file_chooser_select_path: + * gtk_file_chooser_select_file: * @chooser: a #GtkFileChooser - * @path: the path to select - * @error: location to store error, or %NULL + * @file: the file to select + * @error: (allow-none): location to store error, or %NULL * - * Selects the file referred to by @path. An internal function. See + * Selects the file referred to by @file. An internal function. See * _gtk_file_chooser_select_uri(). * - * Return value: %TRUE if both the folder could be changed and the path was - * selected successfully, %FALSE otherwise. + * Return value: Not useful. * - * Since: 2.4 + * Since: 2.14 **/ gboolean -_gtk_file_chooser_select_path (GtkFileChooser *chooser, - const GtkFilePath *path, - GError **error) +gtk_file_chooser_select_file (GtkFileChooser *chooser, + GFile *file, + GError **error) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); - g_return_val_if_fail (path != NULL, FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->select_path (chooser, path, error); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->select_file (chooser, file, error); } /** - * _gtk_file_chooser_unselect_path: + * gtk_file_chooser_unselect_file: * @chooser: a #GtkFileChooser - * @path: the filename to path + * @file: a #GFile * - * Unselects the file referred to by @path. An internal - * function. See _gtk_file_chooser_unselect_uri(). + * Unselects the file referred to by @file. If the file is not in the current + * directory, does not exist, or is otherwise not currently selected, does nothing. * - * Since: 2.4 + * Since: 2.14 **/ void -_gtk_file_chooser_unselect_path (GtkFileChooser *chooser, - const GtkFilePath *path) +gtk_file_chooser_unselect_file (GtkFileChooser *chooser, + GFile *file) { g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser)); + g_return_if_fail (G_IS_FILE (file)); - GTK_FILE_CHOOSER_GET_IFACE (chooser)->unselect_path (chooser, path); + GTK_FILE_CHOOSER_GET_IFACE (chooser)->unselect_file (chooser, file); } /** - * _gtk_file_chooser_get_paths: + * gtk_file_chooser_get_files: * @chooser: a #GtkFileChooser * * Lists all the selected files and subfolders in the current folder of @chooser - * as #GtkFilePath. An internal function, see gtk_file_chooser_get_uris(). - * - * Return value: a #GSList containing a #GtkFilePath for each selected - * file and subfolder in the current folder. Free the returned list - * with g_slist_free(), and the paths with gtk_file_path_free(). + * as #GFile. An internal function, see gtk_file_chooser_get_uris(). * - * Since: 2.4 + * Return value: (element-type GFile) (transfer full): a #GSList + * containing a #GFile for each selected file and subfolder in the + * current folder. Free the returned list with g_slist_free(), and + * the files with g_object_unref(). + * + * Since: 2.14 **/ GSList * -_gtk_file_chooser_get_paths (GtkFileChooser *chooser) +gtk_file_chooser_get_files (GtkFileChooser *chooser) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_paths (chooser); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_files (chooser); } -static GtkFilePath * -gtk_file_chooser_get_path (GtkFileChooser *chooser) +/** + * gtk_file_chooser_set_file: + * @chooser: a #GtkFileChooser + * @file: the #GFile to set as current + * @error: (allow-none): location to store the error, or %NULL to ignore errors. + * + * Sets @file as the current filename for the file chooser, by changing + * to the file's parent folder and actually selecting the file in list. If + * the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file's base name + * will also appear in the dialog's file name entry. + * + * If the file name isn't in the current folder of @chooser, then the current + * folder of @chooser will be changed to the folder containing @filename. This + * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by + * gtk_file_chooser_select_filename(). + * + * Note that the file must exist, or nothing will be done except + * for the directory change. + * + * If you are implementing a File/Save As... dialog, + * you should use this function if you already have a file name to which the + * user may save; for example, when the user opens an existing file and then + * does File/Save As... on it. If you don't have + * a file name already — for example, if the user just created a new + * file and is saving it for the first time, do not call this function. + * Instead, use something similar to this: + * |[ + * if (document_is_new) + * { + * /* the user just created a new document */ + * gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving); + * gtk_file_chooser_set_current_name (chooser, "Untitled document"); + * } + * else + * { + * /* the user edited an existing document */ + * gtk_file_chooser_set_file (chooser, existing_file); + * } + * ]| + * + * Return value: Not useful. + * + * Since: 2.14 + **/ +gboolean +gtk_file_chooser_set_file (GtkFileChooser *chooser, + GFile *file, + GError **error) +{ + g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + + gtk_file_chooser_unselect_all (chooser); + return gtk_file_chooser_select_file (chooser, file, error); +} + +/** + * gtk_file_chooser_get_file: + * @chooser: a #GtkFileChooser + * + * Gets the #GFile for the currently selected file in + * the file selector. If multiple files are selected, + * one of the files will be returned at random. + * + * If the file chooser is in folder mode, this function returns the selected + * folder. + * + * Returns: (transfer full): a selected #GFile. You own the returned file; + * use g_object_unref() to release it. + * + * Since: 2.14 + **/ +GFile * +gtk_file_chooser_get_file (GtkFileChooser *chooser) { GSList *list; - GtkFilePath *result = NULL; + GFile *result = NULL; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - list = _gtk_file_chooser_get_paths (chooser); + list = gtk_file_chooser_get_files (chooser); if (list) { result = list->data; list = g_slist_delete_link (list, list); - gtk_file_paths_free (list); + + g_slist_foreach (list, (GFunc) g_object_unref, NULL); + g_slist_free (list); } return result; @@ -1202,7 +1876,7 @@ _gtk_file_chooser_get_file_system (GtkFileChooser *chooser) * * Sets an application-supplied widget to use to display a custom preview * of the currently selected file. To implement a preview, after setting the - * preview widget, you connect to the ::update-preview + * preview widget, you connect to the #GtkFileChooser::update-preview * signal, and call gtk_file_chooser_get_preview_filename() or * gtk_file_chooser_get_preview_uri() on each change. If you can * display a preview of the new file, update your widget and @@ -1228,11 +1902,11 @@ gtk_file_chooser_set_preview_widget (GtkFileChooser *chooser, /** * gtk_file_chooser_get_preview_widget: * @chooser: a #GtkFileChooser - * + * * Gets the current preview widget; see * gtk_file_chooser_set_preview_widget(). - * - * Return value: the current preview widget, or %NULL + * + * Return value: (transfer none): the current preview widget, or %NULL * * Since: 2.4 **/ @@ -1348,30 +2022,30 @@ gtk_file_chooser_get_use_preview_label (GtkFileChooser *chooser) } /** - * gtk_file_chooser_get_preview_filename: + * gtk_file_chooser_get_preview_file: * @chooser: a #GtkFileChooser - * - * Gets the filename that should be previewed in a custom preview + * + * Gets the #GFile that should be previewed in a custom preview * Internal function, see gtk_file_chooser_get_preview_uri(). - * - * Return value: the #GtkFilePath for the file to preview, or %NULL if no file - * is selected. Free with gtk_file_path_free(). * - * Since: 2.4 + * Return value: (transfer full): the #GFile for the file to preview, + * or %NULL if no file is selected. Free with g_object_unref(). + * + * Since: 2.14 **/ -GtkFilePath * -_gtk_file_chooser_get_preview_path (GtkFileChooser *chooser) +GFile * +gtk_file_chooser_get_preview_file (GtkFileChooser *chooser) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_preview_path (chooser); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->get_preview_file (chooser); } /** * _gtk_file_chooser_add_shortcut_folder: * @chooser: a #GtkFileChooser - * @path: path of the folder to add - * @error: location to store error, or %NULL + * @file: file for the folder to add + * @error: (allow-none): location to store error, or %NULL * * Adds a folder to be displayed with the shortcut folders in a file chooser. * Internal function, see gtk_file_chooser_add_shortcut_folder(). @@ -1382,21 +2056,21 @@ _gtk_file_chooser_get_preview_path (GtkFileChooser *chooser) * Since: 2.4 **/ gboolean -_gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, - const GtkFilePath *path, - GError **error) +_gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, + GFile *file, + GError **error) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); - g_return_val_if_fail (path != NULL, FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, path, error); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, file, error); } /** * _gtk_file_chooser_remove_shortcut_folder: * @chooser: a #GtkFileChooser - * @path: path of the folder to remove - * @error: location to store error, or %NULL + * @file: file for the folder to remove + * @error: (allow-none): location to store error, or %NULL * * Removes a folder from the shortcut folders in a file chooser. Internal * function, see gtk_file_chooser_remove_shortcut_folder(). @@ -1407,14 +2081,14 @@ _gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, * Since: 2.4 **/ gboolean -_gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, - const GtkFilePath *path, - GError **error) +_gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, + GFile *file, + GError **error) { g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); - g_return_val_if_fail (path != NULL, FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); - return GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, path, error); + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, file, error); } /** @@ -1424,8 +2098,8 @@ _gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, * Gets the filename that should be previewed in a custom preview * widget. See gtk_file_chooser_set_preview_widget(). * - * Return value: the filename to preview, or %NULL if no file - * is selected, or if the selected file cannot be represented + * Return value: (type filename): the filename to preview, or %NULL if + * no file is selected, or if the selected file cannot be represented * as a local filename. Free with g_free() * * Since: 2.4 @@ -1433,18 +2107,16 @@ _gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, char * gtk_file_chooser_get_preview_filename (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *result = NULL; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - path = _gtk_file_chooser_get_preview_path (chooser); - if (path) + file = gtk_file_chooser_get_preview_file (chooser); + if (file) { - result = gtk_file_system_path_to_filename (file_system, path); - gtk_file_path_free (path); + result = g_file_get_path (file); + g_object_unref (file); } return result; @@ -1465,18 +2137,16 @@ gtk_file_chooser_get_preview_filename (GtkFileChooser *chooser) char * gtk_file_chooser_get_preview_uri (GtkFileChooser *chooser) { - GtkFileSystem *file_system; - GtkFilePath *path; + GFile *file; gchar *result = NULL; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - file_system = _gtk_file_chooser_get_file_system (chooser); - path = _gtk_file_chooser_get_preview_path (chooser); - if (path) + file = gtk_file_chooser_get_preview_file (chooser); + if (file) { - result = gtk_file_system_path_to_uri (file_system, path); - gtk_file_path_free (path); + result = g_file_get_uri (file); + g_object_unref (file); } return result; @@ -1503,11 +2173,11 @@ gtk_file_chooser_set_extra_widget (GtkFileChooser *chooser, /** * gtk_file_chooser_get_extra_widget: * @chooser: a #GtkFileChooser - * + * * Gets the current preview widget; see * gtk_file_chooser_set_extra_widget(). - * - * Return value: the current extra widget, or %NULL + * + * Return value: (transfer none): the current extra widget, or %NULL * * Since: 2.4 **/ @@ -1577,11 +2247,11 @@ gtk_file_chooser_remove_filter (GtkFileChooser *chooser, * * Lists the current set of user-selectable filters; see * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter(). - * - * Return value: a #GSList containing the current set of - * user selectable filters. The contents of the list are - * owned by GTK+, but you must free the list itself with - * g_slist_free() when you are done with it. + * + * Return value: (element-type GtkFileFilter) (transfer container): a + * #GSList containing the current set of user selectable filters. The + * contents of the list are owned by GTK+, but you must free the list + * itself with g_slist_free() when you are done with it. * * Since: 2.4 **/ @@ -1620,10 +2290,10 @@ gtk_file_chooser_set_filter (GtkFileChooser *chooser, /** * gtk_file_chooser_get_filter: * @chooser: a #GtkFileChooser - * + * * Gets the current filter; see gtk_file_chooser_set_filter(). - * - * Return value: the current filter, or %NULL + * + * Return value: (transfer none): the current filter, or %NULL * * Since: 2.4 **/ @@ -1648,8 +2318,8 @@ gtk_file_chooser_get_filter (GtkFileChooser *chooser) /** * gtk_file_chooser_add_shortcut_folder: * @chooser: a #GtkFileChooser - * @folder: filename of the folder to add - * @error: location to store error, or %NULL + * @folder: (type filename): filename of the folder to add + * @error: (allow-none): location to store error, or %NULL * * Adds a folder to be displayed with the shortcut folders in a file chooser. * Note that shortcut folders do not get saved, as they are provided by the @@ -1666,26 +2336,15 @@ gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, const char *folder, GError **error) { - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (folder != NULL, FALSE); - path = gtk_file_system_filename_to_path (_gtk_file_chooser_get_file_system (chooser), folder); - if (!path) - { - g_set_error (error, - GTK_FILE_CHOOSER_ERROR, - GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, - _("Invalid filename: %s"), - folder); - return FALSE; - } - - result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, path, error); - - gtk_file_path_free (path); + file = g_file_new_for_path (folder); + result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, file, error); + g_object_unref (file); return result; } @@ -1693,8 +2352,8 @@ gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, /** * gtk_file_chooser_remove_shortcut_folder: * @chooser: a #GtkFileChooser - * @folder: filename of the folder to remove - * @error: location to store error, or %NULL + * @folder: (type filename): filename of the folder to remove + * @error: (allow-none): location to store error, or %NULL * * Removes a folder from a file chooser's list of shortcut folders. * @@ -1710,26 +2369,15 @@ gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, const char *folder, GError **error) { - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (folder != NULL, FALSE); - path = gtk_file_system_filename_to_path (_gtk_file_chooser_get_file_system (chooser), folder); - if (!path) - { - g_set_error (error, - GTK_FILE_CHOOSER_ERROR, - GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, - _("Invalid filename: %s"), - folder); - return FALSE; - } - - result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, path, error); - - gtk_file_path_free (path); + file = g_file_new_for_path (folder); + result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, file, error); + g_object_unref (file); return result; } @@ -1740,9 +2388,10 @@ gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, * * Queries the list of shortcut folders in the file chooser, as set by * gtk_file_chooser_add_shortcut_folder(). - * - * Return value: A list of folder filenames, or %NULL if there are no shortcut - * folders. Free the returned list with g_slist_free(), and the filenames with + * + * Return value: (element-type filename) (transfer full): A list of + * folder filenames, or %NULL if there are no shortcut folders. Free + * the returned list with g_slist_free(), and the filenames with * g_free(). * * Since: 2.4 @@ -1755,12 +2404,12 @@ gtk_file_chooser_list_shortcut_folders (GtkFileChooser *chooser) g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - folders = GTK_FILE_CHOOSER_GET_IFACE (chooser)->list_shortcut_folders (chooser); + folders = _gtk_file_chooser_list_shortcut_folder_files (chooser); + + result = files_to_strings (folders, g_file_get_path); + g_slist_foreach (folders, (GFunc) g_object_unref, NULL); + g_slist_free (folders); - result = file_paths_to_strings (_gtk_file_chooser_get_file_system (chooser), - folders, - gtk_file_system_path_to_filename); - gtk_file_paths_free (folders); return result; } @@ -1768,7 +2417,7 @@ gtk_file_chooser_list_shortcut_folders (GtkFileChooser *chooser) * gtk_file_chooser_add_shortcut_folder_uri: * @chooser: a #GtkFileChooser * @uri: URI of the folder to add - * @error: location to store error, or %NULL + * @error: (allow-none): location to store error, or %NULL * * Adds a folder URI to be displayed with the shortcut folders in a file * chooser. Note that shortcut folders do not get saved, as they are provided @@ -1785,26 +2434,15 @@ gtk_file_chooser_add_shortcut_folder_uri (GtkFileChooser *chooser, const char *uri, GError **error) { - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (uri != NULL, FALSE); - path = gtk_file_system_uri_to_path (_gtk_file_chooser_get_file_system (chooser), uri); - if (!path) - { - g_set_error (error, - GTK_FILE_CHOOSER_ERROR, - GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, - _("Invalid filename: %s"), - uri); - return FALSE; - } - - result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, path, error); - - gtk_file_path_free (path); + file = g_file_new_for_uri (uri); + result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->add_shortcut_folder (chooser, file, error); + g_object_unref (file); return result; } @@ -1813,7 +2451,7 @@ gtk_file_chooser_add_shortcut_folder_uri (GtkFileChooser *chooser, * gtk_file_chooser_remove_shortcut_folder_uri: * @chooser: a #GtkFileChooser * @uri: URI of the folder to remove - * @error: location to store error, or %NULL + * @error: (allow-none): location to store error, or %NULL * * Removes a folder URI from a file chooser's list of shortcut folders. * @@ -1829,26 +2467,15 @@ gtk_file_chooser_remove_shortcut_folder_uri (GtkFileChooser *chooser, const char *uri, GError **error) { - GtkFilePath *path; + GFile *file; gboolean result; g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE); g_return_val_if_fail (uri != NULL, FALSE); - path = gtk_file_system_uri_to_path (_gtk_file_chooser_get_file_system (chooser), uri); - if (!path) - { - g_set_error (error, - GTK_FILE_CHOOSER_ERROR, - GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, - _("Invalid filename: %s"), - uri); - return FALSE; - } - - result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, path, error); - - gtk_file_path_free (path); + file = g_file_new_for_uri (uri); + result = GTK_FILE_CHOOSER_GET_IFACE (chooser)->remove_shortcut_folder (chooser, file, error); + g_object_unref (file); return result; } @@ -1859,10 +2486,10 @@ gtk_file_chooser_remove_shortcut_folder_uri (GtkFileChooser *chooser, * * Queries the list of shortcut folders in the file chooser, as set by * gtk_file_chooser_add_shortcut_folder_uri(). - * - * Return value: A list of folder URIs, or %NULL if there are no shortcut - * folders. Free the returned list with g_slist_free(), and the URIs with - * g_free(). + * + * Return value: (element-type utf8) (transfer full): A list of folder + * URIs, or %NULL if there are no shortcut folders. Free the returned + * list with g_slist_free(), and the URIs with g_free(). * * Since: 2.4 **/ @@ -1874,15 +2501,22 @@ gtk_file_chooser_list_shortcut_folder_uris (GtkFileChooser *chooser) g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); - folders = GTK_FILE_CHOOSER_GET_IFACE (chooser)->list_shortcut_folders (chooser); + folders = _gtk_file_chooser_list_shortcut_folder_files (chooser); + + result = files_to_strings (folders, g_file_get_uri); + g_slist_foreach (folders, (GFunc) g_object_unref, NULL); + g_slist_free (folders); - result = file_paths_to_strings (_gtk_file_chooser_get_file_system (chooser), - folders, - gtk_file_system_path_to_uri); - gtk_file_paths_free (folders); return result; } +GSList * +_gtk_file_chooser_list_shortcut_folder_files (GtkFileChooser *chooser) +{ + g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), NULL); + + return GTK_FILE_CHOOSER_GET_IFACE (chooser)->list_shortcut_folders (chooser); +} /** * gtk_file_chooser_set_show_hidden: @@ -1930,17 +2564,17 @@ gtk_file_chooser_get_show_hidden (GtkFileChooser *chooser) * @chooser: a #GtkFileChooser * @do_overwrite_confirmation: whether to confirm overwriting in save mode * - * Sets whether a file chooser in GTK_FILE_CHOOSER_ACTION_SAVE mode will present + * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present * a confirmation dialog if the user types a file name that already exists. This * is %FALSE by default. * - * Regardless of this setting, the @chooser will emit the "confirm-overwrite" - * signal when appropriate. + * Regardless of this setting, the @chooser will emit the + * #GtkFileChooser::confirm-overwrite signal when appropriate. * * If all you need is the stock confirmation dialog, set this property to %TRUE. * You can override the way confirmation is done by actually handling the - * "confirm-overwrite" signal; please refer to its documentation for the - * details. + * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation + * for the details. * * Since: 2.8 **/ @@ -1976,175 +2610,3 @@ gtk_file_chooser_get_do_overwrite_confirmation (GtkFileChooser *chooser) return do_overwrite_confirmation; } - -#ifdef G_OS_WIN32 - -/* DLL ABI stability backward compatibility versions */ - -#undef gtk_file_chooser_get_filename - -gchar * -gtk_file_chooser_get_filename (GtkFileChooser *chooser) -{ - gchar *utf8_filename = gtk_file_chooser_get_filename_utf8 (chooser); - gchar *retval = g_locale_from_utf8 (utf8_filename, -1, NULL, NULL, NULL); - - g_free (utf8_filename); - - return retval; -} - -#undef gtk_file_chooser_set_filename - -gboolean -gtk_file_chooser_set_filename (GtkFileChooser *chooser, - const gchar *filename) -{ - gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL); - gboolean retval = gtk_file_chooser_set_filename_utf8 (chooser, utf8_filename); - - g_free (utf8_filename); - - return retval; -} - -#undef gtk_file_chooser_select_filename - -gboolean -gtk_file_chooser_select_filename (GtkFileChooser *chooser, - const gchar *filename) -{ - gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL); - gboolean retval = gtk_file_chooser_select_filename_utf8 (chooser, utf8_filename); - - g_free (utf8_filename); - - return retval; -} - -#undef gtk_file_chooser_unselect_filename - -void -gtk_file_chooser_unselect_filename (GtkFileChooser *chooser, - const char *filename) -{ - gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL); - - gtk_file_chooser_unselect_filename_utf8 (chooser, utf8_filename); - g_free (utf8_filename); -} - -#undef gtk_file_chooser_get_filenames - -GSList * -gtk_file_chooser_get_filenames (GtkFileChooser *chooser) -{ - GSList *list = gtk_file_chooser_get_filenames_utf8 (chooser); - GSList *rover = list; - - while (rover) - { - gchar *tem = (gchar *) rover->data; - rover->data = g_locale_from_utf8 ((gchar *) rover->data, -1, NULL, NULL, NULL); - g_free (tem); - rover = rover->next; - } - - return list; -} - -#undef gtk_file_chooser_set_current_folder - -gboolean -gtk_file_chooser_set_current_folder (GtkFileChooser *chooser, - const gchar *filename) -{ - gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL); - gboolean retval = gtk_file_chooser_set_current_folder_utf8 (chooser, utf8_filename); - - g_free (utf8_filename); - - return retval; -} - -#undef gtk_file_chooser_get_current_folder - -gchar * -gtk_file_chooser_get_current_folder (GtkFileChooser *chooser) -{ - gchar *utf8_folder = gtk_file_chooser_get_current_folder_utf8 (chooser); - gchar *retval = g_locale_from_utf8 (utf8_folder, -1, NULL, NULL, NULL); - - g_free (utf8_folder); - - return retval; -} - -#undef gtk_file_chooser_get_preview_filename - -char * -gtk_file_chooser_get_preview_filename (GtkFileChooser *chooser) -{ - char *utf8_filename = gtk_file_chooser_get_preview_filename_utf8 (chooser); - char *retval = g_locale_from_utf8 (utf8_filename, -1, NULL, NULL, NULL); - - g_free (utf8_filename); - - return retval; -} - -#undef gtk_file_chooser_add_shortcut_folder - -gboolean -gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, - const char *folder, - GError **error) -{ - char *utf8_folder = g_locale_to_utf8 (folder, -1, NULL, NULL, NULL); - gboolean retval = - gtk_file_chooser_add_shortcut_folder_utf8 (chooser, utf8_folder, error); - - g_free (utf8_folder); - - return retval; -} - -#undef gtk_file_chooser_remove_shortcut_folder - -gboolean -gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, - const char *folder, - GError **error) -{ - char *utf8_folder = g_locale_to_utf8 (folder, -1, NULL, NULL, NULL); - gboolean retval = - gtk_file_chooser_remove_shortcut_folder_utf8 (chooser, utf8_folder, error); - - g_free (utf8_folder); - - return retval; -} - -#undef gtk_file_chooser_list_shortcut_folders - -GSList * -gtk_file_chooser_list_shortcut_folders (GtkFileChooser *chooser) -{ - GSList *list = gtk_file_chooser_list_shortcut_folders_utf8 (chooser); - GSList *rover = list; - - while (rover) - { - gchar *tem = (gchar *) rover->data; - rover->data = g_locale_from_utf8 ((gchar *) rover->data, -1, NULL, NULL, NULL); - g_free (tem); - rover = rover->next; - } - - return list; -} - -#endif - -#define __GTK_FILE_CHOOSER_C__ -#include "gtkaliasdef.c"