## 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.