<FUNCTION>
<NAME>gnome_vfs_init</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_initialized</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_shutdown</NAME>
<RETURNS>void     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_loadinit</NAME>
<DEPRECATED/>
<RETURNS>void     </RETURNS>
gpointer app,gpointer modinfo
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_preinit</NAME>
<DEPRECATED/>
<RETURNS>void     </RETURNS>
gpointer app,gpointer modinfo
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_postinit</NAME>
<DEPRECATED/>
<RETURNS>void     </RETURNS>
gpointer app,gpointer modinfo
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSMethodHandle</NAME>
typedef gpointer GnomeVFSMethodHandle;
</TYPEDEF>
<TYPEDEF>
<NAME>GnomeVFSHandle</NAME>
typedef struct GnomeVFSHandle GnomeVFSHandle;
</TYPEDEF>
<ENUM>
<NAME>GnomeVFSOpenMode</NAME>
typedef enum {
        GNOME_VFS_OPEN_NONE = 0,
        GNOME_VFS_OPEN_READ = 1 << 0,
        GNOME_VFS_OPEN_WRITE = 1 << 1,
        GNOME_VFS_OPEN_RANDOM = 1 << 2,
	GNOME_VFS_OPEN_TRUNCATE = 1 << 3
} GnomeVFSOpenMode;
</ENUM>
<ENUM>
<NAME>GnomeVFSSeekPosition</NAME>
typedef enum {
        GNOME_VFS_SEEK_START,
        GNOME_VFS_SEEK_CURRENT,
        GNOME_VFS_SEEK_END
} GnomeVFSSeekPosition;
</ENUM>
<TYPEDEF>
<NAME>GnomeVFSTransform</NAME>
typedef struct GnomeVFSTransform GnomeVFSTransform;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSTransformInitFunc</NAME>
<RETURNS>GnomeVFSTransform *</RETURNS>
const char        *method_name,
							   const char        *config_args
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSTransformFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSTransform *transform,
							   const char        *old_uri,
							   char             **new_uri,
							   GnomeVFSContext   *context
