FM / gio

/usr/include/glib-2.0/gio

Name	Size	Mode	Actions
gaction.h	4610	0644	edit dl rm
gactiongroup.h	9167	0644	edit dl rm
gactiongroupexporter.h	1768	0644	edit dl rm
gactionmap.h	3996	0644	edit dl rm
gappinfo.h	19095	0644	edit dl rm
gapplication.h	14551	0644	edit dl rm
gapplicationcommandline.h	6168	0644	edit dl rm
gasyncinitable.h	4423	0644	edit dl rm
gasyncresult.h	2818	0644	edit dl rm
gbufferedinputstream.h	5229	0644	edit dl rm
gbufferedoutputstream.h	3334	0644	edit dl rm
gbytesicon.h	1652	0644	edit dl rm
gcancellable.h	4058	0644	edit dl rm
gcharsetconverter.h	2518	0644	edit dl rm
gcontenttype.h	2971	0644	edit dl rm
gconverter.h	2885	0644	edit dl rm
gconverterinputstream.h	3015	0644	edit dl rm
gconverteroutputstream.h	3054	0644	edit dl rm
gcredentials.h	3408	0644	edit dl rm
gdatagrambased.h	6661	0644	edit dl rm
gdatainputstream.h	11140	0644	edit dl rm
gdataoutputstream.h	4923	0644	edit dl rm
gdbusactiongroup.h	2739	0644	edit dl rm
gdbusaddress.h	2670	0644	edit dl rm
gdbusauthobserver.h	2130	0644	edit dl rm
gdbusconnection.h	39042	0644	edit dl rm
gdbuserror.h	4306	0644	edit dl rm
gdbusinterface.h	3069	0644	edit dl rm
gdbusinterfaceskeleton.h	6055	0644	edit dl rm
gdbusintrospection.h	12505	0644	edit dl rm
gdbusmenumodel.h	1730	0644	edit dl rm
gdbusmessage.h	11383	0644	edit dl rm
gdbusmethodinvocation.h	6886	0644	edit dl rm
gdbusnameowning.h	4877	0644	edit dl rm
gdbusnamewatching.h	4521	0644	edit dl rm
gdbusobject.h	2941	0644	edit dl rm
gdbusobjectmanager.h	4474	0644	edit dl rm
gdbusobjectmanagerclient.h	9800	0644	edit dl rm
gdbusobjectmanagerserver.h	4120	0644	edit dl rm
gdbusobjectproxy.h	2635	0644	edit dl rm
gdbusobjectskeleton.h	3957	0644	edit dl rm
gdbusproxy.h	12082	0644	edit dl rm
gdbusserver.h	2534	0644	edit dl rm
gdbusutils.h	2020	0644	edit dl rm
gdrive.h	14501	0644	edit dl rm
gdtlsclientconnection.h	3197	0644	edit dl rm
gdtlsconnection.h	12247	0644	edit dl rm
gdtlsserverconnection.h	2446	0644	edit dl rm
gemblem.h	2155	0644	edit dl rm
gemblemedicon.h	2788	0644	edit dl rm
gfile.h	80114	0644	edit dl rm
gfileattribute.h	2801	0644	edit dl rm
gfileenumerator.h	6393	0644	edit dl rm
gfileicon.h	1959	0644	edit dl rm
gfileinfo.h	44487	0644	edit dl rm
gfileinputstream.h	4656	0644	edit dl rm
gfileiostream.h	5041	0644	edit dl rm
gfilemonitor.h	3280	0644	edit dl rm
gfilenamecompleter.h	3090	0644	edit dl rm
gfileoutputstream.h	5338	0644	edit dl rm
gfilterinputstream.h	2832	0644	edit dl rm
gfilteroutputstream.h	2875	0644	edit dl rm
gicon.h	3435	0644	edit dl rm
ginetaddress.h	4528	0644	edit dl rm
ginetaddressmask.h	3118	0644	edit dl rm
ginetsocketaddress.h	3111	0644	edit dl rm
ginitable.h	2976	0644	edit dl rm
ginputstream.h	9188	0644	edit dl rm
gio-autocleanups.h	9066	0644	edit dl rm
gio.h	5683	0644	edit dl rm
gioenums.h	79564	0644	edit dl rm
gioenumtypes.h	12816	0644	edit dl rm
gioerror.h	1558	0644	edit dl rm
giomodule.h	8064	0644	edit dl rm
gioscheduler.h	1999	0644	edit dl rm
giostream.h	4862	0644	edit dl rm
giotypes.h	24680	0644	edit dl rm
glistmodel.h	2576	0644	edit dl rm
gliststore.h	4178	0644	edit dl rm
gloadableicon.h	3671	0644	edit dl rm
gmemoryinputstream.h	3434	0644	edit dl rm
gmemorymonitor.h	2140	0644	edit dl rm
gmemoryoutputstream.h	3933	0644	edit dl rm
gmenu.h	8940	0644	edit dl rm
gmenuexporter.h	1611	0644	edit dl rm
gmenumodel.h	14334	0644	edit dl rm
gmount.h	15791	0644	edit dl rm
gmountoperation.h	6765	0644	edit dl rm
gnativesocketaddress.h	2536	0644	edit dl rm
gnativevolumemonitor.h	2270	0644	edit dl rm
gnetworkaddress.h	2956	0644	edit dl rm
gnetworking.h	1957	0644	edit dl rm
gnetworkmonitor.h	4239	0644	edit dl rm
gnetworkservice.h	2755	0644	edit dl rm
gnotification.h	4898	0644	edit dl rm
goutputstream.h	15760	0644	edit dl rm
gpermission.h	5862	0644	edit dl rm
gpollableinputstream.h	3828	0644	edit dl rm
gpollableoutputstream.h	4918	0644	edit dl rm
gpollableutils.h	2134	0644	edit dl rm
gpowerprofilemonitor.h	2302	0644	edit dl rm
gpropertyaction.h	1994	0644	edit dl rm
gproxy.h	4067	0644	edit dl rm
gproxyaddress.h	3166	0644	edit dl rm
gproxyaddressenumerator.h	2939	0644	edit dl rm
gproxyresolver.h	3393	0644	edit dl rm
gremoteactiongroup.h	3635	0644	edit dl rm
gresolver.h	16852	0644	edit dl rm
gresource.h	4651	0644	edit dl rm
gseekable.h	3280	0644	edit dl rm
gsettings.h	21148	0644	edit dl rm
gsettingsbackend.h	8508	0644	edit dl rm
gsettingsschema.h	5933	0644	edit dl rm
gsimpleaction.h	2915	0644	edit dl rm
gsimpleactiongroup.h	4355	0644	edit dl rm
gsimpleasyncresult.h	7809	0644	edit dl rm
gsimpleiostream.h	1722	0644	edit dl rm
gsimplepermission.h	1686	0644	edit dl rm
gsimpleproxyresolver.h	3531	0644	edit dl rm
gsocket.h	16181	0644	edit dl rm
gsocketaddress.h	3086	0644	edit dl rm
gsocketaddressenumerator.h	3897	0644	edit dl rm
gsocketclient.h	11211	0644	edit dl rm
gsocketconnectable.h	2886	0644	edit dl rm
gsocketconnection.h	5056	0644	edit dl rm
gsocketcontrolmessage.h	4886	0644	edit dl rm
gsocketlistener.h	7680	0644	edit dl rm
gsocketservice.h	3619	0644	edit dl rm
gsrvtarget.h	1935	0644	edit dl rm
gsubprocess.h	8606	0644	edit dl rm
gsubprocesslauncher.h	6529	0644	edit dl rm
gtask.h	8638	0644	edit dl rm
gtcpconnection.h	2957	0644	edit dl rm
gtcpwrapperconnection.h	2973	0644	edit dl rm
gtestdbus.h	2303	0644	edit dl rm
gthemedicon.h	2643	0644	edit dl rm
gthreadedsocketservice.h	3665	0644	edit dl rm
gtlsbackend.h	4587	0644	edit dl rm
gtlscertificate.h	3816	0644	edit dl rm
gtlsclientconnection.h	3683	0644	edit dl rm
gtlsconnection.h	7771	0644	edit dl rm
gtlsdatabase.h	17271	0644	edit dl rm
gtlsfiledatabase.h	1909	0644	edit dl rm
gtlsinteraction.h	8333	0644	edit dl rm
gtlspassword.h	4818	0644	edit dl rm
gtlsserverconnection.h	2348	0644	edit dl rm
gvfs.h	6616	0644	edit dl rm
gvolume.h	11736	0644	edit dl rm
gvolumemonitor.h	5998	0644	edit dl rm
gzlibcompressor.h	2350	0644	edit dl rm
gzlibdecompressor.h	2212	0644	edit dl rm

