GnomeVFSURI

typedef struct {
	guint ref_count;

	gchar *text;
	gchar *fragment_id;

	gchar *method_string;
	struct GnomeVFSMethod *method;

	struct GnomeVFSURI *parent;
} GnomeVFSURI;

Holds information about the location of a particular resource.

GnomeVFSToplevelURI

typedef struct {
	GnomeVFSURI uri;

	gchar *host_name;
	guint host_port;

	gchar *user_name;
	gchar *password;

	gchar *urn;
} GnomeVFSToplevelURI;

This is the toplevel URI element used to access ressources stored on a remote server. Toplevel method implementations should cast the GnomeVFSURI argument to this type to get the additional host and authentication information.

If any of the elements is 0 respectively NULL, it is unspecified.

enum GnomeVFSURIHideOptions

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; 

Packed boolean bitfield controlling hiding of various elements of a GnomeVFSURI when it is converted to a string using gnome_vfs_uri_to_string().

GNOME_VFS_URI_MAGIC_CHR

#define GNOME_VFS_URI_MAGIC_CHR	'#'

The character used to divide location from extra "arguments" passed to the method.

GNOME_VFS_URI_MAGIC_STR

#define GNOME_VFS_URI_MAGIC_STR "#"

The character used to divide location from extra "arguments" passed to the method.

GNOME_VFS_URI_PATH_CHR

#define GNOME_VFS_URI_PATH_CHR '/'

Defines the path seperator character.

GNOME_VFS_URI_PATH_STR

#define GNOME_VFS_URI_PATH_STR "/"

Defines the path seperator string.

gnome_vfs_uri_new ()

GnomeVFSURI* gnome_vfs_uri_new              (const gchar *text_uri);

Create a new uri from text_uri. Unsupported and unsafe methods are not allowed and will result in NULL being returned. URL transforms are allowed.

The a text_uri must be an escaped URI string such as returned by gnome_vfs_get_uri_from_local_path(), gnome_vfs_make_uri_from_input(), or gtk_file_chooser_get_uri().

gnome_vfs_uri_resolve_relative ()

GnomeVFSURI* gnome_vfs_uri_resolve_relative (const GnomeVFSURI *base,
                                             const gchar *relative_reference);

Create a new uri from relative_reference, relative to base. The resolution algorithm in some aspects follows RFC 2396, section 5.2, but is not identical due to some extra assumptions GnomeVFS makes about URIs.

If relative_reference begins with a valid scheme identifier followed by ':', it is assumed to refer to an absolute URI, and a GnomeVFSURI is created from it using gnome_vfs_uri_new().

Otherwise, depending on its precise syntax, it inherits some aspects of the parent URI, but the parents' fragment and query components are ignored.

If relative_reference begins with "//", it only inherits the base scheme, if it begins with '/' (i.e. is an absolute path reference), it inherits everything ecxept the base path. Otherwise, it replaces the part of base after the last '/'.

gnome_vfs_uri_resolve_symbolic_link ()

GnomeVFSURI* gnome_vfs_uri_resolve_symbolic_link
                                            (const GnomeVFSURI *base,
                                             const gchar *relative_reference);

Create a new uri from symbolic_link, relative to base.

If symbolic_link begins with a '/', it replaces the path of base, otherwise it is appended after the last '/' character of base.

Since 2.16

gnome_vfs_uri_ref ()

GnomeVFSURI* gnome_vfs_uri_ref              (GnomeVFSURI *uri);

Increment uri's reference count.

gnome_vfs_uri_unref ()

void        gnome_vfs_uri_unref             (GnomeVFSURI *uri);

Decrement uri's reference count. If the reference count reaches zero, uri is destroyed.

gnome_vfs_uri_append_string ()

GnomeVFSURI* gnome_vfs_uri_append_string    (const GnomeVFSURI *uri,
                                             const char *uri_fragment);

Create a new uri obtained by appending uri_fragment to uri. This will take care of adding an appropriate directory separator between the end of uri and the start of uri_fragment if necessary.

gnome_vfs_uri_append_path ()

