GFile

GFile

Synopsis




                    GFile;
                    GFileIface;
enum                GFileQueryInfoFlags;
enum                GFileCreateFlags;
enum                GFileCopyFlags;
enum                GFileMonitorFlags;
void                (*GFileProgressCallback)            (goffset current_num_bytes,
                                                         goffset total_num_bytes,
                                                         gpointer user_data);
gboolean            (*GFileReadMoreCallback)            (const char *file_contents,
                                                         goffset file_size,
                                                         gpointer callback_data);
GFile*              g_file_new_for_path                 (const char *path);
GFile*              g_file_new_for_uri                  (const char *uri);
GFile*              g_file_new_for_commandline_arg      (const char *arg);
GFile*              g_file_parse_name                   (const char *parse_name);
GFile*              g_file_dup                          (GFile *file);
guint               g_file_hash                         (gconstpointer file);
gboolean            g_file_equal                        (GFile *file1,
                                                         GFile *file2);
char*               g_file_get_basename                 (GFile *file);
char*               g_file_get_path                     (GFile *file);
char*               g_file_get_uri                      (GFile *file);
char*               g_file_get_parse_name               (GFile *file);
GFile*              g_file_get_parent                   (GFile *file);
GFile*              g_file_get_child                    (GFile *file,
                                                         const char *name);
GFile*              g_file_get_child_for_display_name   (GFile *file,
                                                         const char *display_name,
                                                         GError **error);
gboolean            g_file_contains_file                (GFile *parent,
                                                         GFile *descendant);
char*               g_file_get_relative_path            (GFile *parent,
                                                         GFile *descendant);
GFile*              g_file_resolve_relative_path        (GFile *file,
                                                         const char *relative_path);
gboolean            g_file_is_native                    (GFile *file);
gboolean            g_file_has_uri_scheme               (GFile *file,
                                                         const char *uri_scheme);