Edit: /usr/include/glib-2.0/gio/gfile.h (80114B)

/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright (C) 2006-2007 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * 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, see <http://www.gnu.org/licenses/>.
 *
 * Author: Alexander Larsson <alexl@redhat.com>
 */

#ifndef __G_FILE_H__
#define __G_FILE_H__

#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
#error "Only <gio/gio.h> can be included directly."
#endif

#include <gio/giotypes.h>

G_BEGIN_DECLS

#define G_TYPE_FILE            (g_file_get_type ())
#define G_FILE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_FILE, GFile))
#define G_IS_FILE(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_FILE))
#define G_FILE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_FILE, GFileIface))

#if 0
/**
 * GFile:
 *
 * A handle to an object implementing the #GFileIface interface.
 * Generally stores a location within the file system. Handles do not
 * necessarily represent files or directories that currently exist.
 **/
typedef struct _GFile         		GFile; /* Dummy typedef */
#endif
typedef struct _GFileIface    		GFileIface;

/**
 * GFileIface:
 * @g_iface: The parent interface.
 * @dup: Duplicates a #GFile.
 * @hash: Creates a hash of a #GFile.
 * @equal: Checks equality of two given #GFiles.
 * @is_native: Checks to see if a file is native to the system.
 * @has_uri_scheme: Checks to see if a #GFile has a given URI scheme.
 * @get_uri_scheme: Gets the URI scheme for a #GFile.
 * @get_basename: Gets the basename for a given #GFile.
 * @get_path: Gets the current path within a #GFile.
 * @get_uri: Gets a URI for the path within a #GFile.
 * @get_parse_name: Gets the parsed name for the #GFile.
 * @get_parent: Gets the parent directory for the #GFile.
 * @prefix_matches: Checks whether a #GFile contains a specified file.
 * @get_relative_path: Gets the path for a #GFile relative to a given path.
 * @resolve_relative_path: Resolves a relative path for a #GFile to an absolute path.
 * @get_child_for_display_name: Gets the child #GFile for a given display name.
 * @enumerate_children: Gets a #GFileEnumerator with the children of a #GFile.
 * @enumerate_children_async: Asynchronously gets a #GFileEnumerator with the children of a #GFile.
 * @enumerate_children_finish: Finishes asynchronously enumerating the children.
 * @query_info: Gets the #GFileInfo for a #GFile.
 * @query_info_async: Asynchronously gets the #GFileInfo for a #GFile.
 * @query_info_finish: Finishes an asynchronous query info operation.
 * @query_filesystem_info: Gets a #GFileInfo for the file system #GFile is on.
 * @query_filesystem_info_async: Asynchronously gets a #GFileInfo for the file system #GFile is on.
 * @query_filesystem_info_finish: Finishes asynchronously getting the file system info.
 * @find_enclosing_mount: Gets a #GMount for the #GFile.
 * @find_enclosing_mount_async: Asynchronously gets the #GMount for a #GFile.
 * @find_enclosing_mount_finish: Finishes asynchronously getting the volume.
 * @set_display_name: Sets the display name for a #GFile.
 * @set_display_name_async: Asynchronously sets a #GFile's display name.
 * @set_display_name_finish: Finishes asynchronously setting a #GFile's display name.
 * @query_settable_attributes: Returns a list of #GFileAttributeInfos that can be set.
 * @_query_settable_attributes_async: Asynchronously gets a list of #GFileAttributeInfos that can be set.
 * @_query_settable_attributes_finish: Finishes asynchronously querying settable attributes.
 * @query_writable_namespaces: Returns a list of #GFileAttributeInfo namespaces that are writable.
 * @_query_writable_namespaces_async: Asynchronously gets a list of #GFileAttributeInfo namespaces that are writable.
 * @_query_writable_namespaces_finish: Finishes asynchronously querying the writable namespaces.
 * @set_attribute: Sets a #GFileAttributeInfo.
 * @set_attributes_from_info: Sets a #GFileAttributeInfo with information from a #GFileInfo.
 * @set_attributes_async: Asynchronously sets a file's attributes.
 * @set_attributes_finish: Finishes setting a file's attributes asynchronously.
 * @read_fn: Reads a file asynchronously.
 * @read_async: Asynchronously reads a file.
 * @read_finish: Finishes asynchronously reading a file.
 * @append_to: Writes to the end of a file.
 * @append_to_async: Asynchronously writes to the end of a file.
 * @append_to_finish: Finishes an asynchronous file append operation.
 * @create: Creates a new file.
 * @create_async: Asynchronously creates a file.
 * @create_finish: Finishes asynchronously creating a file.
 * @replace: Replaces the contents of a file.
 * @replace_async: Asynchronously replaces the contents of a file.
 * @replace_finish: Finishes asynchronously replacing a file.
 * @delete_file: Deletes a file.
 * @delete_file_async: Asynchronously deletes a file.
 * @delete_file_finish: Finishes an asynchronous delete.
 * @trash: Sends a #GFile to the Trash location.
 * @trash_async: Asynchronously sends a #GFile to the Trash location.
 * @trash_finish: Finishes an asynchronous file trashing operation.
 * @make_directory: Makes a directory.
 * @make_directory_async: Asynchronously makes a directory.
 * @make_directory_finish: Finishes making a directory asynchronously.
 * @make_symbolic_link: (nullable): Makes a symbolic link. %NULL if symbolic
 *    links are unsupported.
 * @_make_symbolic_link_async: Asynchronously makes a symbolic link
 * @_make_symbolic_link_finish: Finishes making a symbolic link asynchronously.
 * @copy: (nullable): Copies a file. %NULL if copying is unsupported, which will
 *     cause `GFile` to use a fallback copy method where it reads from the
 *     source and writes to the destination.
 * @copy_async: Asynchronously copies a file.
 * @copy_finish: Finishes an asynchronous copy operation.
 * @move: Moves a file.
 * @_move_async: Asynchronously moves a file.
 * @_move_finish: Finishes an asynchronous move operation.
 * @mount_mountable: Mounts a mountable object.
 * @mount_mountable_finish: Finishes a mounting operation.
 * @unmount_mountable: Unmounts a mountable object.
 * @unmount_mountable_finish: Finishes an unmount operation.
 * @eject_mountable: Ejects a mountable.
 * @eject_mountable_finish: Finishes an eject operation.
 * @mount_enclosing_volume: Mounts a specified location.
 * @mount_enclosing_volume_finish: Finishes mounting a specified location.
 * @monitor_dir: Creates a #GFileMonitor for the location.
 * @monitor_file: Creates a #GFileMonitor for the location.
 * @open_readwrite: Open file read/write. Since 2.22.
 * @open_readwrite_async: Asynchronously opens file read/write. Since 2.22.
 * @open_readwrite_finish: Finishes an asynchronous open read/write. Since 2.22.
 * @create_readwrite: Creates file read/write. Since 2.22.
 * @create_readwrite_async: Asynchronously creates file read/write. Since 2.22.
 * @create_readwrite_finish: Finishes an asynchronous creates read/write. Since 2.22.
 * @replace_readwrite: Replaces file read/write. Since 2.22.
 * @replace_readwrite_async: Asynchronously replaces file read/write. Since 2.22.
 * @replace_readwrite_finish: Finishes an asynchronous replace read/write. Since 2.22.
 * @start_mountable: Starts a mountable object. Since 2.22.
 * @start_mountable_finish: Finishes a start operation. Since 2.22.
 * @stop_mountable: Stops a mountable. Since 2.22.
 * @stop_mountable_finish: Finishes a stop operation. Since 2.22.
 * @supports_thread_contexts: a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22.
 * @unmount_mountable_with_operation: Unmounts a mountable object using a #GMountOperation. Since 2.22.
 * @unmount_mountable_with_operation_finish: Finishes an unmount operation using a #GMountOperation. Since 2.22.
 * @eject_mountable_with_operation: Ejects a mountable object using a #GMountOperation. Since 2.22.
 * @eject_mountable_with_operation_finish: Finishes an eject operation using a #GMountOperation. Since 2.22.
 * @poll_mountable: Polls a mountable object for media changes. Since 2.22.
 * @poll_mountable_finish: Finishes a poll operation for media changes. Since 2.22.
 * @measure_disk_usage: Recursively measures the disk usage of @file. Since 2.38
 * @measure_disk_usage_async: Asynchronously recursively measures the disk usage of @file. Since 2.38
 * @measure_disk_usage_finish: Finishes an asynchronous recursive measurement of the disk usage of @file. Since 2.38
 *
 * An interface for writing VFS file handles.
 **/
