GContentType

GContentType — Platform-specific content typing

Synopsis


#include <gio/gio.h>

gboolean            g_content_type_equals               (const char *type1,
                                                         const char *type2);
gboolean            g_content_type_is_a                 (const char *type,
                                                         const char *supertype);
gboolean            g_content_type_is_unknown           (const char *type);
char *              g_content_type_get_description      (const char *type);
char *              g_content_type_get_mime_type        (const char *type);
GIcon *             g_content_type_get_icon             (const char *type);
gboolean            g_content_type_can_be_executable    (const char *type);
char *              g_content_type_from_mime_type       (const char *mime_type);
char *              g_content_type_guess                (const char *filename,
                                                         const guchar *data,
                                                         gsize data_size,
                                                         gboolean *result_uncertain);
char **             g_content_type_guess_for_tree       (GFile *root);
GList *             g_content_types_get_registered      (void);

Description

A content type is a platform specific string that defines the type of a file. On unix it is a mime type, on win32 it is an extension string like ".doc", ".txt" or a percieved string like "audio". Such strings can be looked up in the registry at HKEY_CLASSES_ROOT.

Details

g_content_type_equals ()

gboolean            g_content_type_equals               (const char *type1,
                                                         const char *type2);

Compares two content types for equality.

`type1` :	a content type string.
`type2` :	a content type string.
Returns :	`TRUE` if the two strings are identical or equivalent, `FALSE` otherwise.

g_content_type_is_a ()

gboolean            g_content_type_is_a                 (const char *type,
                                                         const char *supertype);

Determines if type is a subset of supertype.

`type` :	a content type string.
`supertype` :	a string.
Returns :	`TRUE` if `type` is a kind of `supertype`, `FALSE` otherwise.

g_content_type_is_unknown ()

gboolean            g_content_type_is_unknown           (const char *type);

Checks if the content type is the generic "unknown" type. On unix this is the "application/octet-stream" mimetype, while on win32 it is "*".

`type` :	a content type string.
Returns :	`TRUE` if the type is the unknown type.

g_content_type_get_description ()

char *              g_content_type_get_description      (const char *type);

Gets the human readable description of the content type.

`type` :	a content type string.
Returns :	a short description of the content type `type`.

g_content_type_get_mime_type ()

char *              g_content_type_get_mime_type        (const char *type);

Gets the mime-type for the content type. If one is registered

`type` :	a content type string.
Returns :	the registered mime-type for the given `type`, or NULL if unknown.

g_content_type_get_icon ()

GIcon *             g_content_type_get_icon             (const char *type);

Gets the icon for a content type.

`type` :	a content type string.
Returns :	GIcon corresponding to the content type.

g_content_type_can_be_executable ()

gboolean            g_content_type_can_be_executable    (const char *type);

Checks if a content type can be executable. Note that for instance things like text files can be executables (i.e. scripts and batch files).

`type` :	a content type string.
Returns :	`TRUE` if the file type corresponds to a type that can be executable, `FALSE` otherwise.

g_content_type_from_mime_type ()

char *              g_content_type_from_mime_type       (const char *mime_type);

Tries to find a content type based on the mime type name.

`mime_type` :	a mime type string.
Returns :	Newly allocated string with content type or NULL when does not know.

Since 2.18

g_content_type_guess ()

char *              g_content_type_guess                (const char *filename,
                                                         const guchar *data,
                                                         gsize data_size,
                                                         gboolean *result_uncertain);

Guesses the content type based on example data. If the function is uncertain, result_uncertain will be set to TRUE. Either filename or data may be NULL, in which case the guess will be based solely on the other argument.

`filename` :	a string, or `NULL`
`data` :	a stream of data, or `NULL`
`data_size` :	the size of `data`
`result_uncertain` :	a flag indicating the certainty of the result
Returns :	a string indicating a guessed content type for the given data.

g_content_type_guess_for_tree ()

char **             g_content_type_guess_for_tree       (GFile *root);

Tries to guess the type of the tree with root root, by looking at the files it contains. The result is an array of content types, with the best guess coming first.

The types returned all have the form x-content/foo, e.g. x-content/audio-cdda (for audio CDs) or x-content/image-dcf (for a camera memory card). See the shared-mime-info specification for more on x-content types.

This function is useful in the implementation of g_mount_guess_content_type().

`root` :	the root of the tree to guess a type for
Returns :	an `NULL`-terminated array of zero or more content types, or `NULL`. Free with `g_strfreev()`

Since 2.18

g_content_types_get_registered ()

GList *             g_content_types_get_registered      (void);

Gets a list of strings containing all the registered content types known to the system. The list and its data should be freed using g_list_foreach(list, g_free, NULL) and g_list_free(list)

Returns :

GList of the registered content types.

			GIO Reference Manual
Top \| Description