GnomeVFSURI* gnome_vfs_uri_append_path      (const GnomeVFSURI *uri,
                                             const char *path);

Create a new uri obtained by appending path to uri. This will take care of adding an appropriate directory separator between the end of uri and the start of path if necessary as well as escaping path as necessary.

gnome_vfs_uri_append_file_name ()

GnomeVFSURI* gnome_vfs_uri_append_file_name (const GnomeVFSURI *uri,
                                             const gchar *filename);

Create a new uri obtained by appending file_name to uri. This will take care of adding an appropriate directory separator between the end of uri and the start of file_name if necessary. file_name might, for instance, be the result of a call to g_dir_read_name().

gnome_vfs_uri_to_string ()

gchar*      gnome_vfs_uri_to_string         (const GnomeVFSURI *uri,
                                             GnomeVFSURIHideOptions hide_options);

Translate uri into a printable string. The string will not contain the uri elements specified by hide_options.

A file: URI on Win32 might look like file:///x:/foo/bar.txt. Note that the part after file:// is not a legal file name, you need to remove the / in front of the drive letter. This function does that automatically if hide_options specifies that the toplevel method, user name, password, host name and host port should be hidden.

On the other hand, a file: URI for a UNC path looks like file:////server/share/foo/bar.txt, and in that case the part after file:// is the correct file name.

gnome_vfs_uri_dup ()

GnomeVFSURI* gnome_vfs_uri_dup              (const GnomeVFSURI *uri);

Duplicate uri.

gnome_vfs_uri_is_local ()

gboolean    gnome_vfs_uri_is_local          (const GnomeVFSURI *uri);

Check if uri is a local URI. Note that the return value of this function entirely depends on the GnomeVFSMethod associated with the URI. It is up to the method author to distinguish between remote URIs add URIs referring to entities on the local computer.

Warning, this can be slow, as it does i/o to detect things like NFS mounts.

gnome_vfs_uri_has_parent ()

gboolean    gnome_vfs_uri_has_parent        (const GnomeVFSURI *uri);

Check if uri has a parent or not.

gnome_vfs_uri_get_parent ()

GnomeVFSURI* gnome_vfs_uri_get_parent       (const GnomeVFSURI *uri);

Retrieve uri's parent uri.

gnome_vfs_uri_get_toplevel ()

GnomeVFSToplevelURI* gnome_vfs_uri_get_toplevel
                                            (const GnomeVFSURI *uri);

Retrieve the toplevel uri in uri.

gnome_vfs_uri_get_host_name ()

const gchar* gnome_vfs_uri_get_host_name    (const GnomeVFSURI *uri);

Retrieve the host name for uri.

gnome_vfs_uri_get_scheme ()

const gchar* gnome_vfs_uri_get_scheme       (const GnomeVFSURI *uri);

Retrieve the scheme used for uri.

gnome_vfs_uri_get_host_port ()

guint       gnome_vfs_uri_get_host_port     (const GnomeVFSURI *uri);

Retrieve the host port number in uri.

gnome_vfs_uri_get_user_name ()

const gchar* gnome_vfs_uri_get_user_name    (const GnomeVFSURI *uri);

Retrieve the user name in uri.

gnome_vfs_uri_get_password ()

const gchar* gnome_vfs_uri_get_password     (const GnomeVFSURI *uri);

Retrieve the password for uri.

gnome_vfs_uri_set_host_name ()

void        gnome_vfs_uri_set_host_name     (GnomeVFSURI *uri,
                                             const gchar *host_name);

Set host_name as the host name accessed by uri.

gnome_vfs_uri_set_host_port ()

void        gnome_vfs_uri_set_host_port     (GnomeVFSURI *uri,
                                             guint host_port);

Set the host port number in uri. If host_port is zero, the default port for uri's toplevel access method is used.

gnome_vfs_uri_set_user_name ()

void        gnome_vfs_uri_set_user_name     (GnomeVFSURI *uri,
                                             const gchar *user_name);

Set user_name as the user name for uri.

gnome_vfs_uri_set_password ()

void        gnome_vfs_uri_set_password      (GnomeVFSURI *uri,
                                             const gchar *password);

