lolengine
/
binaries
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
2 Branches
7.3 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
binaries/gtk-2.22.1/include/glib-2.0/gio/gfile.h

1018 lines
64 KiB
Raw Permalink Blame History 

  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.  * @open_readwrite: Open file read/write. Since 2.22.

  136.  * @open_readwrite_async: Asynchronously opens file read/write. Since 2.22.

  137.  * @open_readwrite_finish: Finishes an asynchronous open read/write. Since 2.22.

  138.  * @create_readwrite: Creates file read/write. Since 2.22.

  139.  * @create_readwrite_async: Asynchronously creates file read/write. Since 2.22.

  140.  * @create_readwrite_finish: Finishes an asynchronous creates read/write. Since 2.22.

  141.  * @replace_readwrite: Replaces file read/write. Since 2.22.

  142.  * @replace_readwrite_async: Asynchronously replaces file read/write. Since 2.22.

  143.  * @replace_readwrite_finish: Finishes an asynchronous replace read/write. Since 2.22.

  144.  * @start_mountable: Starts a mountable object. Since 2.22.

  145.  * @start_mountable_finish: Finishes an start operation. Since 2.22.

  146.  * @stop_mountable: Stops a mountable. Since 2.22.

  147.  * @stop_mountable_finish: Finishes an stop operation. Since 2.22.

  148.  * @supports_thread_contexts: a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22.

  149.  * @unmount_mountable_with_operation: Unmounts a mountable object using a #GMountOperation. Since 2.22.

  150.  * @unmount_mountable_with_operation_finish: Finishes an unmount operation using a #GMountOperation. Since 2.22.

  151.  * @eject_mountable_with_operation: Ejects a mountable object using a #GMountOperation. Since 2.22.

  152.  * @eject_mountable_with_operation_finish: Finishes an eject operation using a #GMountOperation. Since 2.22.

  153.  * @poll_mountable: Polls a mountable object for media changes. Since 2.22.

  154.  * @poll_mountable_finish: Finishes an poll operation for media changes. Since 2.22.

  155.  *

  156.  * An interface for writing VFS file handles.

  157.  **/

  158. struct _GFileIface

  159. {

  160.   GTypeInterface g_iface;

  161. 

  162.   /* Virtual Table */

  163. 

  164.   GFile *             (* dup)                         (GFile         *file);

  165.   guint               (* hash)                        (GFile         *file);

  166.   gboolean            (* equal)                       (GFile         *file1,

  167.                                                        GFile         *file2);

  168.   gboolean            (* is_native)                   (GFile         *file);

  169.   gboolean            (* has_uri_scheme)              (GFile         *file,

  170.                                                        const char    *uri_scheme);

  171.   char *              (* get_uri_scheme)              (GFile         *file);

  172.   char *              (* get_basename)                (GFile         *file);

  173.   char *              (* get_path)                    (GFile         *file);

  174.   char *              (* get_uri)                     (GFile         *file);

  175.   char *              (* get_parse_name)              (GFile         *file);

  176.   GFile *             (* get_parent)                  (GFile         *file);

  177.   gboolean            (* prefix_matches)              (GFile         *prefix,

  178.                                                        GFile         *file);

  179.   char *              (* get_relative_path)           (GFile         *parent,

  180.                                                        GFile         *descendant);

  181.   GFile *             (* resolve_relative_path)       (GFile        *file,

  182.                                                        const char   *relative_path);

  183.   GFile *             (* get_child_for_display_name)  (GFile        *file,

  184.                                                        const char   *display_name,

  185.                                                        GError      **error);

  186. 

  187.   GFileEnumerator *   (* enumerate_children)          (GFile                *file,

  188.                                                        const char           *attributes,

  189.                                                        GFileQueryInfoFlags   flags,

  190.                                                        GCancellable         *cancellable,

  191.                                                        GError              **error);

  192.   void                (* enumerate_children_async)    (GFile                *file,

  193.                                                        const char           *attributes,

  194.                                                        GFileQueryInfoFlags   flags,

  195.                                                        int                   io_priority,

  196.                                                        GCancellable         *cancellable,

  197.                                                        GAsyncReadyCallback   callback,

  198.                                                        gpointer              user_data);

  199.   GFileEnumerator *   (* enumerate_children_finish)   (GFile                *file,

  200.                                                        GAsyncResult         *res,

  201.                                                        GError              **error);

  202. 

  203.   GFileInfo *         (* query_info)                  (GFile                *file,

  204.                                                        const char           *attributes,

  205.                                                        GFileQueryInfoFlags   flags,

  206.                                                        GCancellable         *cancellable,

  207.                                                        GError              **error);

  208.   void                (* query_info_async)            (GFile                *file,

  209.                                                        const char           *attributes,

  210.                                                        GFileQueryInfoFlags   flags,

  211.                                                        int                   io_priority,

  212.                                                        GCancellable         *cancellable,

  213.                                                        GAsyncReadyCallback   callback,

  214.                                                        gpointer              user_data);

  215.   GFileInfo *         (* query_info_finish)           (GFile                *file,

  216.                                                        GAsyncResult         *res,

  217.                                                        GError              **error);

  218. 

  219.   GFileInfo *         (* query_filesystem_info)       (GFile                *file,

  220.                                                        const char           *attributes,

  221.                                                        GCancellable         *cancellable,

  222.                                                        GError              **error);

  223.   void                (* query_filesystem_info_async) (GFile                *file,

  224.                                                        const char           *attributes,

  225.                                                        int                   io_priority,

  226.                                                        GCancellable         *cancellable,

  227.                                                        GAsyncReadyCallback   callback,

  228.                                                        gpointer              user_data);

  229.   GFileInfo *         (* query_filesystem_info_finish)(GFile                *file,

  230.                                                        GAsyncResult         *res,

  231.                                                        GError              **error);

  232. 

  233.   GMount *            (* find_enclosing_mount)        (GFile                *file,

  234.                                                        GCancellable         *cancellable,

  235.                                                        GError              **error);

  236.   void                (* find_enclosing_mount_async)  (GFile                *file,

  237.                                                        int                   io_priority,

  238.                                                        GCancellable         *cancellable,

  239.                                                        GAsyncReadyCallback   callback,

  240.                                                        gpointer              user_data);

  241.   GMount *            (* find_enclosing_mount_finish) (GFile                *file,

  242.                                                        GAsyncResult         *res,

  243.                                                        GError              **error);

  244. 

  245.   GFile *             (* set_display_name)            (GFile                *file,

  246.                                                        const char           *display_name,

  247.                                                        GCancellable         *cancellable,

  248.                                                        GError              **error);

  249.   void                (* set_display_name_async)      (GFile                *file,

  250.                                                        const char           *display_name,

  251.                                                        int                   io_priority,

  252.                                                        GCancellable         *cancellable,

  253.                                                        GAsyncReadyCallback   callback,

  254.                                                        gpointer              user_data);

  255.   GFile *             (* set_display_name_finish)     (GFile                *file,

  256.                                                        GAsyncResult         *res,

  257.                                                        GError              **error);

  258. 

  259.   GFileAttributeInfoList * (* query_settable_attributes)    (GFile          *file,

  260.                                                              GCancellable   *cancellable,

  261.                                                              GError        **error);

  262.   void                (* _query_settable_attributes_async)  (void);

  263.   void                (* _query_settable_attributes_finish) (void);

  264. 

  265.   GFileAttributeInfoList * (* query_writable_namespaces)    (GFile          *file,

  266.                                                              GCancellable   *cancellable,

  267.                                                              GError        **error);

  268.   void                (* _query_writable_namespaces_async)  (void);

  269.   void                (* _query_writable_namespaces_finish) (void);

  270. 

  271.   gboolean            (* set_attribute)               (GFile                *file,

  272.                                                        const char           *attribute,

  273.                                                        GFileAttributeType    type,

  274.                                                        gpointer              value_p,

  275.                                                        GFileQueryInfoFlags   flags,

  276.                                                        GCancellable         *cancellable,

  277.                                                        GError              **error);

  278.   gboolean            (* set_attributes_from_info)    (GFile                *file,

  279.                                                        GFileInfo            *info,

  280.                                                        GFileQueryInfoFlags   flags,

  281.                                                        GCancellable         *cancellable,

  282.                                                        GError              **error);

  283.   void                (* set_attributes_async)        (GFile                *file,

  284.                                                        GFileInfo            *info,

  285.                                                        GFileQueryInfoFlags   flags,

  286.                                                        int                   io_priority,

  287.                                                        GCancellable         *cancellable,

  288.                                                        GAsyncReadyCallback   callback,

  289.                                                        gpointer              user_data);

  290.   gboolean            (* set_attributes_finish)       (GFile                *file,

  291.                                                        GAsyncResult         *result,

  292.                                                        GFileInfo           **info,

  293.                                                        GError              **error);

  294. 

  295.   GFileInputStream *  (* read_fn)                     (GFile                *file,

  296.                                                        GCancellable         *cancellable,

  297.                                                        GError              **error);

  298.   void                (* read_async)                  (GFile                *file,

  299.                                                        int                   io_priority,

  300.                                                        GCancellable         *cancellable,

  301.                                                        GAsyncReadyCallback   callback,

  302.                                                        gpointer              user_data);

  303.   GFileInputStream *  (* read_finish)                 (GFile                *file,

  304.                                                        GAsyncResult         *res,

  305.                                                        GError              **error);

  306. 

  307.   GFileOutputStream * (* append_to)                   (GFile                *file,

  308.                                                        GFileCreateFlags      flags,

  309.                                                        GCancellable         *cancellable,

  310.                                                        GError              **error);

  311.   void                (* append_to_async)             (GFile                *file,

  312.                                                        GFileCreateFlags      flags,

  313.                                                        int                   io_priority,

  314.                                                        GCancellable         *cancellable,

  315.                                                        GAsyncReadyCallback   callback,

  316.                                                        gpointer              user_data);

  317.   GFileOutputStream * (* append_to_finish)            (GFile                *file,

  318.                                                        GAsyncResult         *res,

  319.                                                        GError              **error);

  320. 

  321.   GFileOutputStream * (* create)                      (GFile                *file,

  322.                                                        GFileCreateFlags      flags,

  323.                                                        GCancellable         *cancellable,

  324.                                                        GError              **error);

  325.   void                (* create_async)                (GFile                *file,

  326.                                                        GFileCreateFlags      flags,

  327.                                                        int                   io_priority,

  328.                                                        GCancellable         *cancellable,

  329.                                                        GAsyncReadyCallback   callback,

  330.                                                        gpointer              user_data);

  331.   GFileOutputStream * (* create_finish)               (GFile                *file,

  332.                                                        GAsyncResult         *res,

  333.                                                        GError              **error);

  334. 

  335.   GFileOutputStream * (* replace)                     (GFile                *file,

  336.                                                        const char           *etag,

  337.                                                        gboolean              make_backup,

  338.                                                        GFileCreateFlags      flags,

  339.                                                        GCancellable         *cancellable,

  340.                                                        GError              **error);

  341.   void                (* replace_async)               (GFile                *file,

  342.                                                        const char           *etag,

  343.                                                        gboolean              make_backup,

  344.                                                        GFileCreateFlags      flags,

  345.                                                        int                   io_priority,

  346.                                                        GCancellable         *cancellable,

  347.                                                        GAsyncReadyCallback   callback,

  348.                                                        gpointer              user_data);

  349.   GFileOutputStream * (* replace_finish)              (GFile                *file,

  350.                                                        GAsyncResult         *res,

  351.                                                        GError              **error);

  352. 

  353.   gboolean            (* delete_file)                 (GFile                *file,

  354.                                                        GCancellable         *cancellable,

  355.                                                        GError              **error);

  356.   void                (* _delete_file_async)          (void);

  357.   void                (* _delete_file_finish)         (void);

  358. 

  359.   gboolean            (* trash)                       (GFile                *file,

  360.                                                        GCancellable         *cancellable,

  361.                                                        GError              **error);

  362.   void                (* _trash_async)                (void);

  363.   void                (* _trash_finish)               (void);

  364. 

  365.   gboolean            (* make_directory)              (GFile                *file,

  366.                                                        GCancellable         *cancellable,

  367.                                                        GError              **error);

  368.   void                (* _make_directory_async)       (void);

  369.   void                (* _make_directory_finish)      (void);

  370. 

  371.   gboolean            (* make_symbolic_link)          (GFile                *file,

  372.                                                        const char           *symlink_value,

  373.                                                        GCancellable         *cancellable,

  374.                                                        GError              **error);

  375.   void                (* _make_symbolic_link_async)   (void);

  376.   void                (* _make_symbolic_link_finish)  (void);

  377. 

  378.   gboolean            (* copy)                        (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                (* copy_async)                  (GFile                *source,

  386.                                                        GFile                *destination,

  387.                                                        GFileCopyFlags        flags,

  388.                                                        int                   io_priority,

  389.                                                        GCancellable         *cancellable,

  390.                                                        GFileProgressCallback progress_callback,

  391.                                                        gpointer              progress_callback_data,

  392.                                                        GAsyncReadyCallback   callback,

  393.                                                        gpointer              user_data);

  394.   gboolean            (* copy_finish)                 (GFile                *file,

  395.                                                        GAsyncResult         *res,

  396.                                                        GError              **error);

  397. 

  398.   gboolean            (* move)                        (GFile                *source,

  399.                                                        GFile                *destination,

  400.                                                        GFileCopyFlags        flags,

  401.                                                        GCancellable         *cancellable,

  402.                                                        GFileProgressCallback progress_callback,

  403.                                                        gpointer              progress_callback_data,

  404.                                                        GError              **error);

  405.   void                (* _move_async)                 (void);

  406.   void                (* _move_finish)                (void);

  407. 

  408.   void                (* mount_mountable)             (GFile                *file,

  409.                                                        GMountMountFlags      flags,

  410.                                                        GMountOperation      *mount_operation,

  411.                                                        GCancellable         *cancellable,

  412.                                                        GAsyncReadyCallback   callback,

  413.                                                        gpointer              user_data);

  414.   GFile *             (* mount_mountable_finish)      (GFile                *file,

  415.                                                        GAsyncResult         *result,

  416.                                                        GError              **error);

  417. 

  418.   void                (* unmount_mountable)           (GFile                *file,

  419.                                                        GMountUnmountFlags    flags,

  420.                                                        GCancellable         *cancellable,

  421.                                                        GAsyncReadyCallback   callback,

  422.                                                        gpointer              user_data);

  423.   gboolean            (* unmount_mountable_finish)    (GFile                *file,

  424.                                                        GAsyncResult         *result,

  425.                                                        GError              **error);

  426. 

  427.   void                (* eject_mountable)             (GFile                *file,

  428.                                                        GMountUnmountFlags    flags,

  429.                                                        GCancellable         *cancellable,

  430.                                                        GAsyncReadyCallback   callback,

  431.                                                        gpointer              user_data);

  432.   gboolean            (* eject_mountable_finish)      (GFile                *file,

  433.                                                        GAsyncResult         *result,

  434.                                                        GError              **error);

  435. 

  436.   void                (* mount_enclosing_volume)      (GFile                *location,

  437.                                                        GMountMountFlags      flags,

  438.                                                        GMountOperation      *mount_operation,

  439.                                                        GCancellable         *cancellable,

  440.                                                        GAsyncReadyCallback   callback,

  441.                                                        gpointer              user_data);

  442.   gboolean         (* mount_enclosing_volume_finish)  (GFile                *location,

  443.                                                        GAsyncResult         *result,

  444.                                                        GError              **error);

  445. 

  446.   GFileMonitor *      (* monitor_dir)                 (GFile                *file,

  447.                                                        GFileMonitorFlags     flags,

  448.                                                        GCancellable         *cancellable,

  449.                                                        GError              **error);

  450.   GFileMonitor *      (* monitor_file)                (GFile                *file,

  451.                                                        GFileMonitorFlags     flags,

  452.                                                        GCancellable         *cancellable,

  453.                                                        GError              **error);

  454. 

  455.   GFileIOStream *     (* open_readwrite)              (GFile                *file,

  456.                                                        GCancellable         *cancellable,

  457.                                                        GError              **error);

  458.   void                (* open_readwrite_async)        (GFile                *file,

  459.                                                        int                   io_priority,

  460.                                                        GCancellable         *cancellable,

  461.                                                        GAsyncReadyCallback   callback,

  462.                                                        gpointer              user_data);

  463.   GFileIOStream *     (* open_readwrite_finish)       (GFile                *file,

  464.                                                        GAsyncResult         *res,

  465.                                                        GError              **error);

  466.   GFileIOStream *     (* create_readwrite)            (GFile                *file,

  467. 						       GFileCreateFlags      flags,

  468.                                                        GCancellable         *cancellable,

  469.                                                        GError              **error);

  470.   void                (* create_readwrite_async)      (GFile                *file,

  471. 						       GFileCreateFlags      flags,

  472.                                                        int                   io_priority,

  473.                                                        GCancellable         *cancellable,

  474.                                                        GAsyncReadyCallback   callback,

  475.                                                        gpointer              user_data);

  476.   GFileIOStream *     (* create_readwrite_finish)      (GFile                *file,

  477.                                                        GAsyncResult         *res,

  478.                                                        GError              **error);

  479.   GFileIOStream *     (* replace_readwrite)           (GFile                *file,

  480.                                                        const char           *etag,

  481.                                                        gboolean              make_backup,

  482.                                                        GFileCreateFlags      flags,

  483.                                                        GCancellable         *cancellable,

  484.                                                        GError              **error);

  485.   void                (* replace_readwrite_async)     (GFile                *file,

  486.                                                        const char           *etag,

  487.                                                        gboolean              make_backup,

  488.                                                        GFileCreateFlags      flags,

  489.                                                        int                   io_priority,

  490.                                                        GCancellable         *cancellable,

  491.                                                        GAsyncReadyCallback   callback,

  492.                                                        gpointer              user_data);

  493.   GFileIOStream *     (* replace_readwrite_finish)    (GFile                *file,

  494.                                                        GAsyncResult         *res,

  495.                                                        GError              **error);

  496. 

  497.   void                (* start_mountable)             (GFile                *file,

  498.                                                        GDriveStartFlags      flags,

  499.                                                        GMountOperation      *start_operation,

  500.                                                        GCancellable         *cancellable,

  501.                                                        GAsyncReadyCallback   callback,

  502.                                                        gpointer              user_data);

  503.   gboolean            (* start_mountable_finish)      (GFile                *file,

  504.                                                        GAsyncResult         *result,

  505.                                                        GError              **error);

  506. 

  507.   void                (* stop_mountable)              (GFile                *file,

  508.                                                        GMountUnmountFlags    flags,

  509.                                                        GMountOperation      *mount_operation,

  510.                                                        GCancellable         *cancellable,

  511.                                                        GAsyncReadyCallback   callback,

  512.                                                        gpointer              user_data);

  513.   gboolean            (* stop_mountable_finish)       (GFile                *file,

  514.                                                        GAsyncResult         *result,

  515.                                                        GError              **error);

  516. 

  517.   gboolean            supports_thread_contexts;

  518. 

  519.   void                (* unmount_mountable_with_operation) (GFile           *file,

  520.                                                        GMountUnmountFlags    flags,

  521.                                                        GMountOperation      *mount_operation,

  522.                                                        GCancellable         *cancellable,

  523.                                                        GAsyncReadyCallback   callback,

  524.                                                        gpointer              user_data);

  525.   gboolean            (* unmount_mountable_with_operation_finish) (GFile    *file,

  526.                                                        GAsyncResult         *result,

  527.                                                        GError              **error);

  528. 

  529.   void                (* eject_mountable_with_operation) (GFile             *file,

  530.                                                        GMountUnmountFlags    flags,

  531.                                                        GMountOperation      *mount_operation,

  532.                                                        GCancellable         *cancellable,

  533.                                                        GAsyncReadyCallback   callback,

  534.                                                        gpointer              user_data);

  535.   gboolean            (* eject_mountable_with_operation_finish) (GFile      *file,

  536.                                                        GAsyncResult         *result,

  537.                                                        GError              **error);

  538. 

  539.   void                (* poll_mountable)              (GFile                *file,

  540.                                                        GCancellable         *cancellable,

  541.                                                        GAsyncReadyCallback   callback,

  542.                                                        gpointer              user_data);

  543.   gboolean            (* poll_mountable_finish)       (GFile                *file,

  544.                                                        GAsyncResult         *result,

  545.                                                        GError              **error);

  546. };

  547. 

  548. GType                   g_file_get_type                   (void) G_GNUC_CONST;

  549. 

  550. GFile *                 g_file_new_for_path               (const char                 *path);

  551. GFile *                 g_file_new_for_uri                (const char                 *uri);

  552. GFile *                 g_file_new_for_commandline_arg    (const char                 *arg);

  553. GFile *                 g_file_parse_name                 (const char                 *parse_name);

  554. GFile *                 g_file_dup                        (GFile                      *file);

  555. guint                   g_file_hash                       (gconstpointer               file);

  556. gboolean                g_file_equal                      (GFile                      *file1,

  557. 							   GFile                      *file2);

  558. char *                  g_file_get_basename               (GFile                      *file);

  559. char *                  g_file_get_path                   (GFile                      *file);

  560. char *                  g_file_get_uri                    (GFile                      *file);

  561. char *                  g_file_get_parse_name             (GFile                      *file);

  562. GFile *                 g_file_get_parent                 (GFile                      *file);

  563. gboolean                g_file_has_parent                 (GFile                      *file,

  564.                                                            GFile                      *parent);

  565. GFile *                 g_file_get_child                  (GFile                      *file,

  566. 							   const char                 *name);

  567. GFile *                 g_file_get_child_for_display_name (GFile                      *file,

  568. 							   const char                 *display_name,

  569. 							   GError                    **error);

  570. gboolean                g_file_has_prefix                 (GFile                      *file,

  571. 							   GFile                      *prefix);

  572. char *                  g_file_get_relative_path          (GFile                      *parent,

  573. 							   GFile                      *descendant);

  574. GFile *                 g_file_resolve_relative_path      (GFile                      *file,

  575. 							   const char                 *relative_path);

  576. gboolean                g_file_is_native                  (GFile                      *file);

  577. gboolean                g_file_has_uri_scheme             (GFile                      *file,

  578. 							   const char                 *uri_scheme);

  579. char *                  g_file_get_uri_scheme             (GFile                      *file);

  580. GFileInputStream *      g_file_read                       (GFile                      *file,

  581. 							   GCancellable               *cancellable,

  582. 							   GError                    **error);

  583. void                    g_file_read_async                 (GFile                      *file,

  584. 							   int                         io_priority,

  585. 							   GCancellable               *cancellable,

  586. 							   GAsyncReadyCallback         callback,

  587. 							   gpointer                    user_data);

  588. GFileInputStream *      g_file_read_finish                (GFile                      *file,

  589. 							   GAsyncResult               *res,

  590. 							   GError                    **error);

  591. GFileOutputStream *     g_file_append_to                  (GFile                      *file,

  592. 							   GFileCreateFlags             flags,

  593. 							   GCancellable               *cancellable,

  594. 							   GError                    **error);

  595. GFileOutputStream *     g_file_create                     (GFile                      *file,

  596. 							   GFileCreateFlags             flags,

  597. 							   GCancellable               *cancellable,

  598. 							   GError                    **error);

  599. GFileOutputStream *     g_file_replace                    (GFile                      *file,

  600. 							   const char                 *etag,

  601. 							   gboolean                    make_backup,

  602. 							   GFileCreateFlags            flags,

  603. 							   GCancellable               *cancellable,

  604. 							   GError                    **error);

  605. void                    g_file_append_to_async            (GFile                      *file,

  606. 							   GFileCreateFlags            flags,

  607. 							   int                         io_priority,

  608. 							   GCancellable               *cancellable,

  609. 							   GAsyncReadyCallback         callback,

  610. 							   gpointer                    user_data);

  611. GFileOutputStream *     g_file_append_to_finish           (GFile                      *file,

  612. 							   GAsyncResult               *res,

  613. 							   GError                    **error);

  614. void                    g_file_create_async               (GFile                      *file,

  615. 							   GFileCreateFlags            flags,

  616. 							   int                         io_priority,

  617. 							   GCancellable               *cancellable,

  618. 							   GAsyncReadyCallback         callback,

  619. 							   gpointer                    user_data);

  620. GFileOutputStream *     g_file_create_finish              (GFile                      *file,

  621. 							   GAsyncResult               *res,

  622. 							   GError                    **error);

  623. void                    g_file_replace_async              (GFile                      *file,

  624. 							   const char                 *etag,

  625. 							   gboolean                    make_backup,

  626. 							   GFileCreateFlags            flags,

  627. 							   int                         io_priority,

  628. 							   GCancellable               *cancellable,

  629. 							   GAsyncReadyCallback         callback,

  630. 							   gpointer                    user_data);

  631. GFileOutputStream *     g_file_replace_finish             (GFile                      *file,

  632. 							   GAsyncResult               *res,

  633. 							   GError                    **error);

  634. GFileIOStream *         g_file_open_readwrite             (GFile                      *file,

  635. 							   GCancellable               *cancellable,

  636. 							   GError                    **error);

  637. void                    g_file_open_readwrite_async       (GFile                      *file,

  638. 							   int                         io_priority,

  639. 							   GCancellable               *cancellable,

  640. 							   GAsyncReadyCallback         callback,

  641. 							   gpointer                    user_data);

  642. GFileIOStream *         g_file_open_readwrite_finish      (GFile                      *file,

  643. 							   GAsyncResult               *res,

  644. 							   GError                    **error);

  645. GFileIOStream *         g_file_create_readwrite           (GFile                      *file,

  646. 							   GFileCreateFlags            flags,

  647. 							   GCancellable               *cancellable,

  648. 							   GError                    **error);

  649. void                    g_file_create_readwrite_async     (GFile                      *file,

  650. 							   GFileCreateFlags            flags,

  651. 							   int                         io_priority,

  652. 							   GCancellable               *cancellable,

  653. 							   GAsyncReadyCallback         callback,

  654. 							   gpointer                    user_data);

  655. GFileIOStream *         g_file_create_readwrite_finish    (GFile                      *file,

  656. 							   GAsyncResult               *res,

  657. 							   GError                    **error);

  658. GFileIOStream *         g_file_replace_readwrite          (GFile                      *file,

  659. 							   const char                 *etag,

  660. 							   gboolean                    make_backup,

  661. 							   GFileCreateFlags            flags,

  662. 							   GCancellable               *cancellable,

  663. 							   GError                    **error);

  664. void                    g_file_replace_readwrite_async    (GFile                      *file,

  665. 							   const char                 *etag,

  666. 							   gboolean                    make_backup,

  667. 							   GFileCreateFlags            flags,

  668. 							   int                         io_priority,

  669. 							   GCancellable               *cancellable,

  670. 							   GAsyncReadyCallback         callback,

  671. 							   gpointer                    user_data);

  672. GFileIOStream *         g_file_replace_readwrite_finish   (GFile                      *file,

  673. 							   GAsyncResult               *res,

  674. 							   GError                    **error);

  675. gboolean                g_file_query_exists               (GFile                      *file,

  676. 							   GCancellable               *cancellable);

  677. GFileType               g_file_query_file_type            (GFile                      *file,

  678.                                                            GFileQueryInfoFlags         flags,

  679.                                                            GCancellable               *cancellable);

  680. GFileInfo *             g_file_query_info                 (GFile                      *file,

  681. 							   const char                 *attributes,

  682. 							   GFileQueryInfoFlags         flags,

  683. 							   GCancellable               *cancellable,

  684. 							   GError                    **error);

  685. void                    g_file_query_info_async           (GFile                      *file,

  686. 							   const char                 *attributes,

  687. 							   GFileQueryInfoFlags         flags,

  688. 							   int                         io_priority,

  689. 							   GCancellable               *cancellable,

  690. 							   GAsyncReadyCallback         callback,

  691. 							   gpointer                    user_data);

  692. GFileInfo *             g_file_query_info_finish          (GFile                      *file,

  693. 							   GAsyncResult               *res,

  694. 							   GError                    **error);

  695. GFileInfo *             g_file_query_filesystem_info      (GFile                      *file,

  696. 							   const char                 *attributes,

  697. 							   GCancellable               *cancellable,

  698. 							   GError                    **error);

  699. void                    g_file_query_filesystem_info_async (GFile                      *file,

  700. 							   const char                 *attributes,

  701. 							   int                         io_priority,

  702. 							   GCancellable               *cancellable,

  703. 							   GAsyncReadyCallback         callback,

  704. 							   gpointer                    user_data);

  705. GFileInfo *             g_file_query_filesystem_info_finish (GFile                      *file,

  706.                                                            GAsyncResult               *res,

  707. 							   GError                    **error);

  708. GMount *                g_file_find_enclosing_mount       (GFile                      *file,

  709.                                                            GCancellable               *cancellable,

  710.                                                            GError                    **error);

  711. void                    g_file_find_enclosing_mount_async (GFile                      *file,

  712. 							   int                         io_priority,

  713. 							   GCancellable               *cancellable,

  714. 							   GAsyncReadyCallback         callback,

  715. 							   gpointer                    user_data);

  716. GMount *                g_file_find_enclosing_mount_finish (GFile                     *file,

  717. 							    GAsyncResult              *res,

  718. 							    GError                   **error);

  719. GFileEnumerator *       g_file_enumerate_children         (GFile                      *file,

  720. 							   const char                 *attributes,

  721. 							   GFileQueryInfoFlags         flags,

  722. 							   GCancellable               *cancellable,

  723. 							   GError                    **error);

  724. void                    g_file_enumerate_children_async   (GFile                      *file,

  725. 							   const char                 *attributes,

  726. 							   GFileQueryInfoFlags         flags,

  727. 							   int                         io_priority,

  728. 							   GCancellable               *cancellable,

  729. 							   GAsyncReadyCallback         callback,

  730. 							   gpointer                    user_data);

  731. GFileEnumerator *       g_file_enumerate_children_finish  (GFile                      *file,

  732. 							   GAsyncResult               *res,

  733. 							   GError                    **error);

  734. GFile *                 g_file_set_display_name           (GFile                      *file,

  735. 							   const char                 *display_name,

  736. 							   GCancellable               *cancellable,

  737. 							   GError                    **error);

  738. void                    g_file_set_display_name_async     (GFile                      *file,

  739. 							   const char                 *display_name,

  740. 							   int                         io_priority,

  741. 							   GCancellable               *cancellable,

  742. 							   GAsyncReadyCallback         callback,

  743. 							   gpointer                    user_data);

  744. GFile *                 g_file_set_display_name_finish    (GFile                      *file,

  745. 							   GAsyncResult               *res,

  746. 							   GError                    **error);

  747. gboolean                g_file_delete                     (GFile                      *file,

  748. 							   GCancellable               *cancellable,

  749. 							   GError                    **error);

  750. gboolean                g_file_trash                      (GFile                      *file,

  751. 							   GCancellable               *cancellable,

  752. 							   GError                    **error);

  753. gboolean                g_file_copy                       (GFile                      *source,

  754. 							   GFile                      *destination,

  755. 							   GFileCopyFlags              flags,

  756. 							   GCancellable               *cancellable,

  757. 							   GFileProgressCallback       progress_callback,

  758. 							   gpointer                    progress_callback_data,

  759. 							   GError                    **error);

  760. void                    g_file_copy_async                 (GFile                      *source,

  761. 							   GFile                      *destination,

  762. 							   GFileCopyFlags              flags,

  763. 							   int                         io_priority,

  764. 							   GCancellable               *cancellable,

  765. 							   GFileProgressCallback       progress_callback,

  766. 							   gpointer                    progress_callback_data,

  767. 							   GAsyncReadyCallback         callback,

  768. 							   gpointer                    user_data);

  769. gboolean                g_file_copy_finish                (GFile                      *file,

  770. 							   GAsyncResult               *res,

  771. 							   GError                    **error);

  772. gboolean                g_file_move                       (GFile                      *source,

  773. 							   GFile                      *destination,

  774. 							   GFileCopyFlags              flags,

  775. 							   GCancellable               *cancellable,

  776. 							   GFileProgressCallback       progress_callback,

  777. 							   gpointer                    progress_callback_data,

  778. 							   GError                    **error);

  779. gboolean                g_file_make_directory             (GFile                      *file,

  780. 							   GCancellable               *cancellable,

  781. 							   GError                    **error);

  782. gboolean                g_file_make_directory_with_parents (GFile                     *file,

  783. 		                                           GCancellable               *cancellable,

  784. 		                                           GError                    **error);

  785. gboolean                g_file_make_symbolic_link         (GFile                      *file,

  786. 							   const char                 *symlink_value,

  787. 							   GCancellable               *cancellable,

  788. 							   GError                    **error);

  789. GFileAttributeInfoList *g_file_query_settable_attributes  (GFile                      *file,

  790. 							   GCancellable               *cancellable,

  791. 							   GError                    **error);

  792. GFileAttributeInfoList *g_file_query_writable_namespaces  (GFile                      *file,

  793. 							   GCancellable               *cancellable,

  794. 							   GError                    **error);

  795. gboolean                g_file_set_attribute              (GFile                      *file,

  796. 							   const char                 *attribute,

  797. 							   GFileAttributeType          type,

  798. 							   gpointer                    value_p,

  799. 							   GFileQueryInfoFlags         flags,

  800. 							   GCancellable               *cancellable,

  801. 							   GError                    **error);

  802. gboolean                g_file_set_attributes_from_info   (GFile                      *file,

  803. 							   GFileInfo                  *info,

  804. 							   GFileQueryInfoFlags         flags,

  805. 							   GCancellable               *cancellable,

  806. 							   GError                    **error);

  807. void                    g_file_set_attributes_async       (GFile                      *file,

  808. 							   GFileInfo                  *info,

  809. 							   GFileQueryInfoFlags         flags,

  810. 							   int                         io_priority,

  811. 							   GCancellable               *cancellable,

  812. 							   GAsyncReadyCallback         callback,

  813. 							   gpointer                    user_data);

  814. gboolean                g_file_set_attributes_finish      (GFile                      *file,

  815. 							   GAsyncResult               *result,

  816. 							   GFileInfo                 **info,

  817. 							   GError                    **error);

  818. gboolean                g_file_set_attribute_string       (GFile                      *file,

  819. 							   const char                 *attribute,

  820. 							   const char                 *value,

  821. 							   GFileQueryInfoFlags         flags,

  822. 							   GCancellable               *cancellable,

  823. 							   GError                    **error);

  824. gboolean                g_file_set_attribute_byte_string  (GFile                      *file,

  825. 							   const char                 *attribute,

  826. 							   const char                 *value,

  827. 							   GFileQueryInfoFlags         flags,

  828. 							   GCancellable               *cancellable,

  829. 							   GError                    **error);

  830. gboolean                g_file_set_attribute_uint32       (GFile                      *file,

  831. 							   const char                 *attribute,

  832. 							   guint32                     value,

  833. 							   GFileQueryInfoFlags         flags,

  834. 							   GCancellable               *cancellable,

  835. 							   GError                    **error);

  836. gboolean                g_file_set_attribute_int32        (GFile                      *file,

  837. 							   const char                 *attribute,

  838. 							   gint32                      value,

  839. 							   GFileQueryInfoFlags         flags,

  840. 							   GCancellable               *cancellable,

  841. 							   GError                    **error);

  842. gboolean                g_file_set_attribute_uint64       (GFile                      *file,

  843. 							   const char                 *attribute,

  844. 							   guint64                     value,

  845. 							   GFileQueryInfoFlags         flags,

  846. 							   GCancellable               *cancellable,

  847. 							   GError                    **error);

  848. gboolean                g_file_set_attribute_int64        (GFile                      *file,

  849. 							   const char                 *attribute,

  850. 							   gint64                      value,

  851. 							   GFileQueryInfoFlags         flags,

  852. 							   GCancellable               *cancellable,

  853. 							   GError                    **error);

  854. void                    g_file_mount_enclosing_volume     (GFile                      *location,

  855. 							   GMountMountFlags            flags,

  856. 							   GMountOperation            *mount_operation,

  857. 							   GCancellable               *cancellable,

  858. 							   GAsyncReadyCallback         callback,

  859. 							   gpointer                    user_data);

  860. gboolean                g_file_mount_enclosing_volume_finish (GFile                      *location,

  861. 							   GAsyncResult               *result,

  862. 							   GError                    **error);

  863. void                    g_file_mount_mountable            (GFile                      *file,

  864. 							   GMountMountFlags            flags,

  865. 							   GMountOperation            *mount_operation,

  866. 							   GCancellable               *cancellable,

  867. 							   GAsyncReadyCallback         callback,

  868. 							   gpointer                    user_data);

  869. GFile *                 g_file_mount_mountable_finish     (GFile                      *file,

  870. 							   GAsyncResult               *result,

  871. 							   GError                    **error);

  872. #ifndef G_DISABLE_DEPRECATED

  873. void                    g_file_unmount_mountable          (GFile                      *file,

  874. 							   GMountUnmountFlags          flags,

  875. 							   GCancellable               *cancellable,

  876. 							   GAsyncReadyCallback         callback,

  877. 							   gpointer                    user_data);

  878. gboolean                g_file_unmount_mountable_finish   (GFile                      *file,

  879. 							   GAsyncResult               *result,

  880. 							   GError                    **error);

  881. #endif

  882. void                    g_file_unmount_mountable_with_operation (GFile                *file,

  883. 							   GMountUnmountFlags          flags,

  884. 							   GMountOperation            *mount_operation,

  885. 							   GCancellable               *cancellable,

  886. 							   GAsyncReadyCallback         callback,

  887. 							   gpointer                    user_data);

  888. gboolean                g_file_unmount_mountable_with_operation_finish (GFile         *file,

  889. 							   GAsyncResult               *result,

  890. 							   GError                    **error);

  891. #ifndef G_DISABLE_DEPRECATED

  892. void                    g_file_eject_mountable            (GFile                      *file,

  893. 							   GMountUnmountFlags          flags,

  894. 							   GCancellable               *cancellable,

  895. 							   GAsyncReadyCallback         callback,

  896. 							   gpointer                    user_data);

  897. gboolean                g_file_eject_mountable_finish     (GFile                      *file,

  898. 							   GAsyncResult               *result,

  899. 							   GError                    **error);

  900. #endif

  901. void                    g_file_eject_mountable_with_operation (GFile                  *file,

  902. 							   GMountUnmountFlags          flags,

  903. 							   GMountOperation            *mount_operation,

  904. 							   GCancellable               *cancellable,

  905. 							   GAsyncReadyCallback         callback,

  906. 							   gpointer                    user_data);

  907. gboolean                g_file_eject_mountable_with_operation_finish (GFile           *file,

  908. 							   GAsyncResult               *result,

  909. 							   GError                    **error);

  910. 

  911. gboolean                g_file_copy_attributes            (GFile                      *source,

  912. 							   GFile                      *destination,

  913. 							   GFileCopyFlags              flags,

  914. 							   GCancellable               *cancellable,

  915. 							   GError                    **error);

  916. 

  917. 

  918. GFileMonitor*           g_file_monitor_directory          (GFile                  *file,

  919. 							   GFileMonitorFlags       flags,

  920. 							   GCancellable           *cancellable,

  921. 							   GError                **error);

  922. GFileMonitor*           g_file_monitor_file               (GFile                  *file,

  923. 							   GFileMonitorFlags       flags,

  924. 							   GCancellable           *cancellable,

  925. 							   GError                **error);

  926. GFileMonitor*           g_file_monitor                    (GFile                  *file,

  927. 							   GFileMonitorFlags       flags,

  928. 							   GCancellable           *cancellable,

  929. 							   GError                **error);

  930. 

  931. void                    g_file_start_mountable            (GFile                      *file,

  932. 							   GDriveStartFlags            flags,

  933. 							   GMountOperation            *start_operation,

  934. 							   GCancellable               *cancellable,

  935. 							   GAsyncReadyCallback         callback,

  936. 							   gpointer                    user_data);

  937. gboolean                g_file_start_mountable_finish     (GFile                      *file,

  938. 							   GAsyncResult               *result,

  939. 							   GError                    **error);

  940. void                    g_file_stop_mountable             (GFile                      *file,

  941. 							   GMountUnmountFlags          flags,

  942.                                                            GMountOperation            *mount_operation,

  943. 							   GCancellable               *cancellable,

  944. 							   GAsyncReadyCallback         callback,

  945. 							   gpointer                    user_data);

  946. gboolean                g_file_stop_mountable_finish      (GFile                      *file,

  947. 							   GAsyncResult               *result,

  948. 							   GError                    **error);

  949. 

  950. void                    g_file_poll_mountable             (GFile                      *file,

  951. 							   GCancellable               *cancellable,

  952. 							   GAsyncReadyCallback         callback,

  953. 							   gpointer                    user_data);

  954. gboolean                g_file_poll_mountable_finish      (GFile                      *file,

  955. 							   GAsyncResult               *result,

  956. 							   GError                    **error);

  957. 

  958. /* Utilities */

  959. 

  960. GAppInfo *g_file_query_default_handler       (GFile                  *file,

  961. 					      GCancellable           *cancellable,

  962. 					      GError                **error);

  963. gboolean g_file_load_contents                (GFile                  *file,

  964. 					      GCancellable           *cancellable,

  965. 					      char                  **contents,

  966. 					      gsize                  *length,

  967. 					      char                  **etag_out,

  968. 					      GError                **error);

  969. void     g_file_load_contents_async          (GFile                  *file,

  970. 					      GCancellable           *cancellable,

  971. 					      GAsyncReadyCallback     callback,

  972. 					      gpointer                user_data);

  973. gboolean g_file_load_contents_finish         (GFile                  *file,

  974. 					      GAsyncResult           *res,

  975. 					      char                  **contents,

  976. 					      gsize                  *length,

  977. 					      char                  **etag_out,

  978. 					      GError                **error);

  979. void     g_file_load_partial_contents_async  (GFile                  *file,

  980. 					      GCancellable           *cancellable,

  981. 					      GFileReadMoreCallback   read_more_callback,

  982. 					      GAsyncReadyCallback     callback,

  983. 					      gpointer                user_data);

  984. gboolean g_file_load_partial_contents_finish (GFile                  *file,

  985. 					      GAsyncResult           *res,

  986. 					      char                  **contents,

  987. 					      gsize                  *length,

  988. 					      char                  **etag_out,

  989. 					      GError                **error);

  990. gboolean g_file_replace_contents             (GFile                  *file,

  991. 					      const char             *contents,

  992. 					      gsize                   length,

  993. 					      const char             *etag,

  994. 					      gboolean                make_backup,

  995. 					      GFileCreateFlags        flags,

  996. 					      char                  **new_etag,

  997. 					      GCancellable           *cancellable,

  998. 					      GError                **error);

  999. void     g_file_replace_contents_async       (GFile                  *file,

  1000. 					      const char             *contents,

  1001. 					      gsize                   length,

  1002. 					      const char             *etag,

  1003. 					      gboolean                make_backup,

  1004. 					      GFileCreateFlags        flags,

  1005. 					      GCancellable           *cancellable,

  1006. 					      GAsyncReadyCallback     callback,

  1007. 					      gpointer                user_data);

  1008. gboolean g_file_replace_contents_finish      (GFile                  *file,

  1009. 					      GAsyncResult           *res,

  1010. 					      char                  **new_etag,

  1011. 					      GError                **error);

  1012. 

  1013. gboolean g_file_supports_thread_contexts     (GFile                  *file);

  1014. 

  1015. G_END_DECLS

  1016. 

  1017. #endif /* __G_FILE_H__ */