char*               g_file_get_uri_scheme               (GFile *file);
GFileInputStream*   g_file_read                         (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_read_async                   (GFile *file,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileInputStream*   g_file_read_finish                  (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileOutputStream*  g_file_append_to                    (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileOutputStream*  g_file_create                       (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileOutputStream*  g_file_replace                      (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_append_to_async              (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileOutputStream*  g_file_append_to_finish             (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
void                g_file_create_async                 (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileOutputStream*  g_file_create_finish                (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
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);
GFileOutputStream*  g_file_replace_finish               (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileInfo*          g_file_query_info                   (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_query_info_async             (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileInfo*          g_file_query_info_finish            (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileInfo*          g_file_query_filesystem_info        (GFile *file,
                                                         const char *attributes,
                                                         GCancellable *cancellable,
                                                         GError **error);
GVolume*            g_file_find_enclosing_volume        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileEnumerator*    g_file_enumerate_children           (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_enumerate_children_async     (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileEnumerator*    g_file_enumerate_children_finish    (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFile*              g_file_set_display_name             (GFile *file,
                                                         const char *display_name,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_set_display_name_async       (GFile *file,
                                                         const char *display_name,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFile*              g_file_set_display_name_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            g_file_delete                       (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_trash                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_copy                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);
gboolean            g_file_move                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);
gboolean            g_file_make_directory               (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_make_symbolic_link           (GFile *file,
                                                         const char *symlink_value,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileAttributeInfoList* g_file_query_settable_attributes
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileAttributeInfoList* g_file_query_writable_namespaces
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute                (GFile *file,
                                                         const char *attribute,
                                                         const GFileAttributeValue *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attributes_from_info     (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_set_attributes_async         (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_set_attributes_finish        (GFile *file,
                                                         GAsyncResult *result,
                                                         GFileInfo **info,
                                                         GError **error);
gboolean            g_file_set_attribute_string         (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_byte_string    (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_uint32         (GFile *file,
                                                         const char *attribute,
                                                         guint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_int32          (GFile *file,
                                                         const char *attribute,
                                                         gint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_uint64         (GFile *file,
                                                         const char *attribute,
                                                         guint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_int64          (GFile *file,
                                                         const char *attribute,
                                                         gint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_mount_for_location                (GFile *location,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_mount_for_location_finish         (GFile *location,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_mount_mountable              (GFile *file,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFile*              g_file_mount_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_unmount_mountable            (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_unmount_mountable_finish     (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_eject_mountable              (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_eject_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
GDirectoryMonitor*  g_file_monitor_directory            (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);
GFileMonitor*       g_file_monitor_file                 (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);
gboolean            g_file_load_contents                (GFile *file,
                                                         GCancellable *cancellable,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
void                g_file_load_contents_async          (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_load_contents_finish         (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
void                g_file_load_partial_contents_async  (GFile *file,
                                                         GCancellable *cancellable,
                                                         GFileReadMoreCallback read_more_callback,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_load_partial_contents_finish (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
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);
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);
gboolean            g_file_replace_contents_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         char **new_etag,
                                                         GError **error);


Object Hierarchy


  GInterface
   +----GFile

Prerequisites

GFile requires GObject.

Description

Details

GFile

typedef struct _GFile GFile;


GFileIface

typedef struct {
  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            (*contains_file)              (GFile         *parent,
						     GFile         *descendant);
  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) (void);
  void                (*_query_filesystem_info_finish) (void);
  
  GVolume *           (*find_enclosing_volume)(GFile              *file,
					       GCancellable       *cancellable,
					       GError            **error);
  void                (*find_enclosing_volume_async)(GFile              *file,
						     int                   io_priority,
						     GCancellable         *cancellable,
						     GAsyncReadyCallback   callback,
						     gpointer              user_data);
  GVolume *           (*find_enclosing_volume_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,
						   const GFileAttributeValue *value,
						   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)               (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) (void);
  void                (*_delete_file_finish) (void);
  
  gboolean            (*trash)              (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_trash_async) (void);
  void                (*_trash_finish) (void);
  
  gboolean            (*make_directory)     (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_make_directory_async) (void);
  void                (*_make_directory_finish) (void);
  
  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) (void);
  void                (*_copy_finish) (void);
  
  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,
						    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,
						    GCancellable         *cancellable,
						    GAsyncReadyCallback  callback,
						    gpointer             user_data);
  gboolean            (*unmount_mountable_finish)  (GFile               *file,
						    GAsyncResult        *result,
						    GError             **error);
  void                (*eject_mountable)           (GFile               *file,
						    GCancellable        *cancellable,
						    GAsyncReadyCallback  callback,
						    gpointer             user_data);
  gboolean            (*eject_mountable_finish)    (GFile               *file,
						    GAsyncResult        *result,
						    GError             **error);


  void     (*mount_for_location)        (GFile *location,
					 GMountOperation *mount_operation,
					 GCancellable *cancellable,
					 GAsyncReadyCallback callback,
					 gpointer user_data);
  gboolean (*mount_for_location_finish) (GFile *location,
					 GAsyncResult *result,
					 GError **error);
  
  GDirectoryMonitor* (*monitor_dir)         (GFile                  *file,
					     GFileMonitorFlags       flags,
					     GCancellable           *cancellable);

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


    /* Padding for future expansion */
  void (*_g_reserved1) (void);
  void (*_g_reserved2) (void);
  void (*_g_reserved3) (void);
  void (*_g_reserved4) (void);
  void (*_g_reserved5) (void);
  void (*_g_reserved6) (void);
  void (*_g_reserved7) (void);
  void (*_g_reserved8) (void);
  void (*_g_reserved9) (void);
  void (*_g_reserved10) (void);
  void (*_g_reserved11) (void);
  void (*_g_reserved12) (void);
  void (*_g_reserved13) (void);
  void (*_g_reserved14) (void);
  void (*_g_reserved15) (void);
  void (*_g_reserved16) (void);
  void (*_g_reserved17) (void);
  void (*_g_reserved18) (void);
  void (*_g_reserved19) (void);
  void (*_g_reserved20) (void);
} GFileIface;


enum GFileQueryInfoFlags

typedef enum {
  G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS = (1<<0)
} GFileQueryInfoFlags;


enum GFileCreateFlags

typedef enum  {
  G_FILE_CREATE_FLAGS_NONE = 0,
  G_FILE_CREATE_FLAGS_PRIVATE = (1<<0)
} GFileCreateFlags;


enum GFileCopyFlags

typedef enum {
  G_FILE_COPY_OVERWRITE = (1<<0),
  G_FILE_COPY_BACKUP = (1<<1),
  G_FILE_COPY_NOFOLLOW_SYMLINKS = (1<<2),
  G_FILE_COPY_ALL_METADATA = (1<<3)
} GFileCopyFlags;


enum GFileMonitorFlags

typedef enum  {
  G_FILE_MONITOR_FLAGS_NONE = 0,
  G_FILE_MONITOR_FLAGS_MONITOR_MOUNTS = (1<<0)
} GFileMonitorFlags;


GFileProgressCallback ()

void                (*GFileProgressCallback)            (goffset current_num_bytes,
                                                         goffset total_num_bytes,
                                                         gpointer user_data);

current_num_bytes :

total_num_bytes :

user_data :


GFileReadMoreCallback ()

gboolean            (*GFileReadMoreCallback)            (const char *file_contents,
                                                         goffset file_size,
                                                         gpointer callback_data);

file_contents :

file_size :

callback_data :

Returns :


g_file_new_for_path ()

GFile*              g_file_new_for_path                 (const char *path);

Constructs a GFile for given path. This operation never fails, but the returned object might not support any I/O operation if the path is malformed.

path :

a string containing a relative or absolute path.

Returns :

a new GFile for the given path.

g_file_new_for_uri ()

GFile*              g_file_new_for_uri                  (const char *uri);

This operation never fails, but the returned object might not support any I/O operation if the uri is malformed or if the uri type is not supported.

uri :

a string containing a URI.

Returns :

a GFile for the given uri.

g_file_new_for_commandline_arg ()

GFile*              g_file_new_for_commandline_arg      (const char *arg);

Attempts to generate a GFile with the given line from the command line argument.

arg :

a command line string.

Returns :

a new GFile.

g_file_parse_name ()

GFile*              g_file_parse_name                   (const char *parse_name);

Constructs a GFile with the given parse_name, looked up by GVfs. This operation never fails, but the returned object might not support any I/O operation if the parse_name cannot be parsed by GVfs.

parse_name :

a file name or path to be parsed.

Returns :

a new GFile.

g_file_dup ()

GFile*              g_file_dup                          (GFile *file);

file :

input GFile.

Returns :

GFile that is a duplicate of the given GFile, or NULL if given GFile is invalid.

g_file_hash ()

guint               g_file_hash                         (gconstpointer file);

file :

gconstpointer to a GFile.

Returns :

0 if file is not a GFile, otherwise a guint containing a hash of the GFile. This function is intended for easily hashing a GFile to add to a GHashTable or similar data structure.

g_file_equal ()

gboolean            g_file_equal                        (GFile *file1,
                                                         GFile *file2);

file1 :

the first GFile.

file2 :

the second GFile.

Returns :

TRUE if file1 and file2 are equal. FALSE if either is not a GFile.

g_file_get_basename ()

char*               g_file_get_basename                 (GFile *file);

file :

input GFile.

Returns :

string containing the GFile's base name, or NULL if given GFile is invalid. The returned string should be freed when no longer needed

g_file_get_path ()

char*               g_file_get_path                     (GFile *file);

file :

input GFile.

Returns :

string containing the GFile's path, or NULL if given GFile is invalid. The returned string should be freed when no longer needed

g_file_get_uri ()

char*               g_file_get_uri                      (GFile *file);

file :

input GFile.

Returns :

string to the GFile's Universal Resource Identifier (URI), or NULL if given GFile is invalid. The returned string should be freed when no longer needed

g_file_get_parse_name ()

char*               g_file_get_parse_name               (GFile *file);

file :

Returns :


g_file_get_parent ()

GFile*              g_file_get_parent                   (GFile *file);

file :

input GFile.

Returns :

a GFile structure to the parent of the given GFile. This function should return the parent directory of the given file. If the file represents the root directory of the file system, then NULL will be returned.

g_file_get_child ()

GFile*              g_file_get_child                    (GFile *file,
                                                         const char *name);

file :

input GFile.

name :

string containing the child's name.

Returns :

a GFile to a child specified by name or NULL if name is NULL, or the specified child doesn't exist.

g_file_get_child_for_display_name ()

GFile*              g_file_get_child_for_display_name   (GFile *file,
                                                         const char *display_name,
                                                         GError **error);

file :

input GFile.

display_name :

string to a possible child.

error :

GError.

Returns :

NULL if display_name is NULL, GFile to the specified child.

g_file_contains_file ()

gboolean            g_file_contains_file                (GFile *parent,
                                                         GFile *descendant);

parent :

input GFile.

descendant :

input GFile.

Returns :

FALSE if either the parent or descendant is invalid. TRUE if the descendent's parent is parent.

g_file_get_relative_path ()

char*               g_file_get_relative_path            (GFile *parent,
                                                         GFile *descendant);

parent :

input GFile.

descendant :

input GFile.

Returns :

string with the relative path from descendant to parent. The returned string should be freed when no longer needed

g_file_resolve_relative_path ()

GFile*              g_file_resolve_relative_path        (GFile *file,
                                                         const char *relative_path);

file :

input GFile.

relative_path :

a given relative path string.

Returns :

GFile to the resolved path. NULL if relative_path is NULL. or if file is invalid.

g_file_is_native ()

gboolean            g_file_is_native                    (GFile *file);

file :

input GFile.

Returns :

TRUE if file is native. TODO: Explain what "native" means.

g_file_has_uri_scheme ()

gboolean            g_file_has_uri_scheme               (GFile *file,
                                                         const char *uri_scheme);

file :

input GFile.

uri_scheme :

a string containing a URI scheme.

Returns :

TRUE if GFile's backend supports the given URI scheme, FALSE if URI scheme is NULL, not supported, or GFile is invalid.

g_file_get_uri_scheme ()

char*               g_file_get_uri_scheme               (GFile *file);

file :

input GFile.

Returns :

string to the URI scheme for the given GFile. RFC 3986 decodes the scheme as: URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] Popular schemes include "file", "http", "svn", etc. The returned string should be freed when no longer needed.

g_file_read ()

GFileInputStream*   g_file_read                         (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

Reads a whole file into a GFileInputStream. Fails returning NULL if given GFile points to a directory.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

GFile to read.

cancellable :

a GCancellable

error :

a GError.

Returns :

GFileInputStream or NULL.

g_file_read_async ()

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

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

Asynchronously reads file. For the synchronous version of this function, see g_file_read().

file :

input GFile.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_read_finish ()

GFileInputStream*   g_file_read_finish                  (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

a GAsyncResult.

Returns :

a GFileInputStream or NULL if there was an error.

g_file_append_to ()

GFileOutputStream*  g_file_append_to                    (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

flags :

a set of GFileCreateFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

Returns :

a GFileOutputStream.

g_file_create ()

GFileOutputStream*  g_file_create                       (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

flags :

a set of GFileCreateFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GFileOutputStream for the newly created file, or NULL on error.

g_file_replace ()

GFileOutputStream*  g_file_replace                      (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

etag :

an Entity Tag for the current GFile.

make_backup :

a gboolean.

flags :

a set of GFileCreateFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

Returns :

a GFileOutputStream or NULL on error. If make_backup is TRUE, this function will attempt to make a backup of the current file.

g_file_append_to_async ()

void                g_file_append_to_async              (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Readies a file for appending data asynchronously. For the synchronous version of this function, see g_file_append_to().

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

flags :

a set of GFileCreateFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_append_to_finish ()

GFileOutputStream*  g_file_append_to_finish             (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

GAsyncResult

error :

a GError.

Returns :

a valid GFileOutputStream or NULL upon error.

g_file_create_async ()

void                g_file_create_async                 (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Creates a new file asynchronously. For the synchronous version of this function, see g_file_create().

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

flags :

a set of GFileCreateFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_create_finish ()

GFileOutputStream*  g_file_create_finish                (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

a GAsyncResult.

Returns :

a GFileOutputStream.

g_file_replace_async ()

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

Replaces a file's contents. For the synchronous version of this function, see g_file_replace(). If make_backup is TRUE, this function will attempt to make a backup of the current file.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

etag :

an Entity Tag for the current GFile.

make_backup :

a gboolean.

flags :

a set of GFileCreateFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_replace_finish ()

GFileOutputStream*  g_file_replace_finish               (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes replacing the contents of the file started by g_file_replace_async().

file :

input GFile.

res :

error :

a GAsyncResult.

Returns :

a GFileOutputStream, or NULL if an error has occured.

g_file_query_info ()

GFileInfo*          g_file_query_info                   (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

attributes :

a string.

flags :

a set of GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GFileInfo for the given file, or NULL on error.

g_file_query_info_async ()

void                g_file_query_info_async             (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

attributes :

a string.

flags :

a set of GFileQueryInfoFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_query_info_finish ()

GFileInfo*          g_file_query_info_finish            (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

Finishes an asynchronous file info query. If the operation failed, returns NULL and set error appropriately if present.

file :

input GFile.

res :

error :

a GAsyncResult.

Returns :

GFileInfo for given file or NULL.

g_file_query_filesystem_info ()

GFileInfo*          g_file_query_filesystem_info        (GFile *file,
                                                         const char *attributes,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

attributes :

a string.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GFileInfo or NULl if there was an error.

g_file_find_enclosing_volume ()

GVolume*            g_file_find_enclosing_volume        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GVolume where the file is located.

g_file_enumerate_children ()

GFileEnumerator*    g_file_enumerate_children           (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

attributes :

a string.

flags :

GFileQueryInfoFlags field.

cancellable :

optional GCancellable object, NULL to ignore.

error :

GError for error reporting.

Returns :

NULL if cancelled or if GFile's backend doesn't support GFileEnumerator. Returns a GFileEnumerator if successful.

g_file_enumerate_children_async ()

void                g_file_enumerate_children_async     (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously enumerates the children of the given file.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

attributes :

a string.

flags :

a set of GFileQueryInfoFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_enumerate_children_finish ()

GFileEnumerator*    g_file_enumerate_children_finish    (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

a GAsyncResult.

error :

a GError.

Returns :

a GFileEnumerator or NULL if an error occurred.

g_file_set_display_name ()

GFile*              g_file_set_display_name             (GFile *file,
                                                         const char *display_name,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

display_name :

a string.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GFile, or NULL if there was an error. For the asynchronous version of this function, see g_file_set_display_name_async().

g_file_set_display_name_async ()

void                g_file_set_display_name_async       (GFile *file,
                                                         const char *display_name,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the display name for a given GFile. For the synchronous version of this function, see g_file_set_display_name().

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

display_name :

a string.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_set_display_name_finish ()

GFile*              g_file_set_display_name_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

a GAsyncResult.

Returns :

a GFile or NULL on error.

g_file_delete ()

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

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the file was deleted. FALSE otherwise.

g_file_trash ()

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

This function sends the object to the virtual "Trash" location. If the GFile interface does not have a corresponding "Trash" location, this function returns FALSE, and will set error appropriately.

file :

GFile to location to send to trash.

cancellable :

optional GCancellable object, NULL to ignore.

error :

GError for possible failures.

Returns :

TRUE on successful trash, FALSE otherwise.

g_file_copy ()

gboolean            g_file_copy                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);

List of possible errors resulting from g_file_copy(): source dest flags res - * * G_IO_ERROR_NOT_FOUND file - * ok file * 0 G_IO_ERROR_EXISTS file file overwr ok file dir overwr G_IO_ERROR_IS_DIRECTORY dir - * G_IO_ERROR_WOULD_RECURSE dir * 0 G_IO_ERROR_EXISTS dir dir overwr G_IO_ERROR_IS_DIRECTORY dir file overwr G_IO_ERROR_WOULD_RECURSE

source :

input GFile.

destination :

destination GFile

flags :

set of GFileCopyFlags

cancellable :

optional GCancellable object, NULL to ignore.

progress_callback :

function to callback with progress information

progress_callback_data :

userdata to pass to progress_callback

error :

GError to set on error

Returns :

TRUE on success, FALSE otherwise.

g_file_move ()

gboolean            g_file_move                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);

List of possible returns from g_file_move() with given source, destination, and flags:

source dest flags results in - * * G_IO_ERROR_NOT_FOUND file - * ok file * 0 G_IO_ERROR_EXISTS file file overwr ok file dir overwr G_IO_ERROR_IS_DIRECTORY

dir - * ok || G_IO_ERROR_WOULD_RECURSE dir * 0 G_IO_ERROR_EXISTS dir dir overwr G_IO_ERROR_IS_DIRECTORY dir file overwr ok || G_IO_ERROR_WOULD_RECURSE

source :

GFile* pointing to the source location.

destination :

GFile* pointing to the destination location.

flags :

GFileCopyFlags enum.

cancellable :

optional GCancellable object, NULL to ignore.

progress_callback :

GFileProgressCallback function for updates.

progress_callback_data :

gpointer to user data for the callback function.

error :

GError for returning error conditions.

Returns :

TRUE on successful move, FALSE otherwise.

g_file_make_directory ()

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

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE on successful creation, FALSE otherwise.

g_file_make_symbolic_link ()

gboolean            g_file_make_symbolic_link           (GFile *file,
                                                         const char *symlink_value,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

symlink_value :

a string with the name of the new symlink.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE on the creation of a new symlink, FALSE otherwise.

g_file_query_settable_attributes ()

GFileAttributeInfoList* g_file_query_settable_attributes
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

the type and full attribute name of all the attributes that the file can set. This doesn't mean setting it will always succeed though, you might get an access failure, or some specific file may not support a specific attribute.

g_file_query_writable_namespaces ()

GFileAttributeInfoList* g_file_query_writable_namespaces
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

a GFileAttributeInfoList of attribute namespaces where the user can create their own attribute names, such as extended attributes.

g_file_set_attribute ()

gboolean            g_file_set_attribute                (GFile *file,
                                                         const char *attribute,
                                                         const GFileAttributeValue *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

GFileAttributeValue

flags :

GFileQueryInfoFlags

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was correctly set, FALSE otherwise.

g_file_set_attributes_from_info ()

gboolean            g_file_set_attributes_from_info     (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

Tries to set all attributes in the GFileInfo on the target values, not stopping on the first error.

file :

input GFile.

info :

a GFileInfo.

flags :

GFileQueryInfoFlags

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if there was any error, and error will be set to the first error. Error on particular fields are flagged by setting the "status" field in the attribute value to G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING.

g_file_set_attributes_async ()

void                g_file_set_attributes_async         (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sets the attributes of file with info and flags. For the synchronous version of this function, see g_file_set_attributes().

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

info :

a GFileInfo.

flags :

a GFileQueryInfoFlags.

io_priority :

the io priority of the request. the io priority of the request.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_set_attributes_finish ()

gboolean            g_file_set_attributes_finish        (GFile *file,
                                                         GAsyncResult *result,
                                                         GFileInfo **info,
                                                         GError **error);

file :

input GFile.

result :

a GAsyncResult.

info :

a GFileInfo.

error :

a GError.

Returns :

TRUE if the attributes were set correctly, FALSE otherwise.

g_file_set_attribute_string ()

gboolean            g_file_set_attribute_string         (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

a string containing the attribute's value.

flags :

GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was successfully set to value in the file, FALSE otherwise.

g_file_set_attribute_byte_string ()

gboolean            g_file_set_attribute_byte_string    (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

attribute :

value :

flags :

cancellable :

error :

Returns :


g_file_set_attribute_uint32 ()

gboolean            g_file_set_attribute_uint32         (GFile *file,
                                                         const char *attribute,
                                                         guint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

a guint32 containing the attribute's new value.

flags :

a GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was successfully set to value in the file, FALSE otherwise.

g_file_set_attribute_int32 ()

gboolean            g_file_set_attribute_int32          (GFile *file,
                                                         const char *attribute,
                                                         gint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

a gint32 containing the attribute's new value.

flags :

a GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was successfully set to value in the file, FALSE otherwise.

g_file_set_attribute_uint64 ()

gboolean            g_file_set_attribute_uint64         (GFile *file,
                                                         const char *attribute,
                                                         guint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

a guint64 containing the attribute's new value.

flags :

a GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was successfully set to value in the file, FALSE otherwise.

g_file_set_attribute_int64 ()

gboolean            g_file_set_attribute_int64          (GFile *file,
                                                         const char *attribute,
                                                         gint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

a string containing the attribute's name.

value :

a guint64 containing the attribute's new value.

flags :

a GFileQueryInfoFlags.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if the attribute was successfully set to value in the file, FALSE otherwise.

g_mount_for_location ()

void                g_mount_for_location                (GFile *location,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Starts the mount_operation, mounting the volume at location. This operation is cancellable with cancellable. When the operation has completed, callback will be called with user data. To finish the operation, call g_mount_for_location_finish() with the GAsyncResult returned by the callback.

location :

input GFile.

mount_operation :

a GMountOperation.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_mount_for_location_finish ()

gboolean            g_mount_for_location_finish         (GFile *location,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes an Asynchronous mount operation.

location :

input GFile.

result :

a GAsyncResult.

error :

a GError.

Returns :

TRUE if the mount was finished successfully. If FALSE and error is present, it will be set appropriately.

g_file_mount_mountable ()

void                g_file_mount_mountable              (GFile *file,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Mounts a mountable file using mount_operation, if possible.

file :

input GFile.

mount_operation :

a GMountOperation.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_mount_mountable_finish ()

GFile*              g_file_mount_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);

file :

input GFile.

result :

a GAsyncResult.

error :

a GError.

Returns :

a GFile or NULL on error.

g_file_unmount_mountable ()

void                g_file_unmount_mountable            (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_unmount_mountable_finish ()

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

file :

input GFile.

result :

a GAsyncResult.

error :

a GError.

Returns :

TRUE if the operation finished successfully. FALSE otherwise.

g_file_eject_mountable ()

void                g_file_eject_mountable              (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_eject_mountable_finish ()

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

file :

input GFile.

result :

a GAsyncResult.

error :

a GError.

Returns :

TRUE if the file was ejected successfully. FALSE otherwise.

g_file_monitor_directory ()

GDirectoryMonitor*  g_file_monitor_directory            (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);

file :

input GFile.

flags :

a set of GFileMonitorFlags.

cancellable :

optional GCancellable object, NULL to ignore.

Returns :

a GDirectoryMonitor for the given file, or NULL on error.

g_file_monitor_file ()

GFileMonitor*       g_file_monitor_file                 (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);

file :

input GFile.

flags :

a set of GFileMonitorFlags.

cancellable :

optional GCancellable object, NULL to ignore.

Returns :

a GFileMonitor for the given file, or NULL on error.

g_file_load_contents ()

gboolean            g_file_load_contents                (GFile *file,
                                                         GCancellable *cancellable,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

contents :

length :

etag_out :

a pointer to the current entity tag for the document.

error :

a GError.

Returns :

TRUE if the file's contents were successfully loaded. FALSE if there were errors. The length of the loaded data will be put into length, the contents in contents.

g_file_load_contents_async ()

void                g_file_load_contents_async          (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Starts an asynchronous load of the file's contents. When the load operation has completed, callback will be called with userdata. To finish the operation, call g_file_load_contents_finish() with the GAsyncResult returned by the callback.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_load_contents_finish ()

gboolean            g_file_load_contents_finish         (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

Finishes an asynchronous load of the file's contents. The contents are placed in contents, and length is set to the size of the contents string. If etag_out is present, it will be set to the new entity tag for the file.

file :

input GFile.

res :

contents :

an array of strings.

length :

a pointer to a gsize.

etag_out :

a pointer to a string to get the new entity tag.

error :

a GAsyncResult.

Returns :

TRUE if the load was successful. If FALSE and error is present, it will be set appropriately.

g_file_load_partial_contents_async ()

void                g_file_load_partial_contents_async  (GFile *file,
                                                         GCancellable *cancellable,
                                                         GFileReadMoreCallback read_more_callback,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

cancellable :

optional GCancellable object, NULL to ignore.

read_more_callback :

a GFileReadMoreCallback.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_load_partial_contents_finish ()

gboolean            g_file_load_partial_contents_finish (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

file :

input GFile.

res :

contents :

a pointer to where the contents of the file will be placed.

length :

a pointer to the location where the content's length will be placed.

etag_out :

a pointer to the current entity tag for the document.

error :

a GAsyncResult.

Returns :

TRUE if the load was successful. If FALSE and error is present, it will be set appropriately.

g_file_replace_contents ()

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

Replaces the contents of file with contents of length. The old etag will be replaced with the new_etag. If make_backup is TRUE, this function will attempt to make a backup of file.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

file :

input GFile.

contents :

length :

a gsize.

etag :

the old entity tag for the document.

make_backup :

a gboolean.

flags :

a set of GFileCreateFlags.

new_etag :

a new entity tag for the document.

cancellable :

optional GCancellable object, NULL to ignore.

error :

a GError.

Returns :

TRUE if successful. If an error has occured, this function will return FALSE and set error appropriately if present.

g_file_replace_contents_async ()

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

Starts an asynchronous replacement of file with the given contents of length bytes. etag will replace the document's current entity tag.

When this operation has completed, callback will be called with user_user data, and the operation can be finalized with g_file_replace_contents_finish().

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an operation was partially finished when the operation was cancelled the partial result will be returned, without an error.

If make_backup is TRUE, this function will attempt to make a backup of file.

file :

input GFile.

contents :

string of contents to replace the file with.

length :

length of the contents string.

etag :

a new entity tag for the file.

make_backup :

a gboolean.

flags :

a set of GFileCreateFlags.

cancellable :

optional GCancellable object, NULL to ignore.

callback :

a GAsyncReadyCallback.

user_data :

a gpointer.

g_file_replace_contents_finish ()

gboolean            g_file_replace_contents_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         char **new_etag,
                                                         GError **error);

Finishes an asynchronous replace of the given file. This function will take ownership of the new_etag, if present.

file :

input GFile.

res :

new_etag :

a pointer to the new entity tag string for the contents of the file.

error :

a GAsyncResult.

Returns :

TRUE on success, FALSE on failure.