• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* GIO - GLib Input, Output and Streaming Library
2  *
3  * Copyright (C) 2006-2007 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Author: Alexander Larsson <alexl@redhat.com>
21  */
22 
23 #if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
24 #error "Only <gio/gio.h> can be included directly."
25 #endif
26 
27 #ifndef __G_FILE_H__
28 #define __G_FILE_H__
29 
30 #include <gio/giotypes.h>
31 
32 G_BEGIN_DECLS
33 
34 #define G_TYPE_FILE            (g_file_get_type ())
35 #define G_FILE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_FILE, GFile))
36 #define G_IS_FILE(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_FILE))
37 #define G_FILE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_FILE, GFileIface))
38 
39 #if 0
40 /**
41  * GFile:
42  *
43  * A handle to an object implementing the #GFileIface interface.
44  * Generally stores a location within the file system. Handles do not
45  * necessarily represent files or directories that currently exist.
46  **/
47 typedef struct _GFile         		GFile; /* Dummy typedef */
48 #endif
49 typedef struct _GFileIface    		GFileIface;
50 
51 
52 /**
53  * GFileIface:
54  * @g_iface: The parent interface.
55  * @dup: Duplicates a #GFile.
56  * @hash: Creates a hash of a #GFile.
57  * @equal: Checks equality of two given #GFile<!-- -->s.
58  * @is_native: Checks to see if a file is native to the system.
59  * @has_uri_scheme: Checks to see if a #GFile has a given URI scheme.
60  * @get_uri_scheme: Gets the URI scheme for a #GFile.
61  * @get_basename: Gets the basename for a given #GFile.
62  * @get_path: Gets the current path within a #GFile.
63  * @get_uri: Gets a URI for the path within a #GFile.
64  * @get_parse_name: Gets the parsed name for the #GFile.
65  * @get_parent: Gets the parent directory for the #GFile.
66  * @prefix_matches: Checks whether a #GFile contains a specified file.
67  * @get_relative_path: Gets the path for a #GFile relative to a given path.
68  * @resolve_relative_path: Resolves a relative path for a #GFile to an absolute path.
69  * @get_child_for_display_name: Gets the child #GFile for a given display name.
70  * @enumerate_children: Gets a #GFileEnumerator with the children of a #GFile.
71  * @enumerate_children_async: Asynchronously gets a #GFileEnumerator with the children of a #GFile.
72  * @enumerate_children_finish: Finishes asynchronously enumerating the children.
73  * @query_info: Gets the #GFileInfo for a #GFile.
74  * @query_info_async: Asynchronously gets the #GFileInfo for a #GFile.
75  * @query_info_finish: Finishes an asynchronous query info operation.
76  * @query_filesystem_info: Gets a #GFileInfo for the file system #GFile is on.
77  * @query_filesystem_info_async: Asynchronously gets a #GFileInfo for the file system #GFile is on.
78  * @query_filesystem_info_finish: Finishes asynchronously getting the file system info.
79  * @find_enclosing_mount: Gets a #GMount for the #GFile.
80  * @find_enclosing_mount_async: Asynchronously gets the #GMount for a #GFile.
81  * @find_enclosing_mount_finish: Finishes asynchronously getting the volume.
82  * @set_display_name: Sets the display name for a #GFile.
83  * @set_display_name_async: Asynchronously sets a #GFile's display name.
84  * @set_display_name_finish: Finishes asynchronously setting a #GFile's display name.
85  * @query_settable_attributes: Returns a list of #GFileAttribute<!-- -->s that can be set.
86  * @_query_settable_attributes_async: Asynchronously gets a list of #GFileAttribute<!-- -->s that can be set.
87  * @_query_settable_attributes_finish: Finishes asynchronously querying settable attributes.
88  * @query_writable_namespaces: Returns a list of #GFileAttribute namespaces that are writable.
89  * @_query_writable_namespaces_async: Asynchronously gets a list of #GFileAttribute namespaces that are writable.
90  * @_query_writable_namespaces_finish: Finishes asynchronously querying the writable namespaces.
91  * @set_attribute: Sets a #GFileAttribute.
92  * @set_attributes_from_info: Sets a #GFileAttribute with information from a #GFileInfo.
93  * @set_attributes_async: Asynchronously sets a file's attributes.
94  * @set_attributes_finish: Finishes setting a file's attributes asynchronously.
95  * @read_fn: Reads a file asynchronously.
96  * @read_async: Asynchronously reads a file.
97  * @read_finish: Finishes asynchronously reading a file.
98  * @append_to: Writes to the end of a file.
99  * @append_to_async: Asynchronously writes to the end of a file.
100  * @append_to_finish: Finishes an asynchronous file append operation.
101  * @create: Creates a new file.
102  * @create_async: Asynchronously creates a file.
103  * @create_finish: Finishes asynchronously creating a file.
104  * @replace: Replaces the contents of a file.
105  * @replace_async: Asynchronously replaces the contents of a file.
106  * @replace_finish: Finishes asynchronously replacing a file.
107  * @delete_file: Deletes a file.
108  * @_delete_file_async: Asynchronously deletes a file.
109  * @_delete_file_finish: Finishes an asynchronous delete.
110  * @trash: Sends a #GFile to the Trash location.
111  * @_trash_async: Asynchronously sends a #GFile to the Trash location.
112  * @_trash_finish: Finishes an asynchronous file trashing operation.
113  * @make_directory: Makes a directory.
114  * @_make_directory_async: Asynchronously makes a directory.
115  * @_make_directory_finish: Finishes making a directory asynchronously.
116  * @make_symbolic_link: Makes a symbolic link.
117  * @_make_symbolic_link_async: Asynchronously makes a symbolic link
118  * @_make_symbolic_link_finish: Finishes making a symbolic link asynchronously.
119  * @copy: Copies a file.
120  * @copy_async: Asynchronously copies a file.
121  * @copy_finish: Finishes an asynchronous copy operation.
122  * @move: Moves a file.
123  * @_move_async: Asynchronously moves a file.
124  * @_move_finish: Finishes an asynchronous move operation.
125  * @mount_mountable: Mounts a mountable object.
126  * @mount_mountable_finish: Finishes a mounting operation.
127  * @unmount_mountable: Unmounts a mountable object.
128  * @unmount_mountable_finish: Finishes an unmount operation.
129  * @eject_mountable: Ejects a mountable.
130  * @eject_mountable_finish: Finishes an eject operation.
131  * @mount_enclosing_volume: Mounts a specified location.
132  * @mount_enclosing_volume_finish: Finishes mounting a specified location.
133  * @monitor_dir: Creates a #GFileMonitor for the location.
134  * @monitor_file: Creates a #GFileMonitor for the location.
135  *
136  * An interface for writing VFS file handles.
137  **/
138 struct _GFileIface
139 {
140   GTypeInterface g_iface;
141 
142   /* Virtual Table */
143 
144   GFile *             (* dup)                         (GFile         *file);
145   guint               (* hash)                        (GFile         *file);
146   gboolean            (* equal)                       (GFile         *file1,
147                                                        GFile         *file2);
148   gboolean            (* is_native)                   (GFile         *file);
149   gboolean            (* has_uri_scheme)              (GFile         *file,
150                                                        const char    *uri_scheme);
151   char *              (* get_uri_scheme)              (GFile         *file);
152   char *              (* get_basename)                (GFile         *file);
153   char *              (* get_path)                    (GFile         *file);
154   char *              (* get_uri)                     (GFile         *file);
155   char *              (* get_parse_name)              (GFile         *file);
156   GFile *             (* get_parent)                  (GFile         *file);
157   gboolean            (* prefix_matches)              (GFile         *prefix,
158                                                        GFile         *file);
159   char *              (* get_relative_path)           (GFile         *parent,
160                                                        GFile         *descendant);
161   GFile *             (* resolve_relative_path)       (GFile        *file,
162                                                        const char   *relative_path);
163   GFile *             (* get_child_for_display_name)  (GFile        *file,
164                                                        const char   *display_name,
165                                                        GError      **error);
166 
167   GFileEnumerator *   (* enumerate_children)          (GFile                *file,
168                                                        const char           *attributes,
169                                                        GFileQueryInfoFlags   flags,
170                                                        GCancellable         *cancellable,
171                                                        GError              **error);
172   void                (* enumerate_children_async)    (GFile                *file,
173                                                        const char           *attributes,
174                                                        GFileQueryInfoFlags   flags,
175                                                        int                   io_priority,
176                                                        GCancellable         *cancellable,
177                                                        GAsyncReadyCallback   callback,
178                                                        gpointer              user_data);
179   GFileEnumerator *   (* enumerate_children_finish)   (GFile                *file,
180                                                        GAsyncResult         *res,
181                                                        GError              **error);
182 
183   GFileInfo *         (* query_info)                  (GFile                *file,
184                                                        const char           *attributes,
185                                                        GFileQueryInfoFlags   flags,
186                                                        GCancellable         *cancellable,
187                                                        GError              **error);
188   void                (* query_info_async)            (GFile                *file,
189                                                        const char           *attributes,
190                                                        GFileQueryInfoFlags   flags,
191                                                        int                   io_priority,
192                                                        GCancellable         *cancellable,
193                                                        GAsyncReadyCallback   callback,
194                                                        gpointer              user_data);
195   GFileInfo *         (* query_info_finish)           (GFile                *file,
196                                                        GAsyncResult         *res,
197                                                        GError              **error);
198 
199   GFileInfo *         (* query_filesystem_info)       (GFile                *file,
200                                                        const char           *attributes,
201                                                        GCancellable         *cancellable,
202                                                        GError              **error);
203   void                (* query_filesystem_info_async) (GFile                *file,
204                                                        const char           *attributes,
205                                                        int                   io_priority,
206                                                        GCancellable         *cancellable,
207                                                        GAsyncReadyCallback   callback,
208                                                        gpointer              user_data);
209   GFileInfo *         (* query_filesystem_info_finish)(GFile                *file,
210                                                        GAsyncResult         *res,
211                                                        GError              **error);
212 
213   GMount *            (* find_enclosing_mount)        (GFile                *file,
214                                                        GCancellable         *cancellable,
215                                                        GError              **error);
216   void                (* find_enclosing_mount_async)  (GFile                *file,
217                                                        int                   io_priority,
218                                                        GCancellable         *cancellable,
219                                                        GAsyncReadyCallback   callback,
220                                                        gpointer              user_data);
221   GMount *            (* find_enclosing_mount_finish) (GFile                *file,
222                                                        GAsyncResult         *res,
223                                                        GError              **error);
224 
225   GFile *             (* set_display_name)            (GFile                *file,
226                                                        const char           *display_name,
227                                                        GCancellable         *cancellable,
228                                                        GError              **error);
229   void                (* set_display_name_async)      (GFile                *file,
230                                                        const char           *display_name,
231                                                        int                   io_priority,
232                                                        GCancellable         *cancellable,
233                                                        GAsyncReadyCallback   callback,
234                                                        gpointer              user_data);
235   GFile *             (* set_display_name_finish)     (GFile                *file,
236                                                        GAsyncResult         *res,
237                                                        GError              **error);
238 
239   GFileAttributeInfoList * (* query_settable_attributes)    (GFile          *file,
240                                                              GCancellable   *cancellable,
241                                                              GError        **error);
242   void                (* _query_settable_attributes_async)  (void);
243   void                (* _query_settable_attributes_finish) (void);
244 
245   GFileAttributeInfoList * (* query_writable_namespaces)    (GFile          *file,
246                                                              GCancellable   *cancellable,
247                                                              GError        **error);
248   void                (* _query_writable_namespaces_async)  (void);
249   void                (* _query_writable_namespaces_finish) (void);
250 
251   gboolean            (* set_attribute)               (GFile                *file,
252                                                        const char           *attribute,
253                                                        GFileAttributeType    type,
254                                                        gpointer              value_p,
255                                                        GFileQueryInfoFlags   flags,
256                                                        GCancellable         *cancellable,
257                                                        GError              **error);
258   gboolean            (* set_attributes_from_info)    (GFile                *file,
259                                                        GFileInfo            *info,
260                                                        GFileQueryInfoFlags   flags,
261                                                        GCancellable         *cancellable,
262                                                        GError              **error);
263   void                (* set_attributes_async)        (GFile                *file,
264                                                        GFileInfo            *info,
265                                                        GFileQueryInfoFlags   flags,
266                                                        int                   io_priority,
267                                                        GCancellable         *cancellable,
268                                                        GAsyncReadyCallback   callback,
269                                                        gpointer              user_data);
270   gboolean            (* set_attributes_finish)       (GFile                *file,
271                                                        GAsyncResult         *result,
272                                                        GFileInfo           **info,
273                                                        GError              **error);
274 
275   GFileInputStream *  (* read_fn)                     (GFile                *file,
276                                                        GCancellable         *cancellable,
277                                                        GError              **error);
278   void                (* read_async)                  (GFile                *file,
279                                                        int                   io_priority,
280                                                        GCancellable         *cancellable,
281                                                        GAsyncReadyCallback   callback,
282                                                        gpointer              user_data);
283   GFileInputStream *  (* read_finish)                 (GFile                *file,
284                                                        GAsyncResult         *res,
285                                                        GError              **error);
286 
287   GFileOutputStream * (* append_to)                   (GFile                *file,
288                                                        GFileCreateFlags      flags,
289                                                        GCancellable         *cancellable,
290                                                        GError              **error);
291   void                (* append_to_async)             (GFile                *file,
292                                                        GFileCreateFlags      flags,
293                                                        int                   io_priority,
294                                                        GCancellable         *cancellable,
295                                                        GAsyncReadyCallback   callback,
296                                                        gpointer              user_data);
297   GFileOutputStream * (* append_to_finish)            (GFile                *file,
298                                                        GAsyncResult         *res,
299                                                        GError              **error);
300 
301   GFileOutputStream * (* create)                      (GFile                *file,
302                                                        GFileCreateFlags      flags,
303                                                        GCancellable         *cancellable,
304                                                        GError              **error);
305   void                (* create_async)                (GFile                *file,
306                                                        GFileCreateFlags      flags,
307                                                        int                   io_priority,
308                                                        GCancellable         *cancellable,
309                                                        GAsyncReadyCallback   callback,
310                                                        gpointer              user_data);
311   GFileOutputStream * (* create_finish)               (GFile                *file,
312                                                        GAsyncResult         *res,
313                                                        GError              **error);
314 
315   GFileOutputStream * (* replace)                     (GFile                *file,
316                                                        const char           *etag,
317                                                        gboolean              make_backup,
318                                                        GFileCreateFlags      flags,
319                                                        GCancellable         *cancellable,
320                                                        GError              **error);
321   void                (* replace_async)               (GFile                *file,
322                                                        const char           *etag,
323                                                        gboolean              make_backup,
324                                                        GFileCreateFlags      flags,
325                                                        int                   io_priority,
326                                                        GCancellable         *cancellable,
327                                                        GAsyncReadyCallback   callback,
328                                                        gpointer              user_data);
329   GFileOutputStream * (* replace_finish)              (GFile                *file,
330                                                        GAsyncResult         *res,
331                                                        GError              **error);
332 
333   gboolean            (* delete_file)                 (GFile                *file,
334                                                        GCancellable         *cancellable,
335                                                        GError              **error);
336   void                (* _delete_file_async)          (void);
337   void                (* _delete_file_finish)         (void);
338 
339   gboolean            (* trash)                       (GFile                *file,
340                                                        GCancellable         *cancellable,
341                                                        GError              **error);
342   void                (* _trash_async)                (void);
343   void                (* _trash_finish)               (void);
344 
345   gboolean            (* make_directory)              (GFile                *file,
346                                                        GCancellable         *cancellable,
347                                                        GError              **error);
348   void                (* _make_directory_async)       (void);
349   void                (* _make_directory_finish)      (void);
350 
351   gboolean            (* make_symbolic_link)          (GFile                *file,
352                                                        const char           *symlink_value,
353                                                        GCancellable         *cancellable,
354                                                        GError              **error);
355   void                (* _make_symbolic_link_async)   (void);
356   void                (* _make_symbolic_link_finish)  (void);
357 
358   gboolean            (* copy)                        (GFile                *source,
359                                                        GFile                *destination,
360                                                        GFileCopyFlags        flags,
361                                                        GCancellable         *cancellable,
362                                                        GFileProgressCallback progress_callback,
363                                                        gpointer              progress_callback_data,
364                                                        GError              **error);
365   void                (* copy_async)                  (GFile                *source,
366                                                        GFile                *destination,
367                                                        GFileCopyFlags        flags,
368                                                        int                   io_priority,
369                                                        GCancellable         *cancellable,
370                                                        GFileProgressCallback progress_callback,
371                                                        gpointer              progress_callback_data,
372                                                        GAsyncReadyCallback   callback,
373                                                        gpointer              user_data);
374   gboolean            (* copy_finish)                 (GFile                *file,
375                                                        GAsyncResult         *res,
376                                                        GError              **error);
377 
378   gboolean            (* move)                        (GFile                *source,
379                                                        GFile                *destination,
380                                                        GFileCopyFlags        flags,
381                                                        GCancellable         *cancellable,
382                                                        GFileProgressCallback progress_callback,
383                                                        gpointer              progress_callback_data,
384                                                        GError              **error);
385   void                (* _move_async)                 (void);
386   void                (* _move_finish)                (void);
387 
388   void                (* mount_mountable)             (GFile                *file,
389                                                        GMountMountFlags      flags,
390                                                        GMountOperation      *mount_operation,
391                                                        GCancellable         *cancellable,
392                                                        GAsyncReadyCallback   callback,
393                                                        gpointer              user_data);
394   GFile *             (* mount_mountable_finish)      (GFile                *file,
395                                                        GAsyncResult         *result,
396                                                        GError              **error);
397 
398   void                (* unmount_mountable)           (GFile                *file,
399                                                        GMountUnmountFlags    flags,
400                                                        GCancellable         *cancellable,
401                                                        GAsyncReadyCallback   callback,
402                                                        gpointer              user_data);
403   gboolean            (* unmount_mountable_finish)    (GFile                *file,
404                                                        GAsyncResult         *result,
405                                                        GError              **error);
406 
407   void                (* eject_mountable)             (GFile                *file,
408                                                        GMountUnmountFlags    flags,
409                                                        GCancellable         *cancellable,
410                                                        GAsyncReadyCallback   callback,
411                                                        gpointer              user_data);
412   gboolean            (* eject_mountable_finish)      (GFile                *file,
413                                                        GAsyncResult         *result,
414                                                        GError              **error);
415 
416   void                (* mount_enclosing_volume)      (GFile                *location,
417                                                        GMountMountFlags      flags,
418                                                        GMountOperation      *mount_operation,
419                                                        GCancellable         *cancellable,
420                                                        GAsyncReadyCallback   callback,
421                                                        gpointer              user_data);
422   gboolean         (* mount_enclosing_volume_finish)  (GFile                *location,
423                                                        GAsyncResult         *result,
424                                                        GError              **error);
425 
426   GFileMonitor *      (* monitor_dir)                 (GFile                *file,
427                                                        GFileMonitorFlags     flags,
428                                                        GCancellable         *cancellable,
429                                                        GError              **error);
430   GFileMonitor *      (* monitor_file)                (GFile                *file,
431                                                        GFileMonitorFlags     flags,
432                                                        GCancellable         *cancellable,
433                                                        GError              **error);
434 };
435 
436 GType                   g_file_get_type                   (void) G_GNUC_CONST;
437 
438 GFile *                 g_file_new_for_path               (const char                 *path);
439 GFile *                 g_file_new_for_uri                (const char                 *uri);
440 GFile *                 g_file_new_for_commandline_arg    (const char                 *arg);
441 GFile *                 g_file_parse_name                 (const char                 *parse_name);
442 GFile *                 g_file_dup                        (GFile                      *file);
443 guint                   g_file_hash                       (gconstpointer               file);
444 gboolean                g_file_equal                      (GFile                      *file1,
445 							   GFile                      *file2);
446 char *                  g_file_get_basename               (GFile                      *file);
447 char *                  g_file_get_path                   (GFile                      *file);
448 char *                  g_file_get_uri                    (GFile                      *file);
449 char *                  g_file_get_parse_name             (GFile                      *file);
450 GFile *                 g_file_get_parent                 (GFile                      *file);
451 GFile *                 g_file_get_child                  (GFile                      *file,
452 							   const char                 *name);
453 GFile *                 g_file_get_child_for_display_name (GFile                      *file,
454 							   const char                 *display_name,
455 							   GError                    **error);
456 gboolean                g_file_has_prefix                 (GFile                      *file,
457 							   GFile                      *prefix);
458 char *                  g_file_get_relative_path          (GFile                      *parent,
459 							   GFile                      *descendant);
460 GFile *                 g_file_resolve_relative_path      (GFile                      *file,
461 							   const char                 *relative_path);
462 gboolean                g_file_is_native                  (GFile                      *file);
463 gboolean                g_file_has_uri_scheme             (GFile                      *file,
464 							   const char                 *uri_scheme);
465 char *                  g_file_get_uri_scheme             (GFile                      *file);
466 GFileInputStream *      g_file_read                       (GFile                      *file,
467 							   GCancellable               *cancellable,
468 							   GError                    **error);
469 void                    g_file_read_async                 (GFile                      *file,
470 							   int                         io_priority,
471 							   GCancellable               *cancellable,
472 							   GAsyncReadyCallback         callback,
473 							   gpointer                    user_data);
474 GFileInputStream *      g_file_read_finish                (GFile                      *file,
475 							   GAsyncResult               *res,
476 							   GError                    **error);
477 GFileOutputStream *     g_file_append_to                  (GFile                      *file,
478 							   GFileCreateFlags             flags,
479 							   GCancellable               *cancellable,
480 							   GError                    **error);
481 GFileOutputStream *     g_file_create                     (GFile                      *file,
482 							   GFileCreateFlags             flags,
483 							   GCancellable               *cancellable,
484 							   GError                    **error);
485 GFileOutputStream *     g_file_replace                    (GFile                      *file,
486 							   const char                 *etag,
487 							   gboolean                    make_backup,
488 							   GFileCreateFlags            flags,
489 							   GCancellable               *cancellable,
490 							   GError                    **error);
491 void                    g_file_append_to_async            (GFile                      *file,
492 							   GFileCreateFlags            flags,
493 							   int                         io_priority,
494 							   GCancellable               *cancellable,
495 							   GAsyncReadyCallback         callback,
496 							   gpointer                    user_data);
497 GFileOutputStream *     g_file_append_to_finish           (GFile                      *file,
498 							   GAsyncResult               *res,
499 							   GError                    **error);
500 void                    g_file_create_async               (GFile                      *file,
501 							   GFileCreateFlags            flags,
502 							   int                         io_priority,
503 							   GCancellable               *cancellable,
504 							   GAsyncReadyCallback         callback,
505 							   gpointer                    user_data);
506 GFileOutputStream *     g_file_create_finish              (GFile                      *file,
507 							   GAsyncResult               *res,
508 							   GError                    **error);
509 void                    g_file_replace_async              (GFile                      *file,
510 							   const char                 *etag,
511 							   gboolean                    make_backup,
512 							   GFileCreateFlags            flags,
513 							   int                         io_priority,
514 							   GCancellable               *cancellable,
515 							   GAsyncReadyCallback         callback,
516 							   gpointer                    user_data);
517 GFileOutputStream *     g_file_replace_finish             (GFile                      *file,
518 							   GAsyncResult               *res,
519 							   GError                    **error);
520 gboolean                g_file_query_exists               (GFile                      *file,
521 							   GCancellable               *cancellable);
522 GFileType               g_file_query_file_type            (GFile                      *file,
523                                                            GFileQueryInfoFlags         flags,
524                                                            GCancellable               *cancellable);
525 GFileInfo *             g_file_query_info                 (GFile                      *file,
526 							   const char                 *attributes,
527 							   GFileQueryInfoFlags         flags,
528 							   GCancellable               *cancellable,
529 							   GError                    **error);
530 void                    g_file_query_info_async           (GFile                      *file,
531 							   const char                 *attributes,
532 							   GFileQueryInfoFlags         flags,
533 							   int                         io_priority,
534 							   GCancellable               *cancellable,
535 							   GAsyncReadyCallback         callback,
536 							   gpointer                    user_data);
537 GFileInfo *             g_file_query_info_finish          (GFile                      *file,
538 							   GAsyncResult               *res,
539 							   GError                    **error);
540 GFileInfo *             g_file_query_filesystem_info      (GFile                      *file,
541 							   const char                 *attributes,
542 							   GCancellable               *cancellable,
543 							   GError                    **error);
544 void                    g_file_query_filesystem_info_async (GFile                      *file,
545 							   const char                 *attributes,
546 							   int                         io_priority,
547 							   GCancellable               *cancellable,
548 							   GAsyncReadyCallback         callback,
549 							   gpointer                    user_data);
550 GFileInfo *             g_file_query_filesystem_info_finish (GFile                      *file,
551                                                            GAsyncResult               *res,
552 							   GError                    **error);
553 GMount *                g_file_find_enclosing_mount       (GFile                      *file,
554                                                            GCancellable               *cancellable,
555                                                            GError                    **error);
556 void                    g_file_find_enclosing_mount_async (GFile                      *file,
557 							   int                         io_priority,
558 							   GCancellable               *cancellable,
559 							   GAsyncReadyCallback         callback,
560 							   gpointer                    user_data);
561 GMount *                g_file_find_enclosing_mount_finish (GFile                     *file,
562 							    GAsyncResult              *res,
563 							    GError                   **error);
564 GFileEnumerator *       g_file_enumerate_children         (GFile                      *file,
565 							   const char                 *attributes,
566 							   GFileQueryInfoFlags         flags,
567 							   GCancellable               *cancellable,
568 							   GError                    **error);
569 void                    g_file_enumerate_children_async   (GFile                      *file,
570 							   const char                 *attributes,
571 							   GFileQueryInfoFlags         flags,
572 							   int                         io_priority,
573 							   GCancellable               *cancellable,
574 							   GAsyncReadyCallback         callback,
575 							   gpointer                    user_data);
576 GFileEnumerator *       g_file_enumerate_children_finish  (GFile                      *file,
577 							   GAsyncResult               *res,
578 							   GError                    **error);
579 GFile *                 g_file_set_display_name           (GFile                      *file,
580 							   const char                 *display_name,
581 							   GCancellable               *cancellable,
582 							   GError                    **error);
583 void                    g_file_set_display_name_async     (GFile                      *file,
584 							   const char                 *display_name,
585 							   int                         io_priority,
586 							   GCancellable               *cancellable,
587 							   GAsyncReadyCallback         callback,
588 							   gpointer                    user_data);
589 GFile *                 g_file_set_display_name_finish    (GFile                      *file,
590 							   GAsyncResult               *res,
591 							   GError                    **error);
592 gboolean                g_file_delete                     (GFile                      *file,
593 							   GCancellable               *cancellable,
594 							   GError                    **error);
595 gboolean                g_file_trash                      (GFile                      *file,
596 							   GCancellable               *cancellable,
597 							   GError                    **error);
598 gboolean                g_file_copy                       (GFile                      *source,
599 							   GFile                      *destination,
600 							   GFileCopyFlags              flags,
601 							   GCancellable               *cancellable,
602 							   GFileProgressCallback       progress_callback,
603 							   gpointer                    progress_callback_data,
604 							   GError                    **error);
605 void                    g_file_copy_async                 (GFile                      *source,
606 							   GFile                      *destination,
607 							   GFileCopyFlags              flags,
608 							   int                         io_priority,
609 							   GCancellable               *cancellable,
610 							   GFileProgressCallback       progress_callback,
611 							   gpointer                    progress_callback_data,
612 							   GAsyncReadyCallback         callback,
613 							   gpointer                    user_data);
614 gboolean                g_file_copy_finish                (GFile                      *file,
615 							   GAsyncResult               *res,
616 							   GError                    **error);
617 gboolean                g_file_move                       (GFile                      *source,
618 							   GFile                      *destination,
619 							   GFileCopyFlags              flags,
620 							   GCancellable               *cancellable,
621 							   GFileProgressCallback       progress_callback,
622 							   gpointer                    progress_callback_data,
623 							   GError                    **error);
624 gboolean                g_file_make_directory             (GFile                      *file,
625 							   GCancellable               *cancellable,
626 							   GError                    **error);
627 gboolean                g_file_make_directory_with_parents (GFile                     *file,
628 		                                           GCancellable               *cancellable,
629 		                                           GError                    **error);
630 gboolean                g_file_make_symbolic_link         (GFile                      *file,
631 							   const char                 *symlink_value,
632 							   GCancellable               *cancellable,
633 							   GError                    **error);
634 GFileAttributeInfoList *g_file_query_settable_attributes  (GFile                      *file,
635 							   GCancellable               *cancellable,
636 							   GError                    **error);
637 GFileAttributeInfoList *g_file_query_writable_namespaces  (GFile                      *file,
638 							   GCancellable               *cancellable,
639 							   GError                    **error);
640 gboolean                g_file_set_attribute              (GFile                      *file,
641 							   const char                 *attribute,
642 							   GFileAttributeType          type,
643 							   gpointer                    value_p,
644 							   GFileQueryInfoFlags         flags,
645 							   GCancellable               *cancellable,
646 							   GError                    **error);
647 gboolean                g_file_set_attributes_from_info   (GFile                      *file,
648 							   GFileInfo                  *info,
649 							   GFileQueryInfoFlags         flags,
650 							   GCancellable               *cancellable,
651 							   GError                    **error);
652 void                    g_file_set_attributes_async       (GFile                      *file,
653 							   GFileInfo                  *info,
654 							   GFileQueryInfoFlags         flags,
655 							   int                         io_priority,
656 							   GCancellable               *cancellable,
657 							   GAsyncReadyCallback         callback,
658 							   gpointer                    user_data);
659 gboolean                g_file_set_attributes_finish      (GFile                      *file,
660 							   GAsyncResult               *result,
661 							   GFileInfo                 **info,
662 							   GError                    **error);
663 gboolean                g_file_set_attribute_string       (GFile                      *file,
664 							   const char                 *attribute,
665 							   const char                 *value,
666 							   GFileQueryInfoFlags         flags,
667 							   GCancellable               *cancellable,
668 							   GError                    **error);
669 gboolean                g_file_set_attribute_byte_string  (GFile                      *file,
670 							   const char                 *attribute,
671 							   const char                 *value,
672 							   GFileQueryInfoFlags         flags,
673 							   GCancellable               *cancellable,
674 							   GError                    **error);
675 gboolean                g_file_set_attribute_uint32       (GFile                      *file,
676 							   const char                 *attribute,
677 							   guint32                     value,
678 							   GFileQueryInfoFlags         flags,
679 							   GCancellable               *cancellable,
680 							   GError                    **error);
681 gboolean                g_file_set_attribute_int32        (GFile                      *file,
682 							   const char                 *attribute,
683 							   gint32                      value,
684 							   GFileQueryInfoFlags         flags,
685 							   GCancellable               *cancellable,
686 							   GError                    **error);
687 gboolean                g_file_set_attribute_uint64       (GFile                      *file,
688 							   const char                 *attribute,
689 							   guint64                     value,
690 							   GFileQueryInfoFlags         flags,
691 							   GCancellable               *cancellable,
692 							   GError                    **error);
693 gboolean                g_file_set_attribute_int64        (GFile                      *file,
694 							   const char                 *attribute,
695 							   gint64                      value,
696 							   GFileQueryInfoFlags         flags,
697 							   GCancellable               *cancellable,
698 							   GError                    **error);
699 void                    g_file_mount_enclosing_volume     (GFile                      *location,
700 							   GMountMountFlags            flags,
701 							   GMountOperation            *mount_operation,
702 							   GCancellable               *cancellable,
703 							   GAsyncReadyCallback         callback,
704 							   gpointer                    user_data);
705 gboolean                g_file_mount_enclosing_volume_finish (GFile                      *location,
706 							   GAsyncResult               *result,
707 							   GError                    **error);
708 void                    g_file_mount_mountable            (GFile                      *file,
709 							   GMountMountFlags            flags,
710 							   GMountOperation            *mount_operation,
711 							   GCancellable               *cancellable,
712 							   GAsyncReadyCallback         callback,
713 							   gpointer                    user_data);
714 GFile *                 g_file_mount_mountable_finish     (GFile                      *file,
715 							   GAsyncResult               *result,
716 							   GError                    **error);
717 void                    g_file_unmount_mountable          (GFile                      *file,
718 							   GMountUnmountFlags          flags,
719 							   GCancellable               *cancellable,
720 							   GAsyncReadyCallback         callback,
721 							   gpointer                    user_data);
722 gboolean                g_file_unmount_mountable_finish   (GFile                      *file,
723 							   GAsyncResult               *result,
724 							   GError                    **error);
725 void                    g_file_eject_mountable            (GFile                      *file,
726 							   GMountUnmountFlags          flags,
727 							   GCancellable               *cancellable,
728 							   GAsyncReadyCallback         callback,
729 							   gpointer                    user_data);
730 gboolean                g_file_eject_mountable_finish     (GFile                      *file,
731 							   GAsyncResult               *result,
732 							   GError                    **error);
733 
734 gboolean                g_file_copy_attributes            (GFile                      *source,
735 							   GFile                      *destination,
736 							   GFileCopyFlags              flags,
737 							   GCancellable               *cancellable,
738 							   GError                    **error);
739 
740 
741 GFileMonitor*           g_file_monitor_directory          (GFile                  *file,
742 							   GFileMonitorFlags       flags,
743 							   GCancellable           *cancellable,
744 							   GError                **error);
745 GFileMonitor*           g_file_monitor_file               (GFile                  *file,
746 							   GFileMonitorFlags       flags,
747 							   GCancellable           *cancellable,
748 							   GError                **error);
749 GFileMonitor*           g_file_monitor                    (GFile                  *file,
750 							   GFileMonitorFlags       flags,
751 							   GCancellable           *cancellable,
752 							   GError                **error);
753 
754 
755 /* Utilities */
756 
757 GAppInfo *g_file_query_default_handler       (GFile                  *file,
758 					      GCancellable           *cancellable,
759 					      GError                **error);
760 gboolean g_file_load_contents                (GFile                  *file,
761 					      GCancellable           *cancellable,
762 					      char                  **contents,
763 					      gsize                  *length,
764 					      char                  **etag_out,
765 					      GError                **error);
766 void     g_file_load_contents_async          (GFile                  *file,
767 					      GCancellable           *cancellable,
768 					      GAsyncReadyCallback     callback,
769 					      gpointer                user_data);
770 gboolean g_file_load_contents_finish         (GFile                  *file,
771 					      GAsyncResult           *res,
772 					      char                  **contents,
773 					      gsize                  *length,
774 					      char                  **etag_out,
775 					      GError                **error);
776 void     g_file_load_partial_contents_async  (GFile                  *file,
777 					      GCancellable           *cancellable,
778 					      GFileReadMoreCallback   read_more_callback,
779 					      GAsyncReadyCallback     callback,
780 					      gpointer                user_data);
781 gboolean g_file_load_partial_contents_finish (GFile                  *file,
782 					      GAsyncResult           *res,
783 					      char                  **contents,
784 					      gsize                  *length,
785 					      char                  **etag_out,
786 					      GError                **error);
787 gboolean g_file_replace_contents             (GFile                  *file,
788 					      const char             *contents,
789 					      gsize                   length,
790 					      const char             *etag,
791 					      gboolean                make_backup,
792 					      GFileCreateFlags        flags,
793 					      char                  **new_etag,
794 					      GCancellable           *cancellable,
795 					      GError                **error);
796 void     g_file_replace_contents_async       (GFile                  *file,
797 					      const char             *contents,
798 					      gsize                   length,
799 					      const char             *etag,
800 					      gboolean                make_backup,
801 					      GFileCreateFlags        flags,
802 					      GCancellable           *cancellable,
803 					      GAsyncReadyCallback     callback,
804 					      gpointer                user_data);
805 gboolean g_file_replace_contents_finish      (GFile                  *file,
806 					      GAsyncResult           *res,
807 					      char                  **new_etag,
808 					      GError                **error);
809 
810 G_END_DECLS
811 
812 #endif /* __G_FILE_H__ */
813