</USER_FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSInetConnection</NAME>
typedef struct GnomeVFSInetConnection GnomeVFSInetConnection;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_create</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSInetConnection **connection_return,const gchar *host_name,guint host_port,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_create_from_address</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSInetConnection **connection_return,GnomeVFSAddress         *address,guint                    host_port,GnomeVFSCancellation    *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_destroy</NAME>
<RETURNS>void 	</RETURNS>
GnomeVFSInetConnection *connection,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_free</NAME>
<RETURNS>void 	</RETURNS>
GnomeVFSInetConnection *connection,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_to_socket</NAME>
<RETURNS>GnomeVFSSocket  *</RETURNS>
GnomeVFSInetConnection *connection
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_to_socket_buffer</NAME>
<RETURNS>GnomeVFSSocketBuffer  *</RETURNS>
GnomeVFSInetConnection *connection
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_get_fd</NAME>
<RETURNS>int </RETURNS>
GnomeVFSInetConnection *connection
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_get_ip</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSInetConnection *connection
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_inet_connection_get_address</NAME>
<RETURNS>GnomeVFSAddress  *</RETURNS>
GnomeVFSInetConnection *connection
</FUNCTION>
<MACRO>
<NAME>DESKTOP_ENTRY_GROUP</NAME>
<DEPRECATED/>
#define DESKTOP_ENTRY_GROUP "Desktop Entry"
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_mime_get_all_desktop_entries</NAME>
<DEPRECATED/>
<RETURNS>GList              *</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_desktop_entry</NAME>
<DEPRECATED/>
<RETURNS>gchar              *</RETURNS>
const char *mime_type
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_MIME_TYPE_UNKNOWN</NAME>
#define GNOME_VFS_MIME_TYPE_UNKNOWN "application/octet-stream"
</MACRO>
<ENUM>
<NAME>GnomeVFSMimeEquivalence</NAME>
typedef enum {
  GNOME_VFS_MIME_UNRELATED,
  GNOME_VFS_MIME_IDENTICAL,
  GNOME_VFS_MIME_PARENT
} GnomeVFSMimeEquivalence;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_mime_type_get_equivalence</NAME>
<RETURNS>GnomeVFSMimeEquivalence </RETURNS>
const char    *mime_type,const char    *base_mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_is_equal</NAME>
<RETURNS>gboolean                </RETURNS>
const char    *a,const char    *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_for_name</NAME>
<RETURNS>const char             *</RETURNS>
const char *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_for_data</NAME>
<RETURNS>const char             *</RETURNS>
gconstpointer  data,int            data_size
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_for_name_and_data</NAME>
<RETURNS>const char             *</RETURNS>
const char    *filename,gconstpointer  data,gssize         data_size
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type</NAME>
<RETURNS>char                   *</RETURNS>
const char    *text_uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_slow_mime_type</NAME>
<RETURNS>char                   *</RETURNS>
const char    *text_uri
</FUNCTION>
<STRUCT>
<NAME>GnomeVFSURI</NAME>
typedef struct GnomeVFSURI {
	/*< public >*/
	guint ref_count;

	gchar *text;
	gchar *fragment_id;

	gchar *method_string;
	struct GnomeVFSMethod *method;

	struct GnomeVFSURI *parent;

	/*< private >*/
	/* Reserved to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSURI;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSToplevelURI</NAME>
typedef struct {
	GnomeVFSURI uri;

	/*< public >*/
	gchar *host_name;
	guint host_port;

	gchar *user_name;
	gchar *password;

	gchar *urn;

	/*< private >*/
	/* Reserved to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSToplevelURI;
</STRUCT>
<ENUM>
<NAME>GnomeVFSURIHideOptions</NAME>
typedef enum
{
	GNOME_VFS_URI_HIDE_NONE = 0,
	GNOME_VFS_URI_HIDE_USER_NAME = 1 << 0,
	GNOME_VFS_URI_HIDE_PASSWORD = 1 << 1,
	GNOME_VFS_URI_HIDE_HOST_NAME = 1 << 2,
	GNOME_VFS_URI_HIDE_HOST_PORT = 1 << 3,
	GNOME_VFS_URI_HIDE_TOPLEVEL_METHOD = 1 << 4,
	GNOME_VFS_URI_HIDE_FRAGMENT_IDENTIFIER = 1 << 8
} GnomeVFSURIHideOptions; 
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_uri_hide_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_URI_HIDE_OPTIONS</NAME>
#define GNOME_VFS_TYPE_VFS_URI_HIDE_OPTIONS (gnome_vfs_uri_hide_options_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_URI_MAGIC_CHR</NAME>
#define GNOME_VFS_URI_MAGIC_CHR	'#'
</MACRO>
<MACRO>
<NAME>GNOME_VFS_URI_MAGIC_STR</NAME>
#define GNOME_VFS_URI_MAGIC_STR "#"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_URI_PATH_CHR</NAME>
#define GNOME_VFS_URI_PATH_CHR '/'
</MACRO>
<MACRO>
<NAME>GNOME_VFS_URI_PATH_STR</NAME>
#define GNOME_VFS_URI_PATH_STR "/"
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_uri_new</NAME>
<RETURNS>GnomeVFSURI 	     *</RETURNS>
const gchar *text_uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_resolve_relative</NAME>
<RETURNS>GnomeVFSURI 	     *</RETURNS>
const GnomeVFSURI *base,const gchar *relative_reference
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_resolve_symbolic_link</NAME>
<RETURNS>GnomeVFSURI 	     *</RETURNS>
const GnomeVFSURI *base,const gchar *relative_reference
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_ref</NAME>
<RETURNS>GnomeVFSURI 	     *</RETURNS>
GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_unref</NAME>
<RETURNS>void        	      </RETURNS>
GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_append_string</NAME>
<RETURNS>GnomeVFSURI          *</RETURNS>
const GnomeVFSURI *uri,const char *uri_fragment
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_append_path</NAME>
<RETURNS>GnomeVFSURI          *</RETURNS>
const GnomeVFSURI *uri,const char *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_append_file_name</NAME>
<RETURNS>GnomeVFSURI          *</RETURNS>
const GnomeVFSURI *uri,const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_to_string</NAME>
<RETURNS>gchar       	     *</RETURNS>
const GnomeVFSURI *uri,GnomeVFSURIHideOptions hide_options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_dup</NAME>
<RETURNS>GnomeVFSURI 	     *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_is_local</NAME>
<RETURNS>gboolean    	      </RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_has_parent</NAME>
<RETURNS>gboolean	      </RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_parent</NAME>
<RETURNS>GnomeVFSURI	     *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_toplevel</NAME>
<RETURNS>GnomeVFSToplevelURI *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_host_name</NAME>
<RETURNS>const gchar 	    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_scheme</NAME>
<RETURNS>const gchar         *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_host_port</NAME>
<RETURNS>guint 	    	     </RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_user_name</NAME>
<RETURNS>const gchar 	    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_password</NAME>
<RETURNS>const gchar	    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_set_host_name</NAME>
<RETURNS>void		     </RETURNS>
GnomeVFSURI *uri,const gchar *host_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_set_host_port</NAME>
<RETURNS>void 	    	     </RETURNS>
GnomeVFSURI *uri,guint host_port
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_set_user_name</NAME>
<RETURNS>void		     </RETURNS>
GnomeVFSURI *uri,const gchar *user_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_set_password</NAME>
<RETURNS>void		     </RETURNS>
GnomeVFSURI *uri,const gchar *password
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_equal</NAME>
<RETURNS>gboolean	     </RETURNS>
const GnomeVFSURI *a,const GnomeVFSURI *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_is_parent</NAME>
<RETURNS>gboolean	     </RETURNS>
const GnomeVFSURI *possible_parent,const GnomeVFSURI *possible_child,gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_path</NAME>
<RETURNS>const gchar 	    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_get_fragment_identifier</NAME>
<RETURNS>const gchar 	    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_extract_dirname</NAME>
<RETURNS>gchar 		    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_extract_short_name</NAME>
<RETURNS>gchar		    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_extract_short_path_name</NAME>
<RETURNS>gchar		    *</RETURNS>
const GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_hequal</NAME>
<RETURNS>gint		     </RETURNS>
gconstpointer a,gconstpointer b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_hash</NAME>
<RETURNS>guint		     </RETURNS>
gconstpointer p
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_list_parse</NAME>
<RETURNS>GList               *</RETURNS>
const gchar* uri_list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_list_ref</NAME>
<RETURNS>GList               *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_list_unref</NAME>
<RETURNS>GList               *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_list_copy</NAME>
<RETURNS>GList               *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_list_free</NAME>
<RETURNS>void                 </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_make_full_from_relative</NAME>
<RETURNS>char                *</RETURNS>
const char *base_uri,const char *relative_uri
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_DRIVE</NAME>
#define GNOME_VFS_TYPE_DRIVE        (gnome_vfs_drive_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_DRIVE</NAME>
#define GNOME_VFS_DRIVE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_TYPE_DRIVE, GnomeVFSDrive))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_DRIVE_CLASS</NAME>
#define GNOME_VFS_DRIVE_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_TYPE_DRIVE, GnomeVFSDriveClass))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_DRIVE</NAME>
#define GNOME_IS_VFS_DRIVE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_TYPE_DRIVE))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_DRIVE_CLASS</NAME>
#define GNOME_IS_VFS_DRIVE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_TYPE_DRIVE))
</MACRO>
<STRUCT>
<NAME>GnomeVFSDrivePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSDrive</NAME>
struct _GnomeVFSDrive {
	GObject parent;

	/*< private >*/
        GnomeVFSDrivePrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSDriveClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSDriveClass</NAME>
struct _GnomeVFSDriveClass {
	GObjectClass parent_class;

	void (* volume_mounted)	  	(GnomeVFSDrive *drive,
				   	 GnomeVFSVolume	*volume);
	void (* volume_pre_unmount)	(GnomeVFSDrive *drive,
				   	 GnomeVFSVolume	*volume);
	void (* volume_unmounted)	(GnomeVFSDrive *drive,
				   	 GnomeVFSVolume	*volume);
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_drive_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_ref</NAME>
<RETURNS>GnomeVFSDrive *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_unref</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_volume_list_free</NAME>
<RETURNS>void           </RETURNS>
GList *volumes
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_id</NAME>
<RETURNS>gulong             </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_device_type</NAME>
<RETURNS>GnomeVFSDeviceType </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_mounted_volume</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSVolume *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_mounted_volumes</NAME>
<RETURNS>GList *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_device_path</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_activation_uri</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_display_name</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_icon</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_get_hal_udi</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_is_user_visible</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_is_connected</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_is_mounted</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_needs_eject</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSDrive *drive
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_compare</NAME>
<RETURNS>gint               </RETURNS>
GnomeVFSDrive *a,GnomeVFSDrive *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_mount</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDrive             *drive,GnomeVFSVolumeOpCallback   callback,gpointer                   user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_unmount</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDrive             *drive,GnomeVFSVolumeOpCallback   callback,gpointer                   user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_drive_eject</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDrive             *drive,GnomeVFSVolumeOpCallback   callback,gpointer                   user_data
</FUNCTION>
<ENUM>
<NAME>GnomeVFSMimeActionType</NAME>
<DEPRECATED/>
typedef enum {
	GNOME_VFS_MIME_ACTION_TYPE_NONE,
	GNOME_VFS_MIME_ACTION_TYPE_APPLICATION,
	GNOME_VFS_MIME_ACTION_TYPE_COMPONENT
} GnomeVFSMimeActionType;
</ENUM>
<STRUCT>
<NAME>GnomeVFSMimeAction</NAME>
<DEPRECATED/>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSMimeAction</NAME>
<DEPRECATED/>
struct _GnomeVFSMimeAction {
	/* <public >*/
	GnomeVFSMimeActionType action_type;
	union {
		void *component;
		void *dummy_component;
		GnomeVFSMimeApplication *application;
	} action;

	/*< private >*/
	/* Padded to avoid future breaks in ABI compatibility */
	void *reserved1;
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_action_type</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSMimeActionType   </RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_action</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSMimeAction *</RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_new_from_id</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSMimeApplication *</RETURNS>
const char              *id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_action_free</NAME>
<DEPRECATED/>
<RETURNS>void                     </RETURNS>
GnomeVFSMimeAction      *action
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_action_launch</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
GnomeVFSMimeAction      *action,GList                   *uris
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_action_launch_with_env</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
GnomeVFSMimeAction      *action,GList                   *uris,char                   **envp
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_icon</NAME>
<DEPRECATED/>
<RETURNS>const char  		*</RETURNS>
const char 		    *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_id_in_application_list</NAME>
<DEPRECATED/>
<RETURNS>gboolean                 </RETURNS>
const char              *id,GList                   *applications
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_application_from_list</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
GList                   *applications,const char              *application_id,gboolean                *did_remove
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_id_list_from_application_list</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
GList                   *applications
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_add_extension</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *extension
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_extension</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *extension
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_default_action_type</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,GnomeVFSMimeActionType   action_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_default_application</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *application_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_default_component</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *component_iid
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_icon</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult  	 </RETURNS>
const char 		    *mime_type,const char		    *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_description</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult		 </RETURNS>
const char		    *mime_type,const char		    *description
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_can_be_executable</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult	 	 </RETURNS>
const char              *mime_type,gboolean		     new_value
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_extend_all_applications</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,GList                   *application_ids
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_from_all_applications</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,GList                   *application_ids
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_short_list_applications</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_short_list_applications</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,GList                   *application_ids
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_short_list_components</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,GList                   *component_iids
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_add_application_to_short_list</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *application_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_application_from_short_list</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *application_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_add_component_to_short_list</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *iid
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_component_from_short_list</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult           </RETURNS>
const char              *mime_type,const char              *iid
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_component</NAME>
<DEPRECATED/>
<RETURNS>Bonobo_ServerInfo *</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_component</NAME>
<DEPRECATED/>
<RETURNS>void *</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_all_components</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_component_list_free</NAME>
<DEPRECATED/>
<RETURNS>void     </RETURNS>
GList      *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_remove_component_from_list</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
GList      *components,const char *iid,gboolean   *did_remove
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_id_list_from_component_list</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
GList      *components
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_id_in_component_list</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
const char *iid,GList      *components
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_short_list_components</NAME>
<DEPRECATED/>
<RETURNS>GList *</RETURNS>
const char *mime_type
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_MAJOR_VERSION</NAME>
#define GNOME_VFS_MAJOR_VERSION			(2)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MINOR_VERSION</NAME>
#define GNOME_VFS_MINOR_VERSION			(23)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MICRO_VERSION</NAME>
#define GNOME_VFS_MICRO_VERSION			(0)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_CHECK_VERSION</NAME>
#define	GNOME_VFS_CHECK_VERSION(major,minor,micro)	\
    (GNOME_VFS_MAJOR_VERSION > (major) || \
     (GNOME_VFS_MAJOR_VERSION == (major) && \
      GNOME_VFS_MINOR_VERSION > (minor)) || \
     (GNOME_VFS_MAJOR_VERSION == (major) && \
      GNOME_VFS_MINOR_VERSION == (minor) && \
      GNOME_VFS_MICRO_VERSION >= (micro)))
</MACRO>
<MACRO>
<NAME>S_ISUID</NAME>
#define S_ISUID 0
</MACRO>
<MACRO>
<NAME>S_ISGID</NAME>
#define S_ISGID 0
</MACRO>
<MACRO>
<NAME>S_IRGRP</NAME>
#define S_IRGRP (S_IRUSR >> 3)
</MACRO>
<MACRO>
<NAME>S_IWGRP</NAME>
#define S_IWGRP (S_IWUSR >> 3)
</MACRO>
<MACRO>
<NAME>S_IXGRP</NAME>
#define S_IXGRP (S_IXUSR >> 3)
</MACRO>
<MACRO>
<NAME>S_IROTH</NAME>
#define S_IROTH (S_IRUSR >> 6)
</MACRO>
<MACRO>
<NAME>S_IWOTH</NAME>
#define S_IWOTH (S_IWUSR >> 6)
</MACRO>
<MACRO>
<NAME>S_IXOTH</NAME>
#define S_IXOTH (S_IXUSR >> 6)
</MACRO>
<TYPEDEF>
<NAME>GnomeVFSInodeNumber</NAME>
typedef GnomeVFSFileSize GnomeVFSInodeNumber;
</TYPEDEF>
<ENUM>
<NAME>GnomeVFSFileFlags</NAME>
typedef enum {
	GNOME_VFS_FILE_FLAGS_NONE = 0,
	GNOME_VFS_FILE_FLAGS_SYMLINK = 1 << 0,
	GNOME_VFS_FILE_FLAGS_LOCAL = 1 << 1
} GnomeVFSFileFlags;
</ENUM>
<ENUM>
<NAME>GnomeVFSFileType</NAME>
typedef enum {
	GNOME_VFS_FILE_TYPE_UNKNOWN,
	GNOME_VFS_FILE_TYPE_REGULAR,
	GNOME_VFS_FILE_TYPE_DIRECTORY,
	GNOME_VFS_FILE_TYPE_FIFO,
	GNOME_VFS_FILE_TYPE_SOCKET,
	GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE,
	GNOME_VFS_FILE_TYPE_BLOCK_DEVICE,
	GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK
} GnomeVFSFileType;
</ENUM>
<ENUM>
<NAME>GnomeVFSFileInfoFields</NAME>
typedef enum {
	GNOME_VFS_FILE_INFO_FIELDS_NONE = 0,
	GNOME_VFS_FILE_INFO_FIELDS_TYPE = 1 << 0,
	GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS = 1 << 1,
	GNOME_VFS_FILE_INFO_FIELDS_FLAGS = 1 << 2,
	GNOME_VFS_FILE_INFO_FIELDS_DEVICE = 1 << 3,
	GNOME_VFS_FILE_INFO_FIELDS_INODE = 1 << 4,
	GNOME_VFS_FILE_INFO_FIELDS_LINK_COUNT = 1 << 5,
	GNOME_VFS_FILE_INFO_FIELDS_SIZE = 1 << 6,
	GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT = 1 << 7,
	GNOME_VFS_FILE_INFO_FIELDS_IO_BLOCK_SIZE = 1 << 8,
	GNOME_VFS_FILE_INFO_FIELDS_ATIME = 1 << 9,
	GNOME_VFS_FILE_INFO_FIELDS_MTIME = 1 << 10,
	GNOME_VFS_FILE_INFO_FIELDS_CTIME = 1 << 11,
	GNOME_VFS_FILE_INFO_FIELDS_SYMLINK_NAME = 1 << 12,
	GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE = 1 << 13,
	GNOME_VFS_FILE_INFO_FIELDS_ACCESS = 1 << 14,
	GNOME_VFS_FILE_INFO_FIELDS_IDS = 1 << 15,
	GNOME_VFS_FILE_INFO_FIELDS_ACL = 1 << 16,
	GNOME_VFS_FILE_INFO_FIELDS_SELINUX_CONTEXT = 1 << 17
} GnomeVFSFileInfoFields;
</ENUM>
<ENUM>
<NAME>GnomeVFSFilePermissions</NAME>
typedef enum {
	GNOME_VFS_PERM_SUID = S_ISUID,
	GNOME_VFS_PERM_SGID = S_ISGID,	
	GNOME_VFS_PERM_STICKY = 01000,	/* S_ISVTX not defined on all systems */
	GNOME_VFS_PERM_USER_READ = S_IRUSR,
	GNOME_VFS_PERM_USER_WRITE = S_IWUSR,
	GNOME_VFS_PERM_USER_EXEC = S_IXUSR,
	GNOME_VFS_PERM_USER_ALL = S_IRUSR | S_IWUSR | S_IXUSR,
	GNOME_VFS_PERM_GROUP_READ = S_IRGRP,
	GNOME_VFS_PERM_GROUP_WRITE = S_IWGRP,
	GNOME_VFS_PERM_GROUP_EXEC = S_IXGRP,
	GNOME_VFS_PERM_GROUP_ALL = S_IRGRP | S_IWGRP | S_IXGRP,
	GNOME_VFS_PERM_OTHER_READ = S_IROTH,
	GNOME_VFS_PERM_OTHER_WRITE = S_IWOTH,
	GNOME_VFS_PERM_OTHER_EXEC = S_IXOTH,
	GNOME_VFS_PERM_OTHER_ALL = S_IROTH | S_IWOTH | S_IXOTH,
	GNOME_VFS_PERM_ACCESS_READABLE   = 1 << 16,
	GNOME_VFS_PERM_ACCESS_WRITABLE   = 1 << 17,
	GNOME_VFS_PERM_ACCESS_EXECUTABLE = 1 << 18
} GnomeVFSFilePermissions;
</ENUM>
<MACRO>
<NAME>GNOME_VFS_TYPE_FILE_INFO</NAME>
#define GNOME_VFS_TYPE_FILE_INFO  (gnome_vfs_file_info_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeVFSFileInfo</NAME>
typedef struct {
	/*< public >*/
	char *name;

	GnomeVFSFileInfoFields valid_fields;
	GnomeVFSFileType type;
	GnomeVFSFilePermissions permissions;

	GnomeVFSFileFlags flags;

	dev_t device;
	GnomeVFSInodeNumber inode;

	guint link_count;

	guint uid;
	guint gid;

	GnomeVFSFileSize size;

	GnomeVFSFileSize block_count;

	guint io_block_size;

	time_t atime;
	time_t mtime;
	time_t ctime;

	char *symlink_name;

	char *mime_type;

	guint refcount;

	/* File ACLs */
	GnomeVFSACL *acl;

	/* SELinux security context. -- ascii string, raw format. */
	char* selinux_context;

	/*< private >*/
	/* Reserved for future expansions to GnomeVFSFileInfo without having
	   to break ABI compatibility */
	void *reserved1;
	void *reserved2;
	void *reserved3;
} GnomeVFSFileInfo;
</STRUCT>
<ENUM>
<NAME>GnomeVFSFileInfoOptions</NAME>
typedef enum {
	GNOME_VFS_FILE_INFO_DEFAULT = 0,
	GNOME_VFS_FILE_INFO_GET_MIME_TYPE = 1 << 0,
	GNOME_VFS_FILE_INFO_FORCE_FAST_MIME_TYPE = 1 << 1,
	GNOME_VFS_FILE_INFO_FORCE_SLOW_MIME_TYPE = 1 << 2,
	GNOME_VFS_FILE_INFO_FOLLOW_LINKS = 1 << 3,
	GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS = 1 << 4,
	GNOME_VFS_FILE_INFO_NAME_ONLY = 1 << 5,
	GNOME_VFS_FILE_INFO_GET_ACL = 1 << 6,
	GNOME_VFS_FILE_INFO_GET_SELINUX_CONTEXT = 1 << 7
} GnomeVFSFileInfoOptions;
</ENUM>
<ENUM>
<NAME>GnomeVFSSetFileInfoMask</NAME>
typedef enum {
	GNOME_VFS_SET_FILE_INFO_NONE = 0,
	GNOME_VFS_SET_FILE_INFO_NAME = 1 << 0,
	GNOME_VFS_SET_FILE_INFO_PERMISSIONS = 1 << 1,
	GNOME_VFS_SET_FILE_INFO_OWNER = 1 << 2,
	GNOME_VFS_SET_FILE_INFO_TIME = 1 << 3,
	GNOME_VFS_SET_FILE_INFO_ACL = 1 << 4,
	GNOME_VFS_SET_FILE_INFO_SELINUX_CONTEXT = 1 << 5,
	GNOME_VFS_SET_FILE_INFO_SYMLINK_NAME = 1 << 6
} GnomeVFSSetFileInfoMask;
</ENUM>
<STRUCT>
<NAME>GnomeVFSGetFileInfoResult</NAME>
struct _GnomeVFSGetFileInfoResult {
	GnomeVFSURI *uri;
	GnomeVFSResult result;
	GnomeVFSFileInfo *file_info;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSGetFileInfoResult</NAME>
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_get_file_info_result_get_type</NAME>
<RETURNS>GType                      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_info_result_dup</NAME>
<RETURNS>GnomeVFSGetFileInfoResult*</RETURNS>
GnomeVFSGetFileInfoResult *result
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_info_result_free</NAME>
<RETURNS>void                       </RETURNS>
GnomeVFSGetFileInfoResult *result
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SYMLINK</NAME>
#define GNOME_VFS_FILE_INFO_SYMLINK(info)		\
	((info)->flags & GNOME_VFS_FILE_FLAGS_SYMLINK)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SET_SYMLINK</NAME>
 #define GNOME_VFS_FILE_INFO_SET_SYMLINK(info, value) \
       ((info)->flags = (value ? \
       ((info)->flags | GNOME_VFS_FILE_FLAGS_SYMLINK) : \
       ((info)->flags & ~GNOME_VFS_FILE_FLAGS_SYMLINK)))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_LOCAL</NAME>
#define GNOME_VFS_FILE_INFO_LOCAL(info)			\
	((info)->flags & GNOME_VFS_FILE_FLAGS_LOCAL)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SET_LOCAL</NAME>
 #define GNOME_VFS_FILE_INFO_SET_LOCAL(info, value) \
       ((info)->flags = (value ? \
       ((info)->flags | GNOME_VFS_FILE_FLAGS_LOCAL) : \
       ((info)->flags & ~GNOME_VFS_FILE_FLAGS_LOCAL)))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SUID</NAME>
#define GNOME_VFS_FILE_INFO_SUID(info)			\
	((info)->permissions & GNOME_VFS_PERM_SUID)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SGID</NAME>
#define GNOME_VFS_FILE_INFO_SGID(info)			\
	((info)->permissions & GNOME_VFS_PERM_SGID)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_STICKY</NAME>
#define GNOME_VFS_FILE_INFO_STICKY(info)		\
	((info)->permissions & GNOME_VFS_PERM_STICKY)
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SET_SUID</NAME>
#define GNOME_VFS_FILE_INFO_SET_SUID(info, value)		\
       ((info)->flags = (value ? \
       ((info)->flags | GNOME_VFS_PERM_SUID) : \
       ((info)->flags & ~GNOME_VFS_PERM_SUID)))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SET_SGID</NAME>
#define GNOME_VFS_FILE_INFO_SET_SGID(info, value)		\
		((info)->flags = (value ? \
		((info)->flags | GNOME_VFS_PERM_SGID) : \
		((info)->flags & ~GNOME_VFS_PERM_SGID)))      
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_SET_STICKY</NAME>
#define GNOME_VFS_FILE_INFO_SET_STICKY(info, value)			\
	(value ? ((info)->permissions |= GNOME_VFS_PERM_STICKY)		\
	       : ((info)->permissions &= ~GNOME_VFS_PERM_STICKY))
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_info_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_new</NAME>
<RETURNS>GnomeVFSFileInfo *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_unref</NAME>
<RETURNS>void              </RETURNS>
GnomeVFSFileInfo       *info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_ref</NAME>
<RETURNS>void              </RETURNS>
GnomeVFSFileInfo       *info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_clear</NAME>
<RETURNS>void              </RETURNS>
GnomeVFSFileInfo       *info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GnomeVFSFileInfo       *info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_copy</NAME>
<RETURNS>void              </RETURNS>
GnomeVFSFileInfo       *dest,const GnomeVFSFileInfo *src
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_dup</NAME>
<RETURNS>GnomeVFSFileInfo *</RETURNS>
const GnomeVFSFileInfo *orig
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_matches</NAME>
<RETURNS>gboolean          </RETURNS>
const GnomeVFSFileInfo *a,const GnomeVFSFileInfo *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_list_ref</NAME>
<RETURNS>GList *</RETURNS>
GList                  *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_list_unref</NAME>
<RETURNS>GList *</RETURNS>
GList                  *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_list_copy</NAME>
<RETURNS>GList *</RETURNS>
GList                  *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_info_list_free</NAME>
<RETURNS>void              </RETURNS>
GList                  *list
</FUNCTION>
<TYPEDEF>
<NAME>XdgIconList</NAME>
typedef struct XdgIconList XdgIconList;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_mime_type_from_mode</NAME>
<RETURNS>const char *</RETURNS>
mode_t             mode
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_from_mode_or_default</NAME>
<RETURNS>const char *</RETURNS>
mode_t             mode,const char        *defaultv
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_stat_to_file_info</NAME>
<RETURNS>void            </RETURNS>
GnomeVFSFileInfo  *file_info,const struct stat *statptr
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_set_meta</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSFileInfo  *info,const char        *file_name,const char        *meta_key
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_set_meta_for_list</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSFileInfo  *info,const char        *file_name,const GList       *meta_keys
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_special_mime_type</NAME>
<RETURNS>const char     *</RETURNS>
GnomeVFSURI       *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_monitor_callback</NAME>
<RETURNS>void            </RETURNS>
GnomeVFSMethodHandle *method_handle,GnomeVFSURI *info_uri,GnomeVFSMonitorEventType event_type
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_ADDRESS</NAME>
#define GNOME_VFS_TYPE_ADDRESS  (gnome_vfs_address_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeVFSAddress</NAME>
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_address_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_new_from_string</NAME>
<RETURNS>GnomeVFSAddress *</RETURNS>
const char      *address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_new_from_ipv4</NAME>
<RETURNS>GnomeVFSAddress *</RETURNS>
guint32          ipv4_address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_new_from_sockaddr</NAME>
<RETURNS>GnomeVFSAddress *</RETURNS>
struct sockaddr *sa,int              len
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_get_family_type</NAME>
<RETURNS>int              </RETURNS>
GnomeVFSAddress *address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_to_string</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSAddress *address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_get_ipv4</NAME>
<RETURNS>guint32          </RETURNS>
GnomeVFSAddress *address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_get_sockaddr</NAME>
<RETURNS>struct sockaddr *</RETURNS>
GnomeVFSAddress *address,guint16          port,int             *len
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_equal</NAME>
<RETURNS>gboolean         </RETURNS>
const GnomeVFSAddress *a,const GnomeVFSAddress *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_match</NAME>
<RETURNS>gboolean         </RETURNS>
const GnomeVFSAddress *a,const GnomeVFSAddress *b,guint             prefix
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_dup</NAME>
<RETURNS>GnomeVFSAddress *</RETURNS>
GnomeVFSAddress *address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_address_free</NAME>
<RETURNS>void             </RETURNS>
GnomeVFSAddress *address
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSSocketBuffer</NAME>
typedef struct GnomeVFSSocketBuffer GnomeVFSSocketBuffer;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_new</NAME>
<RETURNS>GnomeVFSSocketBuffer*</RETURNS>
GnomeVFSSocket       *socket
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_destroy</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,gboolean              close_socket,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_read</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,gpointer              buffer,GnomeVFSFileSize      bytes,GnomeVFSFileSize     *bytes_read,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_read_until</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,gpointer buffer,GnomeVFSFileSize bytes,gconstpointer boundary,GnomeVFSFileSize boundary_len,GnomeVFSFileSize *bytes_read,gboolean *got_boundary,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_peekc</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,char                 *character,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_write</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,gconstpointer         buffer,GnomeVFSFileSize      bytes,GnomeVFSFileSize     *bytes_written,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_buffer_flush</NAME>
<RETURNS>GnomeVFSResult        </RETURNS>
GnomeVFSSocketBuffer *socket_buffer,GnomeVFSCancellation *cancellation
</FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSModuleCallback</NAME>
<RETURNS>void </RETURNS>
gconstpointer in,
					 gsize         in_size,
					 gpointer      out,
					 gsize         out_size,
					 gpointer      callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSModuleCallbackResponse</NAME>
<RETURNS>void </RETURNS>
gpointer response_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncModuleCallback</NAME>
<RETURNS>void </RETURNS>
gconstpointer                  in,
					      gsize                          in_size,
					      gpointer                       out,
					      gsize                          out_size,
					      gpointer                       callback_data,
					      GnomeVFSModuleCallbackResponse response,
					      gpointer                       response_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_module_callback_set_default</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name,GnomeVFSModuleCallback       callback,gpointer                     callback_data,GDestroyNotify               destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_module_callback_push</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name,GnomeVFSModuleCallback       callback,gpointer                     callback_data,GDestroyNotify               destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_module_callback_pop</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_module_callback_set_default</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name,GnomeVFSAsyncModuleCallback  callback,gpointer                     callback_data,GDestroyNotify               destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_module_callback_push</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name,GnomeVFSAsyncModuleCallback  callback,gpointer                     callback_data,GDestroyNotify               destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_module_callback_pop</NAME>
<RETURNS>void </RETURNS>
const char                  *callback_name
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSCancellation</NAME>
typedef struct GnomeVFSCancellation GnomeVFSCancellation;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_cancellation_new</NAME>
<RETURNS>GnomeVFSCancellation  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_cancellation_destroy</NAME>
<RETURNS>void     </RETURNS>
GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_cancellation_cancel</NAME>
<RETURNS>void     </RETURNS>
GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_cancellation_check</NAME>
<RETURNS>gboolean </RETURNS>
GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_cancellation_ack</NAME>
<RETURNS>void     </RETURNS>
GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_cancellation_get_fd</NAME>
<RETURNS>gint	 </RETURNS>
GnomeVFSCancellation *cancellation
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSMethod</NAME>
typedef struct GnomeVFSMethod GnomeVFSMethod;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSMethodInitFunc</NAME>
<RETURNS>GnomeVFSMethod *</RETURNS>
const char *method_name, const char *config_args
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSMethodShutdownFunc</NAME>
<RETURNS>void </RETURNS>
GnomeVFSMethod *method
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSMethodTruncateFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSMethod *method,
						       GnomeVFSURI *uri,
						       GnomeVFSFileSize length,
						       GnomeVFSContext *context
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSMethodTruncateHandleFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSMethod *method,
							     GnomeVFSMethodHandle *handle,
							     GnomeVFSFileSize length,
							     GnomeVFSContext *context
</USER_FUNCTION>
<MACRO>
<NAME>VFS_METHOD_HAS_FUNC</NAME>
#define VFS_METHOD_HAS_FUNC(method,func) ((((char *)&((method)->func)) - ((char *)(method)) < (method)->method_table_size) && method->func != NULL)
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_method_init</NAME>
<RETURNS>gboolean	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_method_get</NAME>
<RETURNS>GnomeVFSMethod    *</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_transform_get</NAME>
<RETURNS>GnomeVFSTransform *</RETURNS>
const gchar *name
</FUNCTION>
<ENUM>
<NAME>GnomeVFSMimeApplicationArgumentType</NAME>
typedef enum {
	GNOME_VFS_MIME_APPLICATION_ARGUMENT_TYPE_URIS,
	GNOME_VFS_MIME_APPLICATION_ARGUMENT_TYPE_PATHS,
	GNOME_VFS_MIME_APPLICATION_ARGUMENT_TYPE_URIS_FOR_NON_FILES
} GnomeVFSMimeApplicationArgumentType;
</ENUM>
<STRUCT>
<NAME>GnomeVFSMimeApplicationPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSMimeApplication</NAME>
typedef struct {
	/*< public > */
	char *id;
	char *name;

	/*< private > */
#ifndef GNOME_VFS_DISABLE_DEPRECATED
	char *command;
	gboolean can_open_multiple_files;
	GnomeVFSMimeApplicationArgumentType expects_uris;
	GList *supported_uri_schemes;
#else
	char *_command;
	gboolean _can_open_multiple_files;
	GnomeVFSMimeApplicationArgumentType _expects_uris;
	GList *_supported_uri_schemes;
#endif
	gboolean requires_terminal;

	/* Padded to avoid future breaks in ABI compatibility */
	void *reserved1;

	GnomeVFSMimeApplicationPrivate *priv;
} GnomeVFSMimeApplication;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_application</NAME>
<RETURNS>GnomeVFSMimeApplication *</RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_default_application_for_uri</NAME>
<RETURNS>GnomeVFSMimeApplication *</RETURNS>
const char		   *uri,const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_all_applications</NAME>
<RETURNS>GList *</RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_all_applications_for_uri</NAME>
<RETURNS>GList *</RETURNS>
const char              *uri,const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_description</NAME>
<RETURNS>const char 	        *</RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_can_be_executable</NAME>
<RETURNS>gboolean 	         </RETURNS>
const char              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_new_from_desktop_id</NAME>
<RETURNS>GnomeVFSMimeApplication *</RETURNS>
const char              *id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_launch</NAME>
<RETURNS>GnomeVFSResult           </RETURNS>
GnomeVFSMimeApplication *app,GList                   *uris
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_launch_with_env</NAME>
<RETURNS>GnomeVFSResult           </RETURNS>
GnomeVFSMimeApplication *app,GList                   *uris,char                   **envp
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_desktop_id</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_desktop_file_path</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_name</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_generic_name</NAME>
<RETURNS>const char              *</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_icon</NAME>
<RETURNS>const char              *</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_exec</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_binary_name</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_supports_uris</NAME>
<RETURNS>gboolean		 </RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_requires_terminal</NAME>
<RETURNS>gboolean		 </RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_supports_startup_notification</NAME>
<RETURNS>gboolean		 </RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_get_startup_wm_class</NAME>
<RETURNS>const char		*</RETURNS>
GnomeVFSMimeApplication *app
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_copy</NAME>
<RETURNS>GnomeVFSMimeApplication *</RETURNS>
GnomeVFSMimeApplication *application
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_equal</NAME>
<RETURNS>gboolean		 </RETURNS>
GnomeVFSMimeApplication *app_a,GnomeVFSMimeApplication *app_b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_free</NAME>
<RETURNS>void                     </RETURNS>
GnomeVFSMimeApplication *application
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_application_list_free</NAME>
<RETURNS>void                     </RETURNS>
GList                   *list
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VOLUME</NAME>
#define GNOME_VFS_TYPE_VOLUME        (gnome_vfs_volume_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME</NAME>
#define GNOME_VFS_VOLUME(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_TYPE_VOLUME, GnomeVFSVolume))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_CLASS</NAME>
#define GNOME_VFS_VOLUME_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_TYPE_VOLUME, GnomeVFSVolumeClass))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME</NAME>
#define GNOME_IS_VFS_VOLUME(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_TYPE_VOLUME))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_CLASS</NAME>
#define GNOME_IS_VFS_VOLUME_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_TYPE_VOLUME))
</MACRO>
<STRUCT>
<NAME>GnomeVFSVolumePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolume</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolume</NAME>
struct _GnomeVFSVolume {
	GObject parent;

	/*< private >*/
        GnomeVFSVolumePrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeClass</NAME>
struct _GnomeVFSVolumeClass {
	GObjectClass parent_class;
};

</STRUCT>
<ENUM>
<NAME>GnomeVFSDeviceType</NAME>
typedef enum {
	GNOME_VFS_DEVICE_TYPE_UNKNOWN,
	GNOME_VFS_DEVICE_TYPE_AUDIO_CD,
	GNOME_VFS_DEVICE_TYPE_VIDEO_DVD,
	GNOME_VFS_DEVICE_TYPE_HARDDRIVE, 
	GNOME_VFS_DEVICE_TYPE_CDROM,
	GNOME_VFS_DEVICE_TYPE_FLOPPY,
	GNOME_VFS_DEVICE_TYPE_ZIP,
	GNOME_VFS_DEVICE_TYPE_JAZ,
	GNOME_VFS_DEVICE_TYPE_NFS,
	GNOME_VFS_DEVICE_TYPE_AUTOFS,
	GNOME_VFS_DEVICE_TYPE_CAMERA,
	GNOME_VFS_DEVICE_TYPE_MEMORY_STICK,
	GNOME_VFS_DEVICE_TYPE_SMB,
	GNOME_VFS_DEVICE_TYPE_APPLE,
	GNOME_VFS_DEVICE_TYPE_MUSIC_PLAYER,
	GNOME_VFS_DEVICE_TYPE_WINDOWS, 
	GNOME_VFS_DEVICE_TYPE_LOOPBACK, 
	GNOME_VFS_DEVICE_TYPE_NETWORK 
} GnomeVFSDeviceType;
</ENUM>
<ENUM>
<NAME>GnomeVFSVolumeType</NAME>
typedef enum {
	GNOME_VFS_VOLUME_TYPE_MOUNTPOINT,
	GNOME_VFS_VOLUME_TYPE_VFS_MOUNT,
	GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER
} GnomeVFSVolumeType;
</ENUM>
<USER_FUNCTION>
<NAME>GnomeVFSVolumeOpCallback</NAME>
<RETURNS>void </RETURNS>
gboolean succeeded,
					  char *error,
					  char *detailed_error,
					  gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeVFSDrive</NAME>
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_volume_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_ref</NAME>
<RETURNS>GnomeVFSVolume *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_unref</NAME>
<RETURNS>void            </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_id</NAME>
<RETURNS>gulong             </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_volume_type</NAME>
<RETURNS>GnomeVFSVolumeType </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_device_type</NAME>
<RETURNS>GnomeVFSDeviceType </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_drive</NAME>
<RETURNS>GnomeVFSDrive *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_device_path</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_activation_uri</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_filesystem_type</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_display_name</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_icon</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_get_hal_udi</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_is_user_visible</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_is_read_only</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_is_mounted</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_handles_trash</NAME>
<RETURNS>gboolean           </RETURNS>
GnomeVFSVolume *volume
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_compare</NAME>
<RETURNS>gint               </RETURNS>
GnomeVFSVolume *a,GnomeVFSVolume *b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_unmount</NAME>
<RETURNS>void </RETURNS>
GnomeVFSVolume           *volume,GnomeVFSVolumeOpCallback  callback,gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_eject</NAME>
<RETURNS>void </RETURNS>
GnomeVFSVolume           *volume,GnomeVFSVolumeOpCallback  callback,gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_connect_to_server</NAME>
<RETURNS>void </RETURNS>
const char               *uri,const char               *display_name,const char               *icon
</FUNCTION>
<ENUM>
<NAME>GnomeVFSResult</NAME>
typedef enum {
	GNOME_VFS_OK,
	GNOME_VFS_ERROR_NOT_FOUND,
	GNOME_VFS_ERROR_GENERIC,
	GNOME_VFS_ERROR_INTERNAL,
	GNOME_VFS_ERROR_BAD_PARAMETERS,
	GNOME_VFS_ERROR_NOT_SUPPORTED,
	GNOME_VFS_ERROR_IO,
	GNOME_VFS_ERROR_CORRUPTED_DATA,
	GNOME_VFS_ERROR_WRONG_FORMAT,
	GNOME_VFS_ERROR_BAD_FILE,
	GNOME_VFS_ERROR_TOO_BIG,
	GNOME_VFS_ERROR_NO_SPACE,
	GNOME_VFS_ERROR_READ_ONLY,
	GNOME_VFS_ERROR_INVALID_URI,
	GNOME_VFS_ERROR_NOT_OPEN,
	GNOME_VFS_ERROR_INVALID_OPEN_MODE,
	GNOME_VFS_ERROR_ACCESS_DENIED,
	GNOME_VFS_ERROR_TOO_MANY_OPEN_FILES,
	GNOME_VFS_ERROR_EOF,
	GNOME_VFS_ERROR_NOT_A_DIRECTORY,
	GNOME_VFS_ERROR_IN_PROGRESS,
	GNOME_VFS_ERROR_INTERRUPTED,
	GNOME_VFS_ERROR_FILE_EXISTS,
	GNOME_VFS_ERROR_LOOP,
	GNOME_VFS_ERROR_NOT_PERMITTED,
	GNOME_VFS_ERROR_IS_DIRECTORY,
	GNOME_VFS_ERROR_NO_MEMORY,
	GNOME_VFS_ERROR_HOST_NOT_FOUND,
	GNOME_VFS_ERROR_INVALID_HOST_NAME,
	GNOME_VFS_ERROR_HOST_HAS_NO_ADDRESS,
	GNOME_VFS_ERROR_LOGIN_FAILED,
	GNOME_VFS_ERROR_CANCELLED,
	GNOME_VFS_ERROR_DIRECTORY_BUSY,
	GNOME_VFS_ERROR_DIRECTORY_NOT_EMPTY,
	GNOME_VFS_ERROR_TOO_MANY_LINKS,
	GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM,
	GNOME_VFS_ERROR_NOT_SAME_FILE_SYSTEM,
	GNOME_VFS_ERROR_NAME_TOO_LONG,
	GNOME_VFS_ERROR_SERVICE_NOT_AVAILABLE,
	GNOME_VFS_ERROR_SERVICE_OBSOLETE,
	GNOME_VFS_ERROR_PROTOCOL_ERROR,
	GNOME_VFS_ERROR_NO_MASTER_BROWSER,
	GNOME_VFS_ERROR_NO_DEFAULT,
	GNOME_VFS_ERROR_NO_HANDLER,
	GNOME_VFS_ERROR_PARSE,
	GNOME_VFS_ERROR_LAUNCH,
	GNOME_VFS_ERROR_TIMEOUT,
	GNOME_VFS_ERROR_NAMESERVER,
	GNOME_VFS_ERROR_LOCKED,
	GNOME_VFS_ERROR_DEPRECATED_FUNCTION,
	GNOME_VFS_ERROR_INVALID_FILENAME,
	GNOME_VFS_ERROR_NOT_A_SYMBOLIC_LINK,
	GNOME_VFS_NUM_ERRORS
} GnomeVFSResult;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_result_to_string</NAME>
<RETURNS>const char	*</RETURNS>
GnomeVFSResult result
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_result_from_errno_code</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
int errno_code
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_result_from_errno</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_result_from_h_errno_val</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
int h_errno_code
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_result_from_h_errno</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION</NAME>
#define GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION "full-authentication"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_FILL_AUTHENTICATION</NAME>
#define GNOME_VFS_MODULE_CALLBACK_FILL_AUTHENTICATION "fill-authentication"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_SAVE_AUTHENTICATION</NAME>
#define GNOME_VFS_MODULE_CALLBACK_SAVE_AUTHENTICATION "save-authentication"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION</NAME>
<DEPRECATED/>
#define GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION "simple-authentication"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_HTTP_PROXY_AUTHENTICATION</NAME>
<DEPRECATED/>
#define GNOME_VFS_MODULE_CALLBACK_HTTP_PROXY_AUTHENTICATION "http:proxy-authentication"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_QUESTION</NAME>
#define GNOME_VFS_MODULE_CALLBACK_QUESTION "ask-question"
</MACRO>
<STRUCT>
<NAME>GnomeVFSModuleCallbackFillAuthenticationIn</NAME>
typedef struct {
	/*< public >*/
	char *uri;
	char *protocol;
	char *server;
	char *object;
	int port;
	char *authtype;
	char *username;
	char *domain;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackFillAuthenticationIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackFillAuthenticationOut</NAME>
typedef struct {
	/*< public >*/
	gboolean valid;
	char *username;
	char *domain;
	char *password;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackFillAuthenticationOut;
</STRUCT>
<ENUM>
<NAME>GnomeVFSModuleCallbackFullAuthenticationFlags</NAME>
typedef enum {
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_PREVIOUS_ATTEMPT_FAILED = 1<<0,
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_PASSWORD = 1<<1,
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_USERNAME = 1<<2,
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_DOMAIN = 1<<3,
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_SAVING_SUPPORTED = 1<<4,
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_ANON_SUPPORTED = 1<<5
} GnomeVFSModuleCallbackFullAuthenticationFlags;
</ENUM>
<STRUCT>
<NAME>GnomeVFSModuleCallbackFullAuthenticationIn</NAME>
typedef struct {
	/*< public >*/
	GnomeVFSModuleCallbackFullAuthenticationFlags flags;

	char *uri;
	char *protocol;
	char *server;
	char *object;
	int port;
	char *authtype;
	char *username;
	char *domain;

	/* for pre-filling the dialog */
	char *default_user;     
	char *default_domain;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackFullAuthenticationIn;
</STRUCT>
<ENUM>
<NAME>GnomeVFSModuleCallbackFullAuthenticationOutFlags</NAME>
typedef enum {
	GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_OUT_ANON_SELECTED = 1<<0
} GnomeVFSModuleCallbackFullAuthenticationOutFlags;
</ENUM>
<STRUCT>
<NAME>GnomeVFSModuleCallbackFullAuthenticationOut</NAME>
typedef struct {
	/*< public >*/
	gboolean abort_auth;

	char *username;
	char *domain;
	char *password;

	gboolean save_password;
	char *keyring;

	gsize out_flags;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved2;
} GnomeVFSModuleCallbackFullAuthenticationOut;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackSaveAuthenticationIn</NAME>
typedef struct {
	/*< public >*/
	char *keyring;
	
	char *uri;
	char *protocol;
	char *server;
	char *object;
	int port;
	char *authtype;
	char *username;
	char *domain;
	char *password;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackSaveAuthenticationIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackSaveAuthenticationOut</NAME>
typedef struct {
	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackSaveAuthenticationOut;
</STRUCT>
<ENUM>
<NAME>GnomeVFSModuleCallbackAuthenticationAuthType</NAME>
<DEPRECATED/>
typedef enum {
	AuthTypeBasic,
	AuthTypeDigest
} GnomeVFSModuleCallbackAuthenticationAuthType;
</ENUM>
<STRUCT>
<NAME>GnomeVFSModuleCallbackAuthenticationIn</NAME>
<DEPRECATED/>
typedef struct {
	/*< public >*/
	char *uri;
	char *realm;
	gboolean previous_attempt_failed;
	GnomeVFSModuleCallbackAuthenticationAuthType auth_type;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackAuthenticationIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackAuthenticationOut</NAME>
<DEPRECATED/>
typedef struct {
	/*< public >*/
	char *username;
	char *password;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackAuthenticationOut;
</STRUCT>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_HTTP_SEND_ADDITIONAL_HEADERS</NAME>
#define GNOME_VFS_MODULE_CALLBACK_HTTP_SEND_ADDITIONAL_HEADERS "http:send-additional-headers"
</MACRO>
<STRUCT>
<NAME>GnomeVFSModuleCallbackAdditionalHeadersIn</NAME>
typedef struct {
	/*< public >*/
	GnomeVFSURI *uri;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackAdditionalHeadersIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackAdditionalHeadersOut</NAME>
typedef struct {
	/*< public >*/
	GList *headers;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackAdditionalHeadersOut;
</STRUCT>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_HTTP_RECEIVED_HEADERS</NAME>
#define GNOME_VFS_MODULE_CALLBACK_HTTP_RECEIVED_HEADERS "http:received-headers"
</MACRO>
<STRUCT>
<NAME>GnomeVFSModuleCallbackReceivedHeadersIn</NAME>
typedef struct {
	/*< public >*/
	GnomeVFSURI *uri;
	GList *headers;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackReceivedHeadersIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackReceivedHeadersOut</NAME>
typedef struct {
	/*< public >*/
	int dummy;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackReceivedHeadersOut;
</STRUCT>
<MACRO>
<NAME>GNOME_VFS_MODULE_CALLBACK_STATUS_MESSAGE</NAME>
#define GNOME_VFS_MODULE_CALLBACK_STATUS_MESSAGE "status-message"
</MACRO>
<STRUCT>
<NAME>GnomeVFSModuleCallbackStatusMessageIn</NAME>
typedef struct {
	/*< public >*/
	char *uri;
	char *message;
	int percentage;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackStatusMessageIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackStatusMessageOut</NAME>
typedef struct {
	/*< public >*/
	/* empty structs not allowed */
	int dummy;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackStatusMessageOut;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackQuestionIn</NAME>
typedef struct {
	/*< public >*/
	char *primary_message;
	char *secondary_message;
	char **choices;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackQuestionIn;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSModuleCallbackQuestionOut</NAME>
typedef struct {
	/*< public >*/
	int answer;

	/*< private >*/
	/* Reserved "padding" to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
} GnomeVFSModuleCallbackQuestionOut;
</STRUCT>
<MACRO>
<NAME>DVD_DAEMON_SERVICE</NAME>
#define DVD_DAEMON_SERVICE                          "org.gnome.GnomeVFS.Daemon"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_OBJECT</NAME>
#define DVD_DAEMON_OBJECT                           "/org/gnome/GnomeVFS/Daemon"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_INTERFACE</NAME>
#define DVD_DAEMON_INTERFACE                        "org.gnome.GnomeVFS.Daemon"
</MACRO>
<MACRO>
<NAME>DVD_CLIENT_OBJECT</NAME>
#define DVD_CLIENT_OBJECT                           "/org/gnome/GnomeVFS/Client"
</MACRO>
<MACRO>
<NAME>DVD_CLIENT_INTERFACE</NAME>
#define DVD_CLIENT_INTERFACE                        "org.gnome.GnomeVFS.Client"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_MONITOR_SIGNAL</NAME>
#define DVD_DAEMON_MONITOR_SIGNAL                   "MonitorSignal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_CONNECTION</NAME>
#define DVD_DAEMON_METHOD_GET_CONNECTION            "GetConnection"
</MACRO>
<MACRO>
<NAME>DVD_CLIENT_METHOD_CALLBACK</NAME>
#define DVD_CLIENT_METHOD_CALLBACK                  "Callback"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_OPEN</NAME>
#define DVD_DAEMON_METHOD_OPEN                      "Open"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CREATE</NAME>
#define DVD_DAEMON_METHOD_CREATE                    "Create"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_READ</NAME>
#define DVD_DAEMON_METHOD_READ                      "Read"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_WRITE</NAME>
#define DVD_DAEMON_METHOD_WRITE                     "Write"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CLOSE</NAME>
#define DVD_DAEMON_METHOD_CLOSE                     "Close"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_SEEK</NAME>
#define DVD_DAEMON_METHOD_SEEK                      "Seek"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_TELL</NAME>
#define DVD_DAEMON_METHOD_TELL                      "Tell"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_TRUNCATE_HANDLE</NAME>
#define DVD_DAEMON_METHOD_TRUNCATE_HANDLE           "TruncateHandle"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_OPEN_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_OPEN_DIRECTORY            "OpenDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CLOSE_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_CLOSE_DIRECTORY           "CloseDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_READ_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_READ_DIRECTORY            "ReadDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_FILE_INFO</NAME>
#define DVD_DAEMON_METHOD_GET_FILE_INFO             "GetFileInfo"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_FILE_INFO_FROM_HANDLE</NAME>
#define DVD_DAEMON_METHOD_GET_FILE_INFO_FROM_HANDLE "GetFileInfoFromHandle"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_IS_LOCAL</NAME>
#define DVD_DAEMON_METHOD_IS_LOCAL                  "IsLocal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_MAKE_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_MAKE_DIRECTORY            "MakeDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_REMOVE_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_REMOVE_DIRECTORY          "RemoveDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_MOVE</NAME>
#define DVD_DAEMON_METHOD_MOVE                      "Move"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_UNLINK</NAME>
#define DVD_DAEMON_METHOD_UNLINK                    "Unlink"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CHECK_SAME_FS</NAME>
#define DVD_DAEMON_METHOD_CHECK_SAME_FS             "CheckSameFs"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_SET_FILE_INFO</NAME>
#define DVD_DAEMON_METHOD_SET_FILE_INFO             "SetFileInfo"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_TRUNCATE</NAME>
#define DVD_DAEMON_METHOD_TRUNCATE                  "Truncate"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_FIND_DIRECTORY</NAME>
#define DVD_DAEMON_METHOD_FIND_DIRECTORY            "FindDirectory"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CREATE_SYMBOLIC_LINK</NAME>
#define DVD_DAEMON_METHOD_CREATE_SYMBOLIC_LINK      "CreateSymbolicLink"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_FORGET_CACHE</NAME>
#define DVD_DAEMON_METHOD_FORGET_CACHE              "ForgetCache"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_VOLUME_FREE_SPACE</NAME>
#define DVD_DAEMON_METHOD_GET_VOLUME_FREE_SPACE     "GetVolumeFreeSpace"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_MONITOR_ADD</NAME>
#define DVD_DAEMON_METHOD_MONITOR_ADD               "MonitorAdd"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_MONITOR_CANCEL</NAME>
#define DVD_DAEMON_METHOD_MONITOR_CANCEL            "MonitorCancel"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_CANCEL</NAME>
#define DVD_DAEMON_METHOD_CANCEL                    "Cancel"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_REGISTER_VOLUME_MONITOR</NAME>
#define DVD_DAEMON_METHOD_REGISTER_VOLUME_MONITOR   "RegisterVolumeMonitor"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_DEREGISTER_VOLUME_MONITOR</NAME>
#define DVD_DAEMON_METHOD_DEREGISTER_VOLUME_MONITOR "DeregisterVolumeMonitor"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_VOLUMES</NAME>
#define DVD_DAEMON_METHOD_GET_VOLUMES               "GetVolumes"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_GET_DRIVES</NAME>
#define DVD_DAEMON_METHOD_GET_DRIVES                "GetDrives"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_EMIT_PRE_UNMOUNT_VOLUME</NAME>
#define DVD_DAEMON_METHOD_EMIT_PRE_UNMOUNT_VOLUME   "EmitPreUnmountVolume"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_METHOD_FORCE_PROBE</NAME>
#define DVD_DAEMON_METHOD_FORCE_PROBE               "ForceProbe"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_VOLUME_MOUNTED_SIGNAL</NAME>
#define DVD_DAEMON_VOLUME_MOUNTED_SIGNAL            "VolumeMountedSignal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_VOLUME_UNMOUNTED_SIGNAL</NAME>
#define DVD_DAEMON_VOLUME_UNMOUNTED_SIGNAL          "VolumeUnmountedSignal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_VOLUME_PRE_UNMOUNT_SIGNAL</NAME>
#define DVD_DAEMON_VOLUME_PRE_UNMOUNT_SIGNAL        "VolumePreUnmountSignal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_DRIVE_CONNECTED_SIGNAL</NAME>
#define DVD_DAEMON_DRIVE_CONNECTED_SIGNAL           "DriveConnectedSignal"
</MACRO>
<MACRO>
<NAME>DVD_DAEMON_DRIVE_DISCONNECTED_SIGNAL</NAME>
#define DVD_DAEMON_DRIVE_DISCONNECTED_SIGNAL        "DriveDisconnectedSignal"
</MACRO>
<MACRO>
<NAME>DVD_ERROR_FAILED</NAME>
#define DVD_ERROR_FAILED            "org.gnome.GnomeVFS.Daemon.Error.Failed"
</MACRO>
<MACRO>
<NAME>DVD_ERROR_SOCKET_FAILED</NAME>
#define DVD_ERROR_SOCKET_FAILED     "org.gnome.GnomeVFS.Error.SocketFailed"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_DBUS_TYPE</NAME>
#define GNOME_VFS_VOLUME_DBUS_TYPE \
	DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_STRUCT_END_CHAR_AS_STRING
</MACRO>
<MACRO>
<NAME>GNOME_VFS_DRIVE_DBUS_TYPE</NAME>
#define GNOME_VFS_DRIVE_DBUS_TYPE \
	DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_ARRAY_AS_STRING \
	 DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_TYPE_BOOLEAN_AS_STRING \
	DBUS_STRUCT_END_CHAR_AS_STRING
</MACRO>
<MACRO>
<NAME>GNOME_VFS_FILE_INFO_DBUS_TYPE</NAME>
#define GNOME_VFS_FILE_INFO_DBUS_TYPE \
	DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT64_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_UINT32_AS_STRING \
	DBUS_TYPE_UINT32_AS_STRING \
	DBUS_TYPE_INT64_AS_STRING \
	DBUS_TYPE_INT64_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_INT32_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_TYPE_STRING_AS_STRING \
	DBUS_STRUCT_END_CHAR_AS_STRING
</MACRO>
<ENUM>
<NAME>DvdArgumentType</NAME>
typedef enum {
	DVD_TYPE_LAST = -1,
	DVD_TYPE_URI,
	DVD_TYPE_STRING,
	DVD_TYPE_INT32,
	DVD_TYPE_INT64,
	DVD_TYPE_UINT64,
	DVD_TYPE_FILE_INFO,
	DVD_TYPE_BOOL,
	DVD_TYPE_BYTE_ARRAY
} DvdArgumentType;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_daemon_set_current_connection</NAME>
<RETURNS>void            </RETURNS>
DBusConnection *conn
</FUNCTION>
<FUNCTION>
<NAME>vfs_module_init</NAME>
<RETURNS>GnomeVFSMethod    *</RETURNS>
const char *method_name, const char *args
</FUNCTION>
<FUNCTION>
<NAME>vfs_module_transform</NAME>
<RETURNS>GnomeVFSTransform *</RETURNS>
const char *method_name, const char *args
</FUNCTION>
<FUNCTION>
<NAME>vfs_module_shutdown</NAME>
<RETURNS>void               </RETURNS>
GnomeVFSMethod *method
</FUNCTION>
<ENUM>
<NAME>GnomeVFSXferOptions</NAME>
typedef enum {
	GNOME_VFS_XFER_DEFAULT = 0,
	GNOME_VFS_XFER_UNUSED_1 = 1 << 0,
	GNOME_VFS_XFER_FOLLOW_LINKS = 1 << 1,
	GNOME_VFS_XFER_UNUSED_2 = 1 << 2,
	GNOME_VFS_XFER_RECURSIVE = 1 << 3,
	GNOME_VFS_XFER_SAMEFS = 1 << 4,
	GNOME_VFS_XFER_DELETE_ITEMS = 1 << 5,
	GNOME_VFS_XFER_EMPTY_DIRECTORIES = 1 << 6,
	GNOME_VFS_XFER_NEW_UNIQUE_DIRECTORY = 1 << 7,
	GNOME_VFS_XFER_REMOVESOURCE = 1 << 8,
	GNOME_VFS_XFER_USE_UNIQUE_NAMES = 1 << 9,
	GNOME_VFS_XFER_LINK_ITEMS = 1 << 10,
	GNOME_VFS_XFER_FOLLOW_LINKS_RECURSIVE = 1 << 11,
	GNOME_VFS_XFER_TARGET_DEFAULT_PERMS = 1 << 12
} GnomeVFSXferOptions;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferProgressStatus</NAME>
typedef enum {
	GNOME_VFS_XFER_PROGRESS_STATUS_OK = 0,
	GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR = 1,
	GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE = 2,
	GNOME_VFS_XFER_PROGRESS_STATUS_DUPLICATE = 3
} GnomeVFSXferProgressStatus;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferOverwriteMode</NAME>
typedef enum {
	GNOME_VFS_XFER_OVERWRITE_MODE_ABORT = 0,
	GNOME_VFS_XFER_OVERWRITE_MODE_QUERY = 1,
	GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE = 2,
	GNOME_VFS_XFER_OVERWRITE_MODE_SKIP = 3
} GnomeVFSXferOverwriteMode;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferOverwriteAction</NAME>
typedef enum {
	GNOME_VFS_XFER_OVERWRITE_ACTION_ABORT = 0,
	GNOME_VFS_XFER_OVERWRITE_ACTION_REPLACE = 1,
	GNOME_VFS_XFER_OVERWRITE_ACTION_REPLACE_ALL = 2,
	GNOME_VFS_XFER_OVERWRITE_ACTION_SKIP = 3,
	GNOME_VFS_XFER_OVERWRITE_ACTION_SKIP_ALL = 4
} GnomeVFSXferOverwriteAction;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferErrorMode</NAME>
typedef enum {
	GNOME_VFS_XFER_ERROR_MODE_ABORT = 0,
	GNOME_VFS_XFER_ERROR_MODE_QUERY = 1
} GnomeVFSXferErrorMode;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferErrorAction</NAME>
typedef enum {
	GNOME_VFS_XFER_ERROR_ACTION_ABORT = 0,
	GNOME_VFS_XFER_ERROR_ACTION_RETRY = 1,
	GNOME_VFS_XFER_ERROR_ACTION_SKIP = 2
} GnomeVFSXferErrorAction;
</ENUM>
<ENUM>
<NAME>GnomeVFSXferPhase</NAME>
typedef enum {
	GNOME_VFS_XFER_PHASE_INITIAL,
	GNOME_VFS_XFER_CHECKING_DESTINATION,
	GNOME_VFS_XFER_PHASE_COLLECTING,
	GNOME_VFS_XFER_PHASE_READYTOGO,
	GNOME_VFS_XFER_PHASE_OPENSOURCE,
	GNOME_VFS_XFER_PHASE_OPENTARGET,
	GNOME_VFS_XFER_PHASE_COPYING,
	GNOME_VFS_XFER_PHASE_MOVING,
	GNOME_VFS_XFER_PHASE_READSOURCE,
	GNOME_VFS_XFER_PHASE_WRITETARGET,
	GNOME_VFS_XFER_PHASE_CLOSESOURCE,
	GNOME_VFS_XFER_PHASE_CLOSETARGET,
	GNOME_VFS_XFER_PHASE_DELETESOURCE,
	GNOME_VFS_XFER_PHASE_SETATTRIBUTES,
	GNOME_VFS_XFER_PHASE_FILECOMPLETED,
	GNOME_VFS_XFER_PHASE_CLEANUP,
	GNOME_VFS_XFER_PHASE_COMPLETED,
	GNOME_VFS_XFER_NUM_PHASES
} GnomeVFSXferPhase;
</ENUM>
<STRUCT>
<NAME>GnomeVFSXferProgressInfo</NAME>
typedef struct {
	/*< public > */
	GnomeVFSXferProgressStatus status;

	GnomeVFSResult vfs_status;

	GnomeVFSXferPhase phase;

	/* Source URI. FIXME bugzilla.eazel.com 1206: change name? */
	gchar *source_name;

	/* Destination URI. FIXME bugzilla.eazel.com 1206: change name? */
	gchar *target_name;

	gulong file_index;

	gulong files_total;

	GnomeVFSFileSize bytes_total;

	GnomeVFSFileSize file_size;

	GnomeVFSFileSize bytes_copied;

	GnomeVFSFileSize total_bytes_copied;

	gchar *duplicate_name;

	int duplicate_count;

	gboolean top_level_item;

	/* Reserved for future expansions to GnomeVFSXferProgressInfo
	 * without having to break ABI compatibility */
	/*< private >*/
	void *reserved1;
	void *reserved2;
} GnomeVFSXferProgressInfo;
</STRUCT>
<USER_FUNCTION>
<NAME>GnomeVFSXferProgressCallback</NAME>
<RETURNS>gint </RETURNS>
GnomeVFSXferProgressInfo *info,
						 gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeVFSProgressCallbackState</NAME>
typedef struct _GnomeVFSProgressCallbackState {
	/*< private >*/

	/* xfer state */
	GnomeVFSXferProgressInfo *progress_info;	

	/* Callback called for every xfer operation. For async calls called 
	   in async xfer context. */
	GnomeVFSXferProgressCallback sync_callback;

	/* Callback called periodically every few hundred miliseconds
	   and whenever user interaction is needed. For async calls
	   called in the context of the async call caller. */
	GnomeVFSXferProgressCallback update_callback;

	/* User data passed to sync_callback. */
	gpointer user_data;

	/* Async job state passed to the update callback. */
	gpointer async_job_data;

	/* When will update_callback be called next. */
	gint64 next_update_callback_time;

	/* When will update_callback be called next. */
	gint64 next_text_update_callback_time;

	/* Period at which the update_callback will be called. */
	gint64 update_callback_period;


	/* Reserved for future expansions to GnomeVFSProgressCallbackState
	 * without having to break ABI compatibility */
	void *reserved1;
	void *reserved2;

} GnomeVFSProgressCallbackState;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_xfer_uri_list</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const GList                  *source_uri_list,const GList                  *target_uri_list,GnomeVFSXferOptions           xfer_options,GnomeVFSXferErrorMode         error_mode,GnomeVFSXferOverwriteMode     overwrite_mode,GnomeVFSXferProgressCallback  progress_callback,gpointer                      data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_xfer_uri</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const GnomeVFSURI            *source_uri,const GnomeVFSURI            *target_uri,GnomeVFSXferOptions           xfer_options,GnomeVFSXferErrorMode         error_mode,GnomeVFSXferOverwriteMode     overwrite_mode,GnomeVFSXferProgressCallback  progress_callback,gpointer                      data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_xfer_delete_list</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const GList                  *source_uri_list,GnomeVFSXferErrorMode         error_mode,GnomeVFSXferOptions           xfer_options,GnomeVFSXferProgressCallback  progress_callback,gpointer                      data
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VOLUME_MONITOR</NAME>
#define GNOME_VFS_TYPE_VOLUME_MONITOR        (gnome_vfs_volume_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR</NAME>
#define GNOME_VFS_VOLUME_MONITOR(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_TYPE_VOLUME_MONITOR, GnomeVFSVolumeMonitor))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR_CLASS</NAME>
#define GNOME_VFS_VOLUME_MONITOR_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_TYPE_VOLUME_MONITOR, GnomeVFSVolumeMonitorClass))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_TYPE_VOLUME_MONITOR))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR_CLASS</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_TYPE_VOLUME_MONITOR))
</MACRO>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitor</NAME>
struct _GnomeVFSVolumeMonitor {
	GObject parent;

        GnomeVFSVolumeMonitorPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClass</NAME>
struct _GnomeVFSVolumeMonitorClass {
	GObjectClass parent_class;

	/*< public >*/
	/* signals */
	void (* volume_mounted)	  	(GnomeVFSVolumeMonitor *volume_monitor,
				   	 GnomeVFSVolume	       *volume);
	void (* volume_pre_unmount)	(GnomeVFSVolumeMonitor *volume_monitor,
				   	 GnomeVFSVolume	       *volume);
	void (* volume_unmounted)	(GnomeVFSVolumeMonitor *volume_monitor,
				   	 GnomeVFSVolume	       *volume);
	void (* drive_connected) 	(GnomeVFSVolumeMonitor *volume_monitor,
				   	 GnomeVFSDrive	       *drive);
	void (* drive_disconnected)	(GnomeVFSVolumeMonitor *volume_monitor,
				   	 GnomeVFSDrive         *drive);
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_volume_monitor</NAME>
<RETURNS>GnomeVFSVolumeMonitor *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_ref</NAME>
<RETURNS>GnomeVFSVolumeMonitor *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_unref</NAME>
<RETURNS>void                   </RETURNS>
GnomeVFSVolumeMonitor *volume_monitor
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_mounted_volumes</NAME>
<RETURNS>GList *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_connected_drives</NAME>
<RETURNS>GList *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_volume_for_path</NAME>
<RETURNS>GnomeVFSVolume *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor,const char            *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_volume_by_id</NAME>
<RETURNS>GnomeVFSVolume *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor,gulong                 id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_get_drive_by_id</NAME>
<RETURNS>GnomeVFSDrive *</RETURNS>
GnomeVFSVolumeMonitor *volume_monitor,gulong                 id
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_ACE</NAME>
#define GNOME_VFS_TYPE_ACE             (gnome_vfs_ace_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_ACE</NAME>
#define GNOME_VFS_ACE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj),  GNOME_VFS_TYPE_ACE, GnomeVFSACE))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_ACE_CLASS</NAME>
#define GNOME_VFS_ACE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass),   GNOME_VFS_TYPE_ACE, GnomeVFSACEClass))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_ACE</NAME>
#define GNOME_VFS_IS_ACE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj),  GNOME_VFS_TYPE_ACE))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_ACE_CLASS</NAME>
#define GNOME_VFS_IS_ACE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass),   GNOME_VFS_TYPE_ACE))
</MACRO>
<STRUCT>
<NAME>GnomeVFSACE</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACEClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACEPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACE</NAME>
struct _GnomeVFSACE {
	GObject parent;
	
	GnomeVFSACEPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSACEClass</NAME>
struct _GnomeVFSACEClass {
	GObjectClass parent_class;
    
	void (*reserved1) (void);
	void (*reserved2) (void);
	void (*reserved3) (void);
	void (*reserved4) (void);
};

</STRUCT>
<TYPEDEF>
<NAME>GnomeVFSACLKind</NAME>
typedef guint32 GnomeVFSACLKind;
</TYPEDEF>
<TYPEDEF>
<NAME>GnomeVFSACLPerm</NAME>
typedef guint32 GnomeVFSACLPerm;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_ace_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_new</NAME>
<RETURNS>GnomeVFSACE *</RETURNS>
GnomeVFSACLKind  kind,const char      *id,GnomeVFSACLPerm *perms
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_get_kind</NAME>
<RETURNS>GnomeVFSACLKind         </RETURNS>
GnomeVFSACE      *entry
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_set_kind</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *entry,GnomeVFSACLKind   kind
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_get_id</NAME>
<RETURNS>const char *</RETURNS>
GnomeVFSACE      *entry
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_set_id</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *entry,const char       *id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_get_inherit</NAME>
<RETURNS>gboolean                </RETURNS>
GnomeVFSACE *entry
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_set_inherit</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE *entry,gboolean     inherit
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_get_negative</NAME>
<RETURNS>gboolean                </RETURNS>
GnomeVFSACE *entry
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_set_negative</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE *entry,gboolean     negative
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_get_perms</NAME>
<RETURNS>const GnomeVFSACLPerm *</RETURNS>
GnomeVFSACE      *entry
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_set_perms</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *entry,GnomeVFSACLPerm  *perms
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_add_perm</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *entry,GnomeVFSACLPerm   perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_del_perm</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *entry,GnomeVFSACLPerm   perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_check_perm</NAME>
<RETURNS>gboolean                </RETURNS>
GnomeVFSACE      *entry,GnomeVFSACLPerm   perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_copy_perms</NAME>
<RETURNS>void                    </RETURNS>
GnomeVFSACE      *source,GnomeVFSACE      *dest
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ace_equal</NAME>
<RETURNS>gboolean                </RETURNS>
GnomeVFSACE  *entry_a,GnomeVFSACE  *entry_b
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_module_callback_invoke</NAME>
<RETURNS>gboolean </RETURNS>
const char    *callback_name,gconstpointer  in,gsize          in_size,gpointer       out,gsize          out_size
</FUNCTION>
<STRUCT>
<NAME>stat</NAME>
struct stat;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_parse_ls_lga</NAME>
<RETURNS>int </RETURNS>
const char *p, struct stat *s,char **filename, char **linkname
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_visit_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_DIRECTORY_VISIT_OPTIONS</NAME>
#define GNOME_VFS_TYPE_VFS_DIRECTORY_VISIT_OPTIONS (gnome_vfs_directory_visit_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_flags_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FILE_FLAGS</NAME>
#define GNOME_VFS_TYPE_VFS_FILE_FLAGS (gnome_vfs_file_flags_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FILE_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_FILE_TYPE (gnome_vfs_file_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_info_fields_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FILE_INFO_FIELDS</NAME>
#define GNOME_VFS_TYPE_VFS_FILE_INFO_FIELDS (gnome_vfs_file_info_fields_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_permissions_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FILE_PERMISSIONS</NAME>
#define GNOME_VFS_TYPE_VFS_FILE_PERMISSIONS (gnome_vfs_file_permissions_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_file_info_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FILE_INFO_OPTIONS</NAME>
#define GNOME_VFS_TYPE_VFS_FILE_INFO_OPTIONS (gnome_vfs_file_info_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_set_file_info_mask_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_SET_FILE_INFO_MASK</NAME>
#define GNOME_VFS_TYPE_VFS_SET_FILE_INFO_MASK (gnome_vfs_set_file_info_mask_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_find_directory_kind_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_FIND_DIRECTORY_KIND</NAME>
#define GNOME_VFS_TYPE_VFS_FIND_DIRECTORY_KIND (gnome_vfs_find_directory_kind_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_open_mode_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_OPEN_MODE</NAME>
#define GNOME_VFS_TYPE_VFS_OPEN_MODE (gnome_vfs_open_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_seek_position_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_SEEK_POSITION</NAME>
#define GNOME_VFS_TYPE_VFS_SEEK_POSITION (gnome_vfs_seek_position_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_mime_action_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MIME_ACTION_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_MIME_ACTION_TYPE (gnome_vfs_mime_action_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_mime_application_argument_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MIME_APPLICATION_ARGUMENT_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_MIME_APPLICATION_ARGUMENT_TYPE (gnome_vfs_mime_application_argument_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_mime_equivalence_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MIME_EQUIVALENCE</NAME>
#define GNOME_VFS_TYPE_VFS_MIME_EQUIVALENCE (gnome_vfs_mime_equivalence_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_monitor_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MONITOR_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_MONITOR_TYPE (gnome_vfs_monitor_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_monitor_event_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MONITOR_EVENT_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_MONITOR_EVENT_TYPE (gnome_vfs_monitor_event_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_result_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_RESULT</NAME>
#define GNOME_VFS_TYPE_VFS_RESULT (gnome_vfs_result_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_module_callback_full_authentication_flags_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_FLAGS</NAME>
#define GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_FLAGS (gnome_vfs_module_callback_full_authentication_flags_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_module_callback_full_authentication_out_flags_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_OUT_FLAGS</NAME>
#define GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_OUT_FLAGS (gnome_vfs_module_callback_full_authentication_out_flags_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_module_callback_authentication_auth_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_AUTHENTICATION_AUTH_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_MODULE_CALLBACK_AUTHENTICATION_AUTH_TYPE (gnome_vfs_module_callback_authentication_auth_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_make_uri_dirs_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_MAKE_URI_DIRS</NAME>
#define GNOME_VFS_TYPE_VFS_MAKE_URI_DIRS (gnome_vfs_make_uri_dirs_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_device_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_DEVICE_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_DEVICE_TYPE (gnome_vfs_device_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_volume_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_VOLUME_TYPE</NAME>
#define GNOME_VFS_TYPE_VFS_VOLUME_TYPE (gnome_vfs_volume_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_OPTIONS</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_OPTIONS (gnome_vfs_xfer_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_progress_status_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_PROGRESS_STATUS</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_PROGRESS_STATUS (gnome_vfs_xfer_progress_status_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_overwrite_mode_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_OVERWRITE_MODE</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_OVERWRITE_MODE (gnome_vfs_xfer_overwrite_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_overwrite_action_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_OVERWRITE_ACTION</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_OVERWRITE_ACTION (gnome_vfs_xfer_overwrite_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_error_mode_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_ERROR_MODE</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_ERROR_MODE (gnome_vfs_xfer_error_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_error_action_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_ERROR_ACTION</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_ERROR_ACTION (gnome_vfs_xfer_error_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_xfer_phase_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_XFER_PHASE</NAME>
#define GNOME_VFS_TYPE_VFS_XFER_PHASE (gnome_vfs_xfer_phase_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT</NAME>
#define GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT        (gnome_vfs_volume_monitor_client_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR_CLIENT</NAME>
#define GNOME_VFS_VOLUME_MONITOR_CLIENT(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT, GnomeVFSVolumeMonitorClient))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR_CLIENT_CLASS</NAME>
#define GNOME_VFS_VOLUME_MONITOR_CLIENT_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT, GnomeVFSVolumeMonitorClientClass))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR_CLIENT</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR_CLIENT(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR_CLIENT_CLASS</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_TYPE_VOLUME_MONITOR_CLIENT))
</MACRO>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClient</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClientClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClient</NAME>
struct _GnomeVFSVolumeMonitorClient {
	GnomeVFSVolumeMonitor parent;
	gboolean is_shutdown;
	DBusConnection *dbus_conn;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorClientClass</NAME>
struct _GnomeVFSVolumeMonitorClientClass {
	GnomeVFSVolumeMonitorClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_client_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_client_shutdown_private</NAME>
<RETURNS>void </RETURNS>
GnomeVFSVolumeMonitorClient *volume_monitor_client
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_set_job_limit</NAME>
<RETURNS>void	      </RETURNS>
int              limit
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_get_job_limit</NAME>
<RETURNS>int	      </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GnomeVFSFindDirectoryKind</NAME>
typedef enum {
	GNOME_VFS_DIRECTORY_KIND_DESKTOP = 1000,
	GNOME_VFS_DIRECTORY_KIND_TRASH = 1001
} GnomeVFSFindDirectoryKind;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_find_directory</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSURI                *near_uri,GnomeVFSFindDirectoryKind   kind,GnomeVFSURI               **result,gboolean                    create_if_needed,gboolean                    find_if_needed,guint                       permissions
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSDirectoryHandle</NAME>
typedef struct GnomeVFSDirectoryHandle GnomeVFSDirectoryHandle;
</TYPEDEF>
<ENUM>
<NAME>GnomeVFSDirectoryVisitOptions</NAME>
typedef enum {
	GNOME_VFS_DIRECTORY_VISIT_DEFAULT = 0,
	GNOME_VFS_DIRECTORY_VISIT_SAMEFS = 1 << 0,
	GNOME_VFS_DIRECTORY_VISIT_LOOPCHECK = 1 << 1,
	GNOME_VFS_DIRECTORY_VISIT_IGNORE_RECURSE_ERROR = 1 << 2
} GnomeVFSDirectoryVisitOptions;
</ENUM>
<USER_FUNCTION>
<NAME>GnomeVFSDirectoryVisitFunc</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *rel_path,
						  GnomeVFSFileInfo *info,
						  gboolean recursing_will_loop,
						  gpointer user_data,
						  gboolean *recurse
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_open</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSDirectoryHandle **handle,const gchar              *text_uri,GnomeVFSFileInfoOptions   options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_open_from_uri</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSDirectoryHandle **handle,GnomeVFSURI              *uri,GnomeVFSFileInfoOptions   options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_read_next</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSDirectoryHandle  *handle,GnomeVFSFileInfo         *file_info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_close</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSDirectoryHandle  *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_visit</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
const gchar *text_uri,GnomeVFSFileInfoOptions info_options,GnomeVFSDirectoryVisitOptions visit_options,GnomeVFSDirectoryVisitFunc callback,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_visit_uri</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSURI *uri,GnomeVFSFileInfoOptions info_options,GnomeVFSDirectoryVisitOptions visit_options,GnomeVFSDirectoryVisitFunc callback,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_visit_files</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
const gchar *text_uri,GList *file_list,GnomeVFSFileInfoOptions info_options,GnomeVFSDirectoryVisitOptions visit_options,GnomeVFSDirectoryVisitFunc callback,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_visit_files_at_uri</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSURI *uri,GList *file_list,GnomeVFSFileInfoOptions info_options,GnomeVFSDirectoryVisitOptions visit_options,GnomeVFSDirectoryVisitFunc callback,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_directory_list_load</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GList **list,const gchar *text_uri,GnomeVFSFileInfoOptions options
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSContext</NAME>
typedef struct GnomeVFSContext GnomeVFSContext;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_context_new</NAME>
<RETURNS>GnomeVFSContext*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_context_free</NAME>
<RETURNS>void             </RETURNS>
GnomeVFSContext *ctx
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_context_get_cancellation</NAME>
<RETURNS>GnomeVFSCancellation *</RETURNS>
const GnomeVFSContext *ctx
</FUNCTION>
<MACRO>
<NAME>gnome_vfs_context_check_cancellation</NAME>
#define          gnome_vfs_context_check_cancellation(x) (gnome_vfs_cancellation_check((x) ? gnome_vfs_context_get_cancellation((x)) : NULL))
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_context_peek_current</NAME>
<RETURNS>const GnomeVFSContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_context_check_cancellation_current</NAME>
<RETURNS>gboolean	       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_open</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle **handle,const gchar *text_uri,GnomeVFSOpenMode open_mode
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_open_uri</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle **handle,GnomeVFSURI *uri,GnomeVFSOpenMode open_mode
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_create</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle **handle,const gchar *text_uri,GnomeVFSOpenMode open_mode,gboolean exclusive,guint perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_create_uri</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle **handle,GnomeVFSURI *uri,GnomeVFSOpenMode open_mode,gboolean exclusive,guint perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_close</NAME>
<RETURNS>GnomeVFSResult 	 </RETURNS>
GnomeVFSHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_read</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle *handle,gpointer buffer,GnomeVFSFileSize bytes,GnomeVFSFileSize *bytes_read
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_write</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle *handle,gconstpointer buffer,GnomeVFSFileSize bytes,GnomeVFSFileSize *bytes_written
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_seek</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle *handle,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_tell</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSHandle *handle,GnomeVFSFileSize *offset_return
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_info</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
const gchar *text_uri,GnomeVFSFileInfo *info,GnomeVFSFileInfoOptions options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_info_uri</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSURI *uri,GnomeVFSFileInfo *info,GnomeVFSFileInfoOptions options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_info_from_handle</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSHandle *handle,GnomeVFSFileInfo *info,GnomeVFSFileInfoOptions options
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_truncate</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
const gchar *text_uri,GnomeVFSFileSize length
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_truncate_uri</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSURI *uri,GnomeVFSFileSize length
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_truncate_handle</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSHandle *handle,GnomeVFSFileSize length
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_directory_for_uri</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSURI *uri, guint perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_directory</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
const gchar *text_uri,guint perm
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_remove_directory_from_uri</NAME>
<RETURNS>GnomeVFSResult 	</RETURNS>
GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_remove_directory</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
const gchar *text_uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_unlink_from_uri</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_create_symbolic_link</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSURI *uri,const gchar *target_reference
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_unlink</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
const gchar *text_uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_move_uri</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSURI *old_uri,GnomeVFSURI *new_uri,gboolean force_replace
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_move</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
const gchar *old_text_uri,const gchar *new_text_uri,gboolean force_replace
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_check_same_fs_uris</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
GnomeVFSURI *source_uri,GnomeVFSURI *target_uri,gboolean *same_fs_return
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_check_same_fs</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
const gchar *source,const gchar *target,gboolean *same_fs_return
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uri_exists</NAME>
<RETURNS>gboolean	 </RETURNS>
GnomeVFSURI *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_set_file_info_uri</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
GnomeVFSURI *uri,GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_set_file_info</NAME>
<RETURNS>GnomeVFSResult   </RETURNS>
const gchar *text_uri,GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_monitor_add</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSMonitorHandle **handle,const gchar *text_uri,GnomeVFSMonitorType monitor_type,GnomeVFSMonitorCallback callback,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_monitor_cancel</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSMonitorHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_file_control</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSHandle *handle,const char *operation,gpointer operation_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_forget_cache</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSHandle *handle,GnomeVFSFileOffset offset,GnomeVFSFileSize size
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSSSL</NAME>
typedef struct GnomeVFSSSL GnomeVFSSSL;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_ssl_enabled</NAME>
<RETURNS>gboolean        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_create</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSSL **handle_return,const char *host,unsigned int port,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_create_from_fd</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSSL **handle_return,gint fd,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_read</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSSL *ssl,gpointer buffer,GnomeVFSFileSize bytes,GnomeVFSFileSize *bytes_read,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_write</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSSL *ssl,gconstpointer buffer,GnomeVFSFileSize bytes,GnomeVFSFileSize *bytes_written,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_destroy</NAME>
<RETURNS>void            </RETURNS>
GnomeVFSSSL *ssl,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_set_timeout</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSSL *ssl,GTimeVal *timeout,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_ssl_to_socket</NAME>
<RETURNS>GnomeVFSSocket *</RETURNS>
GnomeVFSSSL *ssl
</FUNCTION>
<ENUM>
<NAME>GnomeVFSMakeURIDirs</NAME>
typedef enum {
	GNOME_VFS_MAKE_URI_DIR_NONE = 0,
	GNOME_VFS_MAKE_URI_DIR_HOMEDIR = 1 << 0,
	GNOME_VFS_MAKE_URI_DIR_CURRENT = 1 << 1
} GnomeVFSMakeURIDirs;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_format_file_size_for_display</NAME>
<RETURNS>char *</RETURNS>
GnomeVFSFileSize  size
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_escape_string</NAME>
<RETURNS>char *</RETURNS>
const char      *string
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_escape_path_string</NAME>
<RETURNS>char *</RETURNS>
const char      *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_escape_host_and_path_string</NAME>
<RETURNS>char *</RETURNS>
const char      *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_escape_slashes</NAME>
<RETURNS>char *</RETURNS>
const char      *string
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_escape_set</NAME>
<RETURNS>char *</RETURNS>
const char      *string,const char      *match_set
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_unescape_string</NAME>
<RETURNS>char *</RETURNS>
const char      *escaped_string,const char      *illegal_characters
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_canonical</NAME>
<RETURNS>char *</RETURNS>
const char 	*uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_path_name_canonical</NAME>
<RETURNS>char *</RETURNS>
const char      *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_expand_initial_tilde</NAME>
<RETURNS>char *</RETURNS>
const char      *path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_unescape_string_for_display</NAME>
<RETURNS>char *</RETURNS>
const char      *escaped
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_local_path_from_uri</NAME>
<RETURNS>char *</RETURNS>
const char      *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_uri_from_local_path</NAME>
<RETURNS>char *</RETURNS>
const char      *local_full_path
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_is_executable_command_string</NAME>
<RETURNS>gboolean </RETURNS>
const char *command_string
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_list_deep_free</NAME>
<RETURNS>void   </RETURNS>
GList            *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_volume_free_space</NAME>
<RETURNS>GnomeVFSResult	</RETURNS>
const GnomeVFSURI 	*vfs_uri,GnomeVFSFileSize 	*size
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_icon_path_from_filename</NAME>
<RETURNS>char *</RETURNS>
const char *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_open_fd</NAME>
<RETURNS>GnomeVFSResult	</RETURNS>
GnomeVFSHandle	**handle,int filedes
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_is_primary_thread</NAME>
<RETURNS>gboolean	</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_ASSERT_PRIMARY_THREAD</NAME>
#define GNOME_VFS_ASSERT_PRIMARY_THREAD g_assert (gnome_vfs_is_primary_thread())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_ASSERT_SECONDARY_THREAD</NAME>
#define GNOME_VFS_ASSERT_SECONDARY_THREAD g_assert (!gnome_vfs_is_primary_thread())
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_read_entire_file</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
const char *uri,int *file_size,char **file_contents
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_format_uri_for_display</NAME>
<RETURNS>char *</RETURNS>
const char          *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_from_input</NAME>
<RETURNS>char *</RETURNS>
const char     *location
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_from_input_with_trailing_ws</NAME>
<RETURNS>char  *</RETURNS>
const char     *location
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_from_input_with_dirs</NAME>
<RETURNS>char *</RETURNS>
const char     *location,GnomeVFSMakeURIDirs  dirs
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_canonical_strip_fragment</NAME>
<RETURNS>char *</RETURNS>
const char          *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_uris_match</NAME>
<RETURNS>gboolean </RETURNS>
const char          *uri_1,const char          *uri_2
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_uri_scheme</NAME>
<RETURNS>char *</RETURNS>
const char          *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_from_shell_arg</NAME>
<RETURNS>char *</RETURNS>
const char          *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_make_uri_full_from_relative</NAME>
<DEPRECATED/>
<RETURNS>char *</RETURNS>
const char *base_uri,const char *relative_uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_url_show</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char   *url
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_url_show_with_env</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char   *url,char        **envp
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_PRIORITY_MIN</NAME>
#define GNOME_VFS_PRIORITY_MIN     -10
</MACRO>
<MACRO>
<NAME>GNOME_VFS_PRIORITY_MAX</NAME>
#define GNOME_VFS_PRIORITY_MAX     10
</MACRO>
<MACRO>
<NAME>GNOME_VFS_PRIORITY_DEFAULT</NAME>
#define GNOME_VFS_PRIORITY_DEFAULT 0
</MACRO>
<TYPEDEF>
<NAME>GnomeVFSAsyncHandle</NAME>
typedef struct GnomeVFSAsyncHandle GnomeVFSAsyncHandle;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncOpenCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncCreateCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncCloseCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncOpenAsChannelCallback</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
							GIOChannel *channel,
							GnomeVFSResult result,
							gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncCreateAsChannelCallback</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
							  GIOChannel *channel,
							  GnomeVFSResult result,
							  gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncReadCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer buffer,
						 GnomeVFSFileSize bytes_requested,
						 GnomeVFSFileSize bytes_read,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncWriteCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gconstpointer buffer,
						 GnomeVFSFileSize bytes_requested,
						 GnomeVFSFileSize bytes_written,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncSeekCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						 GnomeVFSResult result,
						 gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncGetFileInfoCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						      GList *results,
						      gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncSetFileInfoCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
						      GnomeVFSResult result,
						      GnomeVFSFileInfo *file_info,
						      gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncDirectoryLoadCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
							GnomeVFSResult result,
							GList *list,
							guint entries_read,
							gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncXferProgressCallback</NAME>
<RETURNS>gint </RETURNS>
GnomeVFSAsyncHandle *handle,
						       GnomeVFSXferProgressInfo *info,
						       gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeVFSFindDirectoryResult</NAME>
struct _GnomeVFSFindDirectoryResult {
	/*< public >*/
	GnomeVFSURI *uri;
	GnomeVFSResult result;

	/*< private >*/
	/* Reserved to avoid future breaks in ABI compatibility */
	void *reserved1;
	void *reserved2;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSFindDirectoryResult</NAME>
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_find_directory_result_get_type</NAME>
<RETURNS>GType                        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_find_directory_result_dup</NAME>
<RETURNS>GnomeVFSFindDirectoryResult*</RETURNS>
GnomeVFSFindDirectoryResult* result
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_find_directory_result_free</NAME>
<RETURNS>void                         </RETURNS>
GnomeVFSFindDirectoryResult* result
</FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncFindDirectoryCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
							GList *results,
							gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSAsyncFileControlCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSAsyncHandle *handle,
							 GnomeVFSResult result,
							 gpointer operation_data,
							 gpointer callback_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_cancel</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_open</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,const gchar                           *text_uri,GnomeVFSOpenMode                       open_mode,int				      priority,GnomeVFSAsyncOpenCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_open_uri</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSOpenMode                       open_mode,int				      priority,GnomeVFSAsyncOpenCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_open_as_channel</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,const gchar                           *text_uri,GnomeVFSOpenMode                       open_mode,guint                                  advised_block_size,int				      priority,GnomeVFSAsyncOpenAsChannelCallback     callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_open_uri_as_channel</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSOpenMode                       open_mode,guint                                  advised_block_size,int				      priority,GnomeVFSAsyncOpenAsChannelCallback     callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_create</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,const gchar                           *text_uri,GnomeVFSOpenMode                       open_mode,gboolean                               exclusive,guint                                  perm,int				      priority,GnomeVFSAsyncOpenCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_create_uri</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSOpenMode                       open_mode,gboolean                               exclusive,guint                                  perm,int				      priority,GnomeVFSAsyncOpenCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_create_symbolic_link</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,const gchar                           *uri_reference,int				      priority,GnomeVFSAsyncOpenCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_create_as_channel</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,const gchar                           *text_uri,GnomeVFSOpenMode                       open_mode,gboolean                               exclusive,guint                                  perm,int				      priority,GnomeVFSAsyncCreateAsChannelCallback   callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_create_uri_as_channel</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSOpenMode                       open_mode,gboolean                               exclusive,guint                                  perm,int				      priority,GnomeVFSAsyncCreateAsChannelCallback   callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_close</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle,GnomeVFSAsyncCloseCallback             callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_read</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle,gpointer                               buffer,guint                                  bytes,GnomeVFSAsyncReadCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_write</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle,gconstpointer                          buffer,guint                                  bytes,GnomeVFSAsyncWriteCallback             callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_seek</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle,GnomeVFSSeekPosition                   whence,GnomeVFSFileOffset                     offset,GnomeVFSAsyncSeekCallback              callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_get_file_info</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GList                                 *uri_list,GnomeVFSFileInfoOptions                options,int				      priority,GnomeVFSAsyncGetFileInfoCallback       callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_set_file_info</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSFileInfo                      *info,GnomeVFSSetFileInfoMask                mask,GnomeVFSFileInfoOptions                options,int				      priority,GnomeVFSAsyncSetFileInfoCallback       callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_load_directory</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,const gchar                           *text_uri,GnomeVFSFileInfoOptions                options,guint                                  items_per_notification,int				      priority,GnomeVFSAsyncDirectoryLoadCallback     callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_load_directory_uri</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GnomeVFSURI                           *uri,GnomeVFSFileInfoOptions                options,guint                                  items_per_notification,int				      priority,GnomeVFSAsyncDirectoryLoadCallback     callback,gpointer                               callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_xfer</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GList                                 *source_uri_list,GList                                 *target_uri_list,GnomeVFSXferOptions                    xfer_options,GnomeVFSXferErrorMode                  error_mode,GnomeVFSXferOverwriteMode              overwrite_mode,int				      priority,GnomeVFSAsyncXferProgressCallback      progress_update_callback,gpointer                               update_callback_data,GnomeVFSXferProgressCallback           progress_sync_callback,gpointer                               sync_callback_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_find_directory</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                  **handle_return,GList                                 *near_uri_list,GnomeVFSFindDirectoryKind              kind,gboolean                               create_if_needed,gboolean                               find_if_needed,guint                                  permissions,int				      priority,GnomeVFSAsyncFindDirectoryCallback     callback,gpointer                               user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_async_file_control</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSAsyncHandle                   *handle,const char                            *operation,gpointer                               operation_data,GDestroyNotify                         operation_data_destroy_func,GnomeVFSAsyncFileControlCallback       callback,gpointer                               callback_data
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_COMMAND</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_COMMAND "command"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_NAME</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_NAME "name"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_CAN_OPEN_MULTIPLE_FILES</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_CAN_OPEN_MULTIPLE_FILES "can_open_multiple_files"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_REQUIRES_TERMINAL</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_REQUIRES_TERMINAL "requires_terminal"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_USES_GNOMEVFS</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_USES_GNOMEVFS "uses_gnomevfs"
</MACRO>
<MACRO>
<NAME>GNOME_VFS_APPLICATION_REGISTRY_STARTUP_NOTIFY</NAME>
<DEPRECATED/>
#define GNOME_VFS_APPLICATION_REGISTRY_STARTUP_NOTIFY "startup_notify"
</MACRO>
<FUNCTION>
<NAME>gnome_vfs_application_registry_exists</NAME>
<DEPRECATED/>
<RETURNS>gboolean	</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_get_keys</NAME>
<DEPRECATED/>
<RETURNS>GList      	*</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_peek_value</NAME>
<DEPRECATED/>
<RETURNS>const char 	*</RETURNS>
const char *app_id,const char *key
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_get_bool_value</NAME>
<DEPRECATED/>
<RETURNS>gboolean	</RETURNS>
const char *app_id,const char *key,gboolean *got_key
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_remove_application</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_set_value</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id,const char *key,const char *value
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_set_bool_value</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id,const char *key,gboolean value
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_unset_key</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id,const char *key
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_get_applications</NAME>
<DEPRECATED/>
<RETURNS>GList		*</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_get_mime_types</NAME>
<DEPRECATED/>
<RETURNS>GList		*</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_supports_mime_type</NAME>
<DEPRECATED/>
<RETURNS>gboolean	</RETURNS>
const char *app_id,const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_supports_uri_scheme</NAME>
<DEPRECATED/>
<RETURNS>gboolean        </RETURNS>
const char *app_id,const char *uri_scheme
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_is_user_owned_application</NAME>
<DEPRECATED/>
<RETURNS>gboolean	</RETURNS>
const GnomeVFSMimeApplication *application
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_clear_mime_types</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_add_mime_type</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id,const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_remove_mime_type</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const char *app_id,const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_sync</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_shutdown</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_reload</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_get_mime_application</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSMimeApplication  *</RETURNS>
const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_application_registry_save_mime_application</NAME>
<DEPRECATED/>
<RETURNS>void		</RETURNS>
const GnomeVFSMimeApplication *application
</FUNCTION>
<TYPEDEF>
<NAME>GnomeVFSSocket</NAME>
typedef struct GnomeVFSSocket GnomeVFSSocket;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSSocketReadFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
gpointer connection,
						   gpointer buffer, 
						   GnomeVFSFileSize bytes, 
						   GnomeVFSFileSize *bytes_read_out,
						   GnomeVFSCancellation *cancellation
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSSocketWriteFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
gpointer connection, 
						   gconstpointer buffer,
						   GnomeVFSFileSize bytes,
						   GnomeVFSFileSize *bytes_written_out,
						   GnomeVFSCancellation *cancellation
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSSocketCloseFunc</NAME>
<RETURNS>void </RETURNS>
gpointer connection,
						   GnomeVFSCancellation *cancellation
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSSocketSetTimeoutFunc</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
gpointer connection,
							GTimeVal *timeout,
							GnomeVFSCancellation *cancellation
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeVFSSocketImpl</NAME>
typedef struct {
  GnomeVFSSocketReadFunc read;
  GnomeVFSSocketWriteFunc write;
  GnomeVFSSocketCloseFunc close;
  GnomeVFSSocketSetTimeoutFunc set_timeout;
} GnomeVFSSocketImpl;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_socket_new</NAME>
<RETURNS>GnomeVFSSocket*</RETURNS>
GnomeVFSSocketImpl *impl,void               *connection
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_write</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSocket     *socket,gconstpointer       buffer,int                 bytes,GnomeVFSFileSize   *bytes_written,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_close</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSocket     *socket,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_read</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSocket     *socket,gpointer            buffer,GnomeVFSFileSize    bytes,GnomeVFSFileSize   *bytes_read,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_set_timeout</NAME>
<RETURNS>GnomeVFSResult  </RETURNS>
GnomeVFSSocket *socket,GTimeVal *timeout,GnomeVFSCancellation *cancellation
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_socket_free</NAME>
<RETURNS>void            </RETURNS>
GnomeVFSSocket *socket
</FUNCTION>
<STRUCT>
<NAME>stat</NAME>
struct stat;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_mime_shutdown</NAME>
<DEPRECATED/>
<RETURNS>void 	     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_from_name</NAME>
<DEPRECATED/>
<RETURNS>const char  *</RETURNS>
const char        *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_from_name_or_default</NAME>
<RETURNS>const char  *</RETURNS>
const char        *filename,const char        *defaultv
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_common</NAME>
<RETURNS>const char  *</RETURNS>
GnomeVFSURI       *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_from_uri</NAME>
<RETURNS>const char  *</RETURNS>
GnomeVFSURI       *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_mime_type_from_file_data</NAME>
<DEPRECATED/>
<RETURNS>const char  *</RETURNS>
GnomeVFSURI       *uri
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_mime_type_fast</NAME>
<RETURNS>const char *</RETURNS>
const char        *path,const struct stat *optional_stat_info
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_file_mime_type</NAME>
<RETURNS>const char  *</RETURNS>
const char        *path,const struct stat *optional_stat_info,gboolean           suffix_only
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_is_supertype</NAME>
<RETURNS>gboolean     </RETURNS>
const char        *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_supertype_from_mime_type</NAME>
<RETURNS>char	    *</RETURNS>
const char        *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_info_cache_reload</NAME>
<RETURNS>void         </RETURNS>
const char *dir
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_reload</NAME>
<RETURNS>void         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_kind_to_string</NAME>
<RETURNS>const char *</RETURNS>
GnomeVFSACLKind kind
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_perm_to_string</NAME>
<RETURNS>const char *</RETURNS>
GnomeVFSACLPerm perm
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_ACL</NAME>
#define GNOME_VFS_TYPE_ACL             (gnome_vfs_acl_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_ACL</NAME>
#define GNOME_VFS_ACL(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_VFS_TYPE_ACL, GnomeVFSACL))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_ACL_CLASS</NAME>
#define GNOME_VFS_ACL_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_VFS_TYPE_ACL, GnomeVFSACLClass))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_ACL</NAME>
#define GNOME_VFS_IS_ACL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_VFS_TYPE_ACL))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_ACL_CLASS</NAME>
#define GNOME_VFS_IS_ACL_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_VFS_TYPE_ACL))
</MACRO>
<STRUCT>
<NAME>GnomeVFSACL</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACLClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACLPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSACL</NAME>
struct _GnomeVFSACL {
	GObject parent;

	GnomeVFSACLPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSACLClass</NAME>
struct _GnomeVFSACLClass {
	GObjectClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_acl_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_new</NAME>
<RETURNS>GnomeVFSACL *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_clear</NAME>
<RETURNS>void          </RETURNS>
GnomeVFSACL *acl
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_set</NAME>
<RETURNS>void          </RETURNS>
GnomeVFSACL *acl,GnomeVFSACE *ace
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_unset</NAME>
<RETURNS>void          </RETURNS>
GnomeVFSACL *acl,GnomeVFSACE *ace
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_get_ace_list</NAME>
<RETURNS>GList *</RETURNS>
GnomeVFSACL *acl
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_acl_free_ace_list</NAME>
<RETURNS>void          </RETURNS>
GList       *ace_list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_value</NAME>
<RETURNS>const char 	*</RETURNS>
const char *mime_type,const char *key
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_type_is_known</NAME>
<RETURNS>gboolean	 </RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_freeze</NAME>
<RETURNS>void             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_thaw</NAME>
<RETURNS>void             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_extensions_list</NAME>
<RETURNS>GList 	   	*</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_extensions_list_free</NAME>
<RETURNS>void	   	 </RETURNS>
GList      *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_registered_type_key</NAME>
<RETURNS>GnomeVFSResult	 </RETURNS>
const char *mime_type,const char *key,const char *data
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_info_reload</NAME>
<RETURNS>void       	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_value</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult   </RETURNS>
const char *mime_type,const char *key,const char *value
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_key_list</NAME>
<DEPRECATED/>
<RETURNS>GList      	*</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_keys_list_free</NAME>
<DEPRECATED/>
<RETURNS>void             </RETURNS>
GList *mime_type_list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_extensions_string</NAME>
<DEPRECATED/>
<RETURNS>char 	   	*</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_get_extensions_pretty_string</NAME>
<DEPRECATED/>
<RETURNS>char 	   	*</RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_registered_mime_types</NAME>
<DEPRECATED/>
<RETURNS>GList 	        *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_registered_mime_type_list_free</NAME>
<DEPRECATED/>
<RETURNS>void	         </RETURNS>
GList      *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_set_extensions_list</NAME>
<DEPRECATED/>
<RETURNS>GnomeVFSResult   </RETURNS>
const char *mime_type,const char *extensions_list
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_registered_mime_type_delete</NAME>
<DEPRECATED/>
<RETURNS>void             </RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_reset</NAME>
<DEPRECATED/>
<RETURNS>void             </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GnomeVFSDNSSDService</NAME>
typedef struct {
	char *name;
	char *type;
	char *domain;
} GnomeVFSDNSSDService;
</STRUCT>
<ENUM>
<NAME>GnomeVFSDNSSDServiceStatus</NAME>
typedef enum {
	GNOME_VFS_DNS_SD_SERVICE_ADDED,
	GNOME_VFS_DNS_SD_SERVICE_REMOVED
} GnomeVFSDNSSDServiceStatus;
</ENUM>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_service_status_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VFS_DNS_SD_SERVICE_STATUS</NAME>
#define GNOME_VFS_TYPE_VFS_DNS_SD_SERVICE_STATUS (gnome_vfs_dns_sd_service_status_get_type())
</MACRO>
<TYPEDEF>
<NAME>GnomeVFSDNSSDBrowseHandle</NAME>
typedef struct GnomeVFSDNSSDBrowseHandle GnomeVFSDNSSDBrowseHandle;
</TYPEDEF>
<TYPEDEF>
<NAME>GnomeVFSDNSSDResolveHandle</NAME>
typedef struct GnomeVFSDNSSDResolveHandle GnomeVFSDNSSDResolveHandle;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSDNSSDBrowseCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDNSSDBrowseHandle *handle,
					      GnomeVFSDNSSDServiceStatus status,
					      const GnomeVFSDNSSDService *service,
					      gpointer callback_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeVFSDNSSDResolveCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDNSSDResolveHandle *handle,
					       GnomeVFSResult result,
					       const GnomeVFSDNSSDService *service,
					       const char *host,
					       int port,
					       const GHashTable *text,
					       int text_raw_len,
					       const char *text_raw,
					       gpointer callback_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_browse</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSDNSSDBrowseHandle **handle,const char *domain,const char *type,GnomeVFSDNSSDBrowseCallback callback,gpointer callback_data,GDestroyNotify callback_data_destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_stop_browse</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSDNSSDBrowseHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_resolve</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSDNSSDResolveHandle **handle,const char *name,const char *type,const char *domain,int timeout,GnomeVFSDNSSDResolveCallback callback,gpointer callback_data,GDestroyNotify callback_data_destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_cancel_resolve</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
GnomeVFSDNSSDResolveHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_browse_sync</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char *domain,const char *type,int timeout_msec,int *n_services,GnomeVFSDNSSDService **services
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_resolve_sync</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char *name,const char *type,const char *domain,int timeout_msec,char **host, int *port,GHashTable **text,int *text_raw_len_out,char **text_raw_out
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_service_list_free</NAME>
<RETURNS>void </RETURNS>
GnomeVFSDNSSDService *services,int n_services
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_dns_sd_list_browse_domains_sync</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char *domain,int timeout_msec,GList **domains
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_get_default_browse_domains</NAME>
<RETURNS>GList  *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON</NAME>
#define GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON        (gnome_vfs_volume_monitor_daemon_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR_DAEMON</NAME>
#define GNOME_VFS_VOLUME_MONITOR_DAEMON(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON, GnomeVFSVolumeMonitorDaemon))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_VOLUME_MONITOR_DAEMON_CLASS</NAME>
#define GNOME_VFS_VOLUME_MONITOR_DAEMON_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON, GnomeVFSVolumeMonitorDaemonClass))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR_DAEMON</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR_DAEMON(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON))
</MACRO>
<MACRO>
<NAME>GNOME_IS_VFS_VOLUME_MONITOR_DAEMON_CLASS</NAME>
#define GNOME_IS_VFS_VOLUME_MONITOR_DAEMON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_TYPE_VOLUME_MONITOR_DAEMON))
</MACRO>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorDaemon</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorDaemonClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorDaemon</NAME>
struct _GnomeVFSVolumeMonitorDaemon {
	GnomeVFSVolumeMonitor parent;

#ifdef USE_HAL
	LibHalContext *hal_ctx;
#endif /* USE_HAL */
	GList *last_fstab;
	GList *last_mtab;
	GList *last_connected_servers;
	
	GConfClient *gconf_client;
	guint connected_id;
};

</STRUCT>
<STRUCT>
<NAME>GnomeVFSVolumeMonitorDaemonClass</NAME>
struct _GnomeVFSVolumeMonitorDaemonClass {
	GnomeVFSVolumeMonitorClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_daemon_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_volume_monitor_daemon_force_probe</NAME>
<RETURNS>void </RETURNS>
GnomeVFSVolumeMonitor *volume_monitor_daemon
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_MIME_MONITOR_TYPE</NAME>
#define GNOME_VFS_MIME_MONITOR_TYPE        (gnome_vfs_mime_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MIME_MONITOR</NAME>
#define GNOME_VFS_MIME_MONITOR(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GNOME_VFS_MIME_MONITOR_TYPE, GnomeVFSMIMEMonitor))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_MIME_MONITOR_CLASS</NAME>
#define GNOME_VFS_MIME_MONITOR_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNOME_VFS_MIME_MONITOR_TYPE, GnomeVFSMIMEMonitorClass))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_MIME_MONITOR</NAME>
#define GNOME_VFS_IS_MIME_MONITOR(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNOME_VFS_MIME_MONITOR_TYPE))
</MACRO>
<MACRO>
<NAME>GNOME_VFS_IS_MIME_MONITOR_CLASS</NAME>
#define GNOME_VFS_IS_MIME_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_VFS_MIME_MONITOR_TYPE))
</MACRO>
<STRUCT>
<NAME>GnomeVFSMIMEMonitorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeVFSMIMEMonitor</NAME>
typedef struct {
	/*< private >*/
	GObject object;

	GnomeVFSMIMEMonitorPrivate *priv;
} GnomeVFSMIMEMonitor;
</STRUCT>
<STRUCT>
<NAME>GnomeVFSMIMEMonitorClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* signals */
	void (*data_changed) (GnomeVFSMIMEMonitor *monitor);
} GnomeVFSMIMEMonitorClass;
</STRUCT>
<FUNCTION>
<NAME>gnome_vfs_mime_monitor_get_type</NAME>
<RETURNS>GType                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_mime_monitor_get</NAME>
<RETURNS>GnomeVFSMIMEMonitor *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_VFS_SIZE_IS_UNSIGNED_LONG_LONG</NAME>
#define GNOME_VFS_SIZE_IS_UNSIGNED_LONG_LONG
</MACRO>
<MACRO>
<NAME>GNOME_VFS_OFFSET_IS_LONG_LONG</NAME>
#define GNOME_VFS_OFFSET_IS_LONG_LONG
</MACRO>
<MACRO>
<NAME>GNOME_VFS_SIZE_FORMAT_STR</NAME>
#define GNOME_VFS_SIZE_FORMAT_STR G_GUINT64_FORMAT
</MACRO>
<MACRO>
<NAME>GNOME_VFS_OFFSET_FORMAT_STR</NAME>
#define GNOME_VFS_OFFSET_FORMAT_STR G_GINT64_FORMAT
</MACRO>
<TYPEDEF>
<NAME>GnomeVFSFileSize</NAME>
G_GNUC_EXTENSION typedef guint64 GnomeVFSFileSize;
</TYPEDEF>
<TYPEDEF>
<NAME>GnomeVFSFileOffset</NAME>
G_GNUC_EXTENSION typedef gint64 GnomeVFSFileOffset;
</TYPEDEF>
<TYPEDEF>
<NAME>GnomeVFSResolveHandle</NAME>
typedef struct GnomeVFSResolveHandle_ GnomeVFSResolveHandle;
</TYPEDEF>
<FUNCTION>
<NAME>gnome_vfs_resolve</NAME>
<RETURNS>GnomeVFSResult </RETURNS>
const char              *hostname,GnomeVFSResolveHandle  **handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_resolve_next_address</NAME>
<RETURNS>gboolean       </RETURNS>
GnomeVFSResolveHandle   *handle,GnomeVFSAddress        **address
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_resolve_reset_to_beginning</NAME>
<RETURNS>void  </RETURNS>
GnomeVFSResolveHandle   *handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_resolve_free</NAME>
<RETURNS>void           </RETURNS>
GnomeVFSResolveHandle   *handle
</FUNCTION>
<ENUM>
<NAME>GnomeVFSMonitorType</NAME>
typedef enum {
  GNOME_VFS_MONITOR_FILE,
  GNOME_VFS_MONITOR_DIRECTORY
} GnomeVFSMonitorType;
</ENUM>
<ENUM>
<NAME>GnomeVFSMonitorEventType</NAME>
typedef enum {
  GNOME_VFS_MONITOR_EVENT_CHANGED,
  GNOME_VFS_MONITOR_EVENT_DELETED,
  GNOME_VFS_MONITOR_EVENT_STARTEXECUTING,
  GNOME_VFS_MONITOR_EVENT_STOPEXECUTING,
  GNOME_VFS_MONITOR_EVENT_CREATED,
  GNOME_VFS_MONITOR_EVENT_METADATA_CHANGED
} GnomeVFSMonitorEventType;
</ENUM>
<TYPEDEF>
<NAME>GnomeVFSMonitorHandle</NAME>
typedef struct GnomeVFSMonitorHandle GnomeVFSMonitorHandle;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GnomeVFSMonitorCallback</NAME>
<RETURNS>void </RETURNS>
GnomeVFSMonitorHandle *handle,
                                          const gchar *monitor_uri,
                                          const gchar *info_uri,
                                          GnomeVFSMonitorEventType event_type,
                                          gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_vfs_pty_open</NAME>
<RETURNS>int </RETURNS>
pid_t *child, guint flags, char **env_add,const char *command, char **argv, const char *directory,int columns, int rows,int *stdin_fd, int *stdout_fd, int *stderr_fd
</FUNCTION>