Set password as the password for uri.

gnome_vfs_uri_equal ()

gboolean    gnome_vfs_uri_equal             (const GnomeVFSURI *a,
                                             const GnomeVFSURI *b);

Compare a and b.

FIXME: This comparison should take into account the possiblity that unreserved characters may be escaped. ...or perhaps gnome_vfs_uri_new() should unescape unreserved characters?

gnome_vfs_uri_is_parent ()

gboolean    gnome_vfs_uri_is_parent         (const GnomeVFSURI *possible_parent,
                                             const GnomeVFSURI *possible_child,
                                             gboolean recursive);

Check if possible_child is contained by possible_parent. If recursive is FALSE, just try the immediate parent directory, else search up through the hierarchy.

gnome_vfs_uri_get_path ()

const gchar* gnome_vfs_uri_get_path         (const GnomeVFSURI *uri);

Retrieve full path name for uri.

gnome_vfs_uri_get_fragment_identifier ()

const gchar* gnome_vfs_uri_get_fragment_identifier
                                            (const GnomeVFSURI *uri);

gnome_vfs_uri_extract_dirname ()

gchar*      gnome_vfs_uri_extract_dirname   (const GnomeVFSURI *uri);

Extract the name of the directory in which the file pointed to by uri is stored as a newly allocated string. The string will end with a GNOME_VFS_URI_PATH_CHR.

gnome_vfs_uri_extract_short_name ()

gchar*      gnome_vfs_uri_extract_short_name
                                            (const GnomeVFSURI *uri);

Retrieve base file name for uri, ignoring any trailing path separators. This matches the XPG definition of basename, but not g_basename. This is often useful when you want the name of something that's pointed to by a uri, and don't care whether the uri has a directory or file form. If uri points to the root of a domain, returns the host name. If there's no host name, returns GNOME_VFS_URI_PATH_STR.

See also: gnome_vfs_uri_extract_short_path_name().

gnome_vfs_uri_extract_short_path_name ()

gchar*      gnome_vfs_uri_extract_short_path_name
                                            (const GnomeVFSURI *uri);

Retrieve base file name for uri, ignoring any trailing path separators. This matches the XPG definition of basename, but not g_basename. This is often useful when you want the name of something that's pointed to by a uri, and don't care whether the uri has a directory or file form. If uri points to the root (including the root of any domain), returns GNOME_VFS_URI_PATH_STR.

See also: gnome_vfs_uri_extract_short_name().

gnome_vfs_uri_hequal ()

gint        gnome_vfs_uri_hequal            (gconstpointer a,
                                             gconstpointer b);

Function intended for use as a hash table "are these two items the same" comparison. Useful for creating a hash table of uris.

gnome_vfs_uri_hash ()

guint       gnome_vfs_uri_hash              (gconstpointer p);

Creates an integer value from a GnomeVFSURI, appropriate for using as the key to a hash table entry.

gnome_vfs_uri_list_parse ()

GList*      gnome_vfs_uri_list_parse        (const gchar *uri_list);

Extracts a list of GnomeVFSURI objects from a standard text/uri-list, such as one you would get on a drop operation. Use gnome_vfs_uri_list_free() when you are done with the list.

gnome_vfs_uri_list_ref ()

GList*      gnome_vfs_uri_list_ref          (GList *list);

Increments the reference count of the items in list by one.

gnome_vfs_uri_list_unref ()

GList*      gnome_vfs_uri_list_unref        (GList *list);

Decrements the reference count of the items in list by one. Note that the list is *not freed* even if each member of the list is freed.

gnome_vfs_uri_list_copy ()

GList*      gnome_vfs_uri_list_copy         (GList *list);

Creates a duplicate of list, and references each member of that list.

gnome_vfs_uri_list_free ()

void        gnome_vfs_uri_list_free         (GList *list);

Decrements the reference count of each member of list by one, and frees the list itself.

gnome_vfs_uri_make_full_from_relative ()

char*       gnome_vfs_uri_make_full_from_relative
                                            (const char *base_uri,
                                             const char *relative_uri);

Returns a full uri given a full base uri, and a secondary uri which may be relative.