struct _GFileIface
{
  GTypeInterface g_iface;

/* Virtual Table */

GFile *             (* dup)                         (GFile         *file);
  guint               (* hash)                        (GFile         *file);
  gboolean            (* equal)                       (GFile         *file1,
                                                       GFile         *file2);
  gboolean            (* is_native)                   (GFile         *file);
  gboolean            (* has_uri_scheme)              (GFile         *file,
                                                       const char    *uri_scheme);
  char *              (* get_uri_scheme)              (GFile         *file);
  char *              (* get_basename)                (GFile         *file);
  char *              (* get_path)                    (GFile         *file);
  char *              (* get_uri)                     (GFile         *file);
  char *              (* get_parse_name)              (GFile         *file);
  GFile *             (* get_parent)                  (GFile         *file);
  gboolean            (* prefix_matches)              (GFile         *prefix,
                                                       GFile         *file);
  char *              (* get_relative_path)           (GFile         *parent,
                                                       GFile         *descendant);
  GFile *             (* resolve_relative_path)       (GFile        *file,
                                                       const char   *relative_path);
  GFile *             (* get_child_for_display_name)  (GFile        *file,
                                                       const char   *display_name,
                                                       GError      **error);

GFileEnumerator *   (* enumerate_children)          (GFile                *file,
                                                       const char           *attributes,
                                                       GFileQueryInfoFlags   flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* enumerate_children_async)    (GFile                *file,
                                                       const char           *attributes,
                                                       GFileQueryInfoFlags   flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileEnumerator *   (* enumerate_children_finish)   (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileInfo *         (* query_info)                  (GFile                *file,
                                                       const char           *attributes,
                                                       GFileQueryInfoFlags   flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* query_info_async)            (GFile                *file,
                                                       const char           *attributes,
                                                       GFileQueryInfoFlags   flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileInfo *         (* query_info_finish)           (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileInfo *         (* query_filesystem_info)       (GFile                *file,
                                                       const char           *attributes,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* query_filesystem_info_async) (GFile                *file,
                                                       const char           *attributes,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileInfo *         (* query_filesystem_info_finish)(GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GMount *            (* find_enclosing_mount)        (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* find_enclosing_mount_async)  (GFile                *file,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GMount *            (* find_enclosing_mount_finish) (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFile *             (* set_display_name)            (GFile                *file,
                                                       const char           *display_name,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* set_display_name_async)      (GFile                *file,
                                                       const char           *display_name,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFile *             (* set_display_name_finish)     (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileAttributeInfoList * (* query_settable_attributes)    (GFile          *file,
                                                             GCancellable   *cancellable,
                                                             GError        **error);
  void                (* _query_settable_attributes_async)  (void);
  void                (* _query_settable_attributes_finish) (void);

GFileAttributeInfoList * (* query_writable_namespaces)    (GFile          *file,
                                                             GCancellable   *cancellable,
                                                             GError        **error);
  void                (* _query_writable_namespaces_async)  (void);
  void                (* _query_writable_namespaces_finish) (void);

gboolean            (* set_attribute)               (GFile                *file,
                                                       const char           *attribute,
                                                       GFileAttributeType    type,
                                                       gpointer              value_p,
                                                       GFileQueryInfoFlags   flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  gboolean            (* set_attributes_from_info)    (GFile                *file,
                                                       GFileInfo            *info,
                                                       GFileQueryInfoFlags   flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* set_attributes_async)        (GFile                *file,
                                                       GFileInfo            *info,
                                                       GFileQueryInfoFlags   flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* set_attributes_finish)       (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GFileInfo           **info,
                                                       GError              **error);

GFileInputStream *  (* read_fn)                     (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* read_async)                  (GFile                *file,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileInputStream *  (* read_finish)                 (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileOutputStream * (* append_to)                   (GFile                *file,
                                                       GFileCreateFlags      flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* append_to_async)             (GFile                *file,
                                                       GFileCreateFlags      flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileOutputStream * (* append_to_finish)            (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileOutputStream * (* create)                      (GFile                *file,
                                                       GFileCreateFlags      flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* create_async)                (GFile                *file,
                                                       GFileCreateFlags      flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileOutputStream * (* create_finish)               (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

GFileOutputStream * (* replace)                     (GFile                *file,
                                                       const char           *etag,
                                                       gboolean              make_backup,
                                                       GFileCreateFlags      flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* replace_async)               (GFile                *file,
                                                       const char           *etag,
                                                       gboolean              make_backup,
                                                       GFileCreateFlags      flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileOutputStream * (* replace_finish)              (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

gboolean            (* delete_file)                 (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* delete_file_async)           (GFile                *file,
						       int                   io_priority,
						       GCancellable         *cancellable,
						       GAsyncReadyCallback   callback,
						       gpointer              user_data);
  gboolean            (* delete_file_finish)          (GFile                *file,
						       GAsyncResult         *result,
						       GError              **error);

gboolean            (* trash)                       (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* trash_async)                 (GFile                *file,
						       int                   io_priority,
						       GCancellable         *cancellable,
						       GAsyncReadyCallback   callback,
						       gpointer              user_data);
  gboolean            (* trash_finish)                (GFile                *file,
						       GAsyncResult         *result,
						       GError              **error);

gboolean            (* make_directory)              (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* make_directory_async)        (GFile                *file,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* make_directory_finish)       (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

gboolean            (* make_symbolic_link)          (GFile                *file,
                                                       const char           *symlink_value,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* _make_symbolic_link_async)   (void);
  void                (* _make_symbolic_link_finish)  (void);

gboolean            (* copy)                        (GFile                *source,
                                                       GFile                *destination,
                                                       GFileCopyFlags        flags,
                                                       GCancellable         *cancellable,
                                                       GFileProgressCallback progress_callback,
                                                       gpointer              progress_callback_data,
                                                       GError              **error);
  void                (* copy_async)                  (GFile                *source,
                                                       GFile                *destination,
                                                       GFileCopyFlags        flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GFileProgressCallback progress_callback,
                                                       gpointer              progress_callback_data,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* copy_finish)                 (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

gboolean            (* move)                        (GFile                *source,
                                                       GFile                *destination,
                                                       GFileCopyFlags        flags,
                                                       GCancellable         *cancellable,
                                                       GFileProgressCallback progress_callback,
                                                       gpointer              progress_callback_data,
                                                       GError              **error);
  void                (* _move_async)                 (void);
  void                (* _move_finish)                (void);

void                (* mount_mountable)             (GFile                *file,
                                                       GMountMountFlags      flags,
                                                       GMountOperation      *mount_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFile *             (* mount_mountable_finish)      (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* unmount_mountable)           (GFile                *file,
                                                       GMountUnmountFlags    flags,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* unmount_mountable_finish)    (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* eject_mountable)             (GFile                *file,
                                                       GMountUnmountFlags    flags,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* eject_mountable_finish)      (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* mount_enclosing_volume)      (GFile                *location,
                                                       GMountMountFlags      flags,
                                                       GMountOperation      *mount_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean         (* mount_enclosing_volume_finish)  (GFile                *location,
                                                       GAsyncResult         *result,
                                                       GError              **error);

GFileMonitor *      (* monitor_dir)                 (GFile                *file,
                                                       GFileMonitorFlags     flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  GFileMonitor *      (* monitor_file)                (GFile                *file,
                                                       GFileMonitorFlags     flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);

GFileIOStream *     (* open_readwrite)              (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* open_readwrite_async)        (GFile                *file,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileIOStream *     (* open_readwrite_finish)       (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);
  GFileIOStream *     (* create_readwrite)            (GFile                *file,
						       GFileCreateFlags      flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* create_readwrite_async)      (GFile                *file,
						       GFileCreateFlags      flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileIOStream *     (* create_readwrite_finish)      (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);
  GFileIOStream *     (* replace_readwrite)           (GFile                *file,
                                                       const char           *etag,
                                                       gboolean              make_backup,
                                                       GFileCreateFlags      flags,
                                                       GCancellable         *cancellable,
                                                       GError              **error);
  void                (* replace_readwrite_async)     (GFile                *file,
                                                       const char           *etag,
                                                       gboolean              make_backup,
                                                       GFileCreateFlags      flags,
                                                       int                   io_priority,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  GFileIOStream *     (* replace_readwrite_finish)    (GFile                *file,
                                                       GAsyncResult         *res,
                                                       GError              **error);

void                (* start_mountable)             (GFile                *file,
                                                       GDriveStartFlags      flags,
                                                       GMountOperation      *start_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* start_mountable_finish)      (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* stop_mountable)              (GFile                *file,
                                                       GMountUnmountFlags    flags,
                                                       GMountOperation      *mount_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* stop_mountable_finish)       (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

gboolean            supports_thread_contexts;

void                (* unmount_mountable_with_operation) (GFile           *file,
                                                       GMountUnmountFlags    flags,
                                                       GMountOperation      *mount_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* unmount_mountable_with_operation_finish) (GFile    *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* eject_mountable_with_operation) (GFile             *file,
                                                       GMountUnmountFlags    flags,
                                                       GMountOperation      *mount_operation,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* eject_mountable_with_operation_finish) (GFile      *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

void                (* poll_mountable)              (GFile                *file,
                                                       GCancellable         *cancellable,
                                                       GAsyncReadyCallback   callback,
                                                       gpointer              user_data);
  gboolean            (* poll_mountable_finish)       (GFile                *file,
                                                       GAsyncResult         *result,
                                                       GError              **error);

gboolean            (* measure_disk_usage)          (GFile                         *file,
                                                       GFileMeasureFlags              flags,
                                                       GCancellable                  *cancellable,
                                                       GFileMeasureProgressCallback   progress_callback,
                                                       gpointer                       progress_data,
                                                       guint64                       *disk_usage,
                                                       guint64                       *num_dirs,
                                                       guint64                       *num_files,
                                                       GError                       **error);
  void                (* measure_disk_usage_async)    (GFile                         *file,
                                                       GFileMeasureFlags              flags,
                                                       gint                           io_priority,
                                                       GCancellable                  *cancellable,
                                                       GFileMeasureProgressCallback   progress_callback,
                                                       gpointer                       progress_data,
                                                       GAsyncReadyCallback            callback,
                                                       gpointer                       user_data);
  gboolean            (* measure_disk_usage_finish)   (GFile                         *file,
                                                       GAsyncResult                  *result,
                                                       guint64                       *disk_usage,
                                                       guint64                       *num_dirs,
                                                       guint64                       *num_files,
                                                       GError                       **error);
};

GLIB_AVAILABLE_IN_ALL
GType                   g_file_get_type                   (void) G_GNUC_CONST;

GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_new_for_path               (const char                 *path);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_new_for_uri                (const char                 *uri);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_new_for_commandline_arg    (const char                 *arg);
GLIB_AVAILABLE_IN_2_36
GFile *                 g_file_new_for_commandline_arg_and_cwd (const gchar           *arg,
                                                                const gchar           *cwd);
GLIB_AVAILABLE_IN_2_32
GFile *                 g_file_new_tmp                    (const char                 *tmpl,
                                                           GFileIOStream             **iostream,
                                                           GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_parse_name                 (const char                 *parse_name);
GLIB_AVAILABLE_IN_2_56
GFile *                 g_file_new_build_filename         (const gchar                *first_element,
                                                           ...) G_GNUC_NULL_TERMINATED;
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_dup                        (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
guint                   g_file_hash                       (gconstpointer               file);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_equal                      (GFile                      *file1,
							   GFile                      *file2);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_basename               (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_path                   (GFile                      *file);
GLIB_AVAILABLE_IN_2_56
const char *            g_file_peek_path                  (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_uri                    (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_parse_name             (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_get_parent                 (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_has_parent                 (GFile                      *file,
                                                           GFile                      *parent);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_get_child                  (GFile                      *file,
							   const char                 *name);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_get_child_for_display_name (GFile                      *file,
							   const char                 *display_name,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_has_prefix                 (GFile                      *file,
							   GFile                      *prefix);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_relative_path          (GFile                      *parent,
							   GFile                      *descendant);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_resolve_relative_path      (GFile                      *file,
							   const char                 *relative_path);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_is_native                  (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_has_uri_scheme             (GFile                      *file,
							   const char                 *uri_scheme);
GLIB_AVAILABLE_IN_ALL
char *                  g_file_get_uri_scheme             (GFile                      *file);
GLIB_AVAILABLE_IN_ALL
GFileInputStream *      g_file_read                       (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_read_async                 (GFile                      *file,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileInputStream *      g_file_read_finish                (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_append_to                  (GFile                      *file,
							   GFileCreateFlags             flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_create                     (GFile                      *file,
							   GFileCreateFlags             flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_replace                    (GFile                      *file,
							   const char                 *etag,
							   gboolean                    make_backup,
							   GFileCreateFlags            flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_append_to_async            (GFile                      *file,
							   GFileCreateFlags            flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_append_to_finish           (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_create_async               (GFile                      *file,
							   GFileCreateFlags            flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_create_finish              (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_replace_async              (GFile                      *file,
							   const char                 *etag,
							   gboolean                    make_backup,
							   GFileCreateFlags            flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileOutputStream *     g_file_replace_finish             (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_open_readwrite             (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_open_readwrite_async       (GFile                      *file,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_open_readwrite_finish      (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_create_readwrite           (GFile                      *file,
							   GFileCreateFlags            flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_create_readwrite_async     (GFile                      *file,
							   GFileCreateFlags            flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_create_readwrite_finish    (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_replace_readwrite          (GFile                      *file,
							   const char                 *etag,
							   gboolean                    make_backup,
							   GFileCreateFlags            flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_replace_readwrite_async    (GFile                      *file,
							   const char                 *etag,
							   gboolean                    make_backup,
							   GFileCreateFlags            flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileIOStream *         g_file_replace_readwrite_finish   (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_query_exists               (GFile                      *file,
							   GCancellable               *cancellable);
GLIB_AVAILABLE_IN_ALL
GFileType               g_file_query_file_type            (GFile                      *file,
                                                           GFileQueryInfoFlags         flags,
                                                           GCancellable               *cancellable);
GLIB_AVAILABLE_IN_ALL
GFileInfo *             g_file_query_info                 (GFile                      *file,
							   const char                 *attributes,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_query_info_async           (GFile                      *file,
							   const char                 *attributes,
							   GFileQueryInfoFlags         flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileInfo *             g_file_query_info_finish          (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileInfo *             g_file_query_filesystem_info      (GFile                      *file,
							   const char                 *attributes,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_query_filesystem_info_async (GFile                      *file,
							   const char                 *attributes,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileInfo *             g_file_query_filesystem_info_finish (GFile                      *file,
                                                           GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GMount *                g_file_find_enclosing_mount       (GFile                      *file,
                                                           GCancellable               *cancellable,
                                                           GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_find_enclosing_mount_async (GFile                      *file,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GMount *                g_file_find_enclosing_mount_finish (GFile                     *file,
							    GAsyncResult              *res,
							    GError                   **error);
GLIB_AVAILABLE_IN_ALL
GFileEnumerator *       g_file_enumerate_children         (GFile                      *file,
							   const char                 *attributes,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_enumerate_children_async   (GFile                      *file,
							   const char                 *attributes,
							   GFileQueryInfoFlags         flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFileEnumerator *       g_file_enumerate_children_finish  (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_set_display_name           (GFile                      *file,
							   const char                 *display_name,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_set_display_name_async     (GFile                      *file,
							   const char                 *display_name,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_set_display_name_finish    (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_delete                     (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);

GLIB_AVAILABLE_IN_2_34
void                    g_file_delete_async               (GFile                      *file,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);

GLIB_AVAILABLE_IN_2_34
gboolean                g_file_delete_finish              (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);

GLIB_AVAILABLE_IN_ALL
gboolean                g_file_trash                      (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);

GLIB_AVAILABLE_IN_2_38
void                    g_file_trash_async                (GFile                      *file,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);

GLIB_AVAILABLE_IN_2_38
gboolean                g_file_trash_finish               (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);

GLIB_AVAILABLE_IN_ALL
gboolean                g_file_copy                       (GFile                      *source,
							   GFile                      *destination,
							   GFileCopyFlags              flags,
							   GCancellable               *cancellable,
							   GFileProgressCallback       progress_callback,
							   gpointer                    progress_callback_data,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_copy_async                 (GFile                      *source,
							   GFile                      *destination,
							   GFileCopyFlags              flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GFileProgressCallback       progress_callback,
							   gpointer                    progress_callback_data,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_copy_finish                (GFile                      *file,
							   GAsyncResult               *res,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_move                       (GFile                      *source,
							   GFile                      *destination,
							   GFileCopyFlags              flags,
							   GCancellable               *cancellable,
							   GFileProgressCallback       progress_callback,
							   gpointer                    progress_callback_data,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_make_directory             (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_2_38
void                    g_file_make_directory_async       (GFile                      *file,
                                                           int                         io_priority,
                                                           GCancellable               *cancellable,
                                                           GAsyncReadyCallback         callback,
                                                           gpointer                    user_data);
GLIB_AVAILABLE_IN_2_38
gboolean                g_file_make_directory_finish      (GFile                      *file,
                                                           GAsyncResult               *result,
                                                           GError                    **error);

GLIB_AVAILABLE_IN_ALL
gboolean                g_file_make_directory_with_parents (GFile                     *file,
		                                           GCancellable               *cancellable,
		                                           GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_make_symbolic_link         (GFile                      *file,
							   const char                 *symlink_value,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileAttributeInfoList *g_file_query_settable_attributes  (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
GFileAttributeInfoList *g_file_query_writable_namespaces  (GFile                      *file,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute              (GFile                      *file,
							   const char                 *attribute,
							   GFileAttributeType          type,
							   gpointer                    value_p,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attributes_from_info   (GFile                      *file,
							   GFileInfo                  *info,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_set_attributes_async       (GFile                      *file,
							   GFileInfo                  *info,
							   GFileQueryInfoFlags         flags,
							   int                         io_priority,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attributes_finish      (GFile                      *file,
							   GAsyncResult               *result,
							   GFileInfo                 **info,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_string       (GFile                      *file,
							   const char                 *attribute,
							   const char                 *value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_byte_string  (GFile                      *file,
							   const char                 *attribute,
							   const char                 *value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_uint32       (GFile                      *file,
							   const char                 *attribute,
							   guint32                     value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_int32        (GFile                      *file,
							   const char                 *attribute,
							   gint32                      value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_uint64       (GFile                      *file,
							   const char                 *attribute,
							   guint64                     value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_set_attribute_int64        (GFile                      *file,
							   const char                 *attribute,
							   gint64                      value,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_mount_enclosing_volume     (GFile                      *location,
							   GMountMountFlags            flags,
							   GMountOperation            *mount_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_mount_enclosing_volume_finish (GFile                      *location,
							   GAsyncResult               *result,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_mount_mountable            (GFile                      *file,
							   GMountMountFlags            flags,
							   GMountOperation            *mount_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
GFile *                 g_file_mount_mountable_finish     (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);
GLIB_DEPRECATED_FOR(g_file_unmount_mountable_with_operation)
void                    g_file_unmount_mountable          (GFile                      *file,
                                                           GMountUnmountFlags          flags,
                                                           GCancellable               *cancellable,
                                                           GAsyncReadyCallback         callback,
                                                           gpointer                    user_data);

GLIB_DEPRECATED_FOR(g_file_unmount_mountable_with_operation_finish)
gboolean                g_file_unmount_mountable_finish   (GFile                      *file,
                                                           GAsyncResult               *result,
                                                           GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_unmount_mountable_with_operation (GFile                *file,
							   GMountUnmountFlags          flags,
							   GMountOperation            *mount_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_unmount_mountable_with_operation_finish (GFile         *file,
							   GAsyncResult               *result,
							   GError                    **error);
GLIB_DEPRECATED_FOR(g_file_eject_mountable_with_operation)
void                    g_file_eject_mountable            (GFile                      *file,
                                                           GMountUnmountFlags          flags,
                                                           GCancellable               *cancellable,
                                                           GAsyncReadyCallback         callback,
                                                           gpointer                    user_data);

GLIB_DEPRECATED_FOR(g_file_eject_mountable_with_operation_finish)
gboolean                g_file_eject_mountable_finish     (GFile                      *file,
                                                           GAsyncResult               *result,
                                                           GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_eject_mountable_with_operation (GFile                  *file,
							   GMountUnmountFlags          flags,
							   GMountOperation            *mount_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_eject_mountable_with_operation_finish (GFile           *file,
							   GAsyncResult               *result,
							   GError                    **error);

GLIB_AVAILABLE_IN_2_68
char *			g_file_build_attribute_list_for_copy (GFile                   *file,
							   GFileCopyFlags              flags,
							   GCancellable               *cancellable,
							   GError                    **error);

GLIB_AVAILABLE_IN_ALL
gboolean                g_file_copy_attributes            (GFile                      *source,
							   GFile                      *destination,
							   GFileCopyFlags              flags,
							   GCancellable               *cancellable,
							   GError                    **error);

GLIB_AVAILABLE_IN_ALL
GFileMonitor*           g_file_monitor_directory          (GFile                  *file,
							   GFileMonitorFlags       flags,
							   GCancellable           *cancellable,
							   GError                **error);
GLIB_AVAILABLE_IN_ALL
GFileMonitor*           g_file_monitor_file               (GFile                  *file,
							   GFileMonitorFlags       flags,
							   GCancellable           *cancellable,
							   GError                **error);
GLIB_AVAILABLE_IN_ALL
GFileMonitor*           g_file_monitor                    (GFile                  *file,
							   GFileMonitorFlags       flags,
							   GCancellable           *cancellable,
							   GError                **error);

GLIB_AVAILABLE_IN_2_38
gboolean                g_file_measure_disk_usage         (GFile                         *file,
                                                           GFileMeasureFlags              flags,
                                                           GCancellable                  *cancellable,
                                                           GFileMeasureProgressCallback   progress_callback,
                                                           gpointer                       progress_data,
                                                           guint64                       *disk_usage,
                                                           guint64                       *num_dirs,
                                                           guint64                       *num_files,
                                                           GError                       **error);

GLIB_AVAILABLE_IN_2_38
void                    g_file_measure_disk_usage_async   (GFile                         *file,
                                                           GFileMeasureFlags              flags,
                                                           gint                           io_priority,
                                                           GCancellable                  *cancellable,
                                                           GFileMeasureProgressCallback   progress_callback,
                                                           gpointer                       progress_data,
                                                           GAsyncReadyCallback            callback,
                                                           gpointer                       user_data);

GLIB_AVAILABLE_IN_2_38
gboolean                g_file_measure_disk_usage_finish  (GFile                         *file,
                                                           GAsyncResult                  *result,
                                                           guint64                       *disk_usage,
                                                           guint64                       *num_dirs,
                                                           guint64                       *num_files,
                                                           GError                       **error);

GLIB_AVAILABLE_IN_ALL
void                    g_file_start_mountable            (GFile                      *file,
							   GDriveStartFlags            flags,
							   GMountOperation            *start_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_start_mountable_finish     (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);
GLIB_AVAILABLE_IN_ALL
void                    g_file_stop_mountable             (GFile                      *file,
							   GMountUnmountFlags          flags,
                                                           GMountOperation            *mount_operation,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_stop_mountable_finish      (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);

GLIB_AVAILABLE_IN_ALL
void                    g_file_poll_mountable             (GFile                      *file,
							   GCancellable               *cancellable,
							   GAsyncReadyCallback         callback,
							   gpointer                    user_data);
GLIB_AVAILABLE_IN_ALL
gboolean                g_file_poll_mountable_finish      (GFile                      *file,
							   GAsyncResult               *result,
							   GError                    **error);

/* Utilities */

GLIB_AVAILABLE_IN_ALL
GAppInfo *g_file_query_default_handler       (GFile                  *file,
					      GCancellable           *cancellable,
					      GError                **error);
GLIB_AVAILABLE_IN_2_60
void      g_file_query_default_handler_async (GFile                  *file,
                                              int                     io_priority,
                                              GCancellable           *cancellable,
                                              GAsyncReadyCallback     callback,
                                              gpointer                user_data);
GLIB_AVAILABLE_IN_2_60
GAppInfo *g_file_query_default_handler_finish (GFile                 *file,
                                               GAsyncResult          *result,
                                               GError               **error);

GLIB_AVAILABLE_IN_ALL
gboolean g_file_load_contents                (GFile                  *file,
					      GCancellable           *cancellable,
					      char                  **contents,
					      gsize                  *length,
					      char                  **etag_out,
					      GError                **error);
GLIB_AVAILABLE_IN_ALL
void     g_file_load_contents_async          (GFile                  *file,
					      GCancellable           *cancellable,
					      GAsyncReadyCallback     callback,
					      gpointer                user_data);
GLIB_AVAILABLE_IN_ALL
gboolean g_file_load_contents_finish         (GFile                  *file,
					      GAsyncResult           *res,
					      char                  **contents,
					      gsize                  *length,
					      char                  **etag_out,
					      GError                **error);
GLIB_AVAILABLE_IN_ALL
void     g_file_load_partial_contents_async  (GFile                  *file,
					      GCancellable           *cancellable,
					      GFileReadMoreCallback   read_more_callback,
					      GAsyncReadyCallback     callback,
					      gpointer                user_data);
GLIB_AVAILABLE_IN_ALL
gboolean g_file_load_partial_contents_finish (GFile                  *file,
					      GAsyncResult           *res,
					      char                  **contents,
					      gsize                  *length,
					      char                  **etag_out,
					      GError                **error);
GLIB_AVAILABLE_IN_ALL
gboolean g_file_replace_contents             (GFile                  *file,
					      const char             *contents,
					      gsize                   length,
					      const char             *etag,
					      gboolean                make_backup,
					      GFileCreateFlags        flags,
					      char                  **new_etag,
					      GCancellable           *cancellable,
					      GError                **error);
GLIB_AVAILABLE_IN_ALL
void     g_file_replace_contents_async       (GFile                  *file,
					      const char             *contents,
					      gsize                   length,
					      const char             *etag,
					      gboolean                make_backup,
					      GFileCreateFlags        flags,
					      GCancellable           *cancellable,
					      GAsyncReadyCallback     callback,
					      gpointer                user_data);
GLIB_AVAILABLE_IN_2_40
void     g_file_replace_contents_bytes_async (GFile                  *file,
					      GBytes                 *contents,
					      const char             *etag,
					      gboolean                make_backup,
					      GFileCreateFlags        flags,
					      GCancellable           *cancellable,
					      GAsyncReadyCallback     callback,
					      gpointer                user_data);
GLIB_AVAILABLE_IN_ALL
gboolean g_file_replace_contents_finish      (GFile                  *file,
					      GAsyncResult           *res,
					      char                  **new_etag,
					      GError                **error);

GLIB_AVAILABLE_IN_ALL
gboolean g_file_supports_thread_contexts     (GFile                  *file);

GLIB_AVAILABLE_IN_2_56
GBytes  *g_file_load_bytes                   (GFile                  *file,
                                              GCancellable           *cancellable,
                                              gchar                 **etag_out,
                                              GError                **error);
GLIB_AVAILABLE_IN_2_56
void     g_file_load_bytes_async             (GFile                  *file,
                                              GCancellable           *cancellable,
                                              GAsyncReadyCallback     callback,
                                              gpointer                user_data);
GLIB_AVAILABLE_IN_2_56
GBytes  *g_file_load_bytes_finish            (GFile                  *file,
                                              GAsyncResult           *result,
                                              gchar                 **etag_out,
                                              GError                **error);

G_END_DECLS

#endif /* __G_FILE_H__ */

cmd: