enum MateVFSMimeActionType

typedef enum {
	MATE_VFS_MIME_ACTION_TYPE_NONE,
	MATE_VFS_MIME_ACTION_TYPE_APPLICATION,
	MATE_VFS_MIME_ACTION_TYPE_COMPONENT
} MateVFSMimeActionType;

This is used to specify the type of a MateVFSMimeAction.

enum MateVFSMimeApplicationArgumentType

typedef enum {
	MATE_VFS_MIME_APPLICATION_ARGUMENT_TYPE_URIS,
	MATE_VFS_MIME_APPLICATION_ARGUMENT_TYPE_PATHS,
	MATE_VFS_MIME_APPLICATION_ARGUMENT_TYPE_URIS_FOR_NON_FILES
} MateVFSMimeApplicationArgumentType;

struct MateVFSMimeAction

struct MateVFSMimeAction {
	MateVFSMimeActionType action_type;
	union {
		void *component;
		void *dummy_component;
		MateVFSMimeApplication *application;
	} action;
};

This data structure describes an action that can be done on a file.

mate_vfs_mime_get_default_action_type ()

MateVFSMimeActionType mate_vfs_mime_get_default_action_type
                                                        (const char *mime_type);

Query the MIME database for the type of action to be performed on mime_type.

mate_vfs_mime_get_default_action ()

MateVFSMimeAction * mate_vfs_mime_get_default_action    (const char *mime_type);

Query the MIME database for default action associated with mime_type.

mate_vfs_mime_get_short_list_applications ()

GList *             mate_vfs_mime_get_short_list_applications
                                                        (const char *mime_type);

Return an alphabetically sorted list of MateVFSMimeApplication data structures for the mime_type. mate-vfs no longer supports the concept of a "short list" of applications that the user might be interested in.

mate_vfs_mime_get_short_list_components ()

GList *             mate_vfs_mime_get_short_list_components
                                                        (const char *mime_type);

mate_vfs_mime_set_default_action_type ()

MateVFSResult       mate_vfs_mime_set_default_action_type
                                                        (const char *mime_type,
                                                         MateVFSMimeActionType action_type);

Sets the default action type to be performed on files of mime_type.

mate_vfs_mime_set_icon ()

MateVFSResult       mate_vfs_mime_set_icon              (const char *mime_type,
                                                         const char *filename);

Set the icon entry for mime_type in the MIME database. Note that icon entries need not necessarily contain the full path, and do not necessarily need to specify an extension. So "i-regular", "my-special-icon.png", and "some-icon" are all valid icon filenames.

mate_vfs_mime_set_description ()

MateVFSResult       mate_vfs_mime_set_description       (const char *mime_type,
                                                         const char *description);

Set the description of this MIME type in the MIME database. The description should be something like "Gnumeric spreadsheet".

mate_vfs_mime_set_can_be_executable ()

MateVFSResult       mate_vfs_mime_set_can_be_executable (const char *mime_type,
                                                         gboolean new_value);

Set whether files of mime_type might conceivably be executable.

mate_vfs_mime_set_short_list_applications ()

MateVFSResult       mate_vfs_mime_set_short_list_applications
                                                        (const char *mime_type,
                                                         GList *application_ids);

Set the short list of applications for the specified MIME type. The short list contains applications recommended for possible selection by the user.

mate_vfs_mime_set_short_list_components ()

MateVFSResult       mate_vfs_mime_set_short_list_components
                                                        (const char *mime_type,
                                                         GList *component_iids);

Set the short list of components for the mime_type. The short list contains companents recommended for possible selection by the user.

mate_vfs_mime_add_application_to_short_list ()

MateVFSResult       mate_vfs_mime_add_application_to_short_list
                                                        (const char *mime_type,
                                                         const char *application_id);

Add an application to the short list for mime_type. The short list contains applications recommended for display as choices to the user for a particular MIME type.

mate_vfs_mime_remove_application_from_short_list ()

MateVFSResult       mate_vfs_mime_remove_application_from_short_list
                                                        (const char *mime_type,
                                                         const char *application_id);

Remove an application specified by application_id from the short list for mime_type. A short list contains applications recommended for display as choices to the user for a particular MIME type.

mate_vfs_mime_add_component_to_short_list ()

MateVFSResult       mate_vfs_mime_add_component_to_short_list
                                                        (const char *mime_type,
                                                         const char *iid);

Add a component to the short list for mime_type. A short list contains components recommended for display as choices to the user for a particular MIME type.

mate_vfs_mime_remove_component_from_short_list ()

MateVFSResult       mate_vfs_mime_remove_component_from_short_list
                                                        (const char *mime_type,
                                                         const char *iid);

Remove a component from the short list for mime_type. The short list contains components recommended for display as choices to the user for a particular MIME type.

mate_vfs_mime_set_default_application ()

MateVFSResult       mate_vfs_mime_set_default_application
                                                        (const char *mime_type,
                                                         const char *application_id);

Sets the default application to be run on files of mime_type.

mate_vfs_mime_set_default_component ()

MateVFSResult       mate_vfs_mime_set_default_component (const char *mime_type,
                                                         const char *component_iid);

Sets the default component to be activated for files of mime_type.

mate_vfs_mime_add_extension ()

MateVFSResult       mate_vfs_mime_add_extension         (const char *mime_type,
                                                         const char *extension);

Add a file extension to the specificed MIME type in the MIME database.

mate_vfs_mime_remove_extension ()

MateVFSResult       mate_vfs_mime_remove_extension      (const char *mime_type,
                                                         const char *extension);

Removes a file extension from the mime_type in the MIME database.

mate_vfs_mime_extend_all_applications ()

MateVFSResult       mate_vfs_mime_extend_all_applications
                                                        (const char *mime_type,
                                                         GList *application_ids);

Register mime_type as being handled by all applications list in application_ids.

mate_vfs_mime_remove_from_all_applications ()

MateVFSResult       mate_vfs_mime_remove_from_all_applications
                                                        (const char *mime_type,
                                                         GList *application_ids);

Remove mime_type as a handled type from every application in application_ids

mate_vfs_mime_application_new_from_id ()

MateVFSMimeApplication * mate_vfs_mime_application_new_from_id
                                                        (const char *id);

Fetches the MateVFSMimeApplication associated with the specified application id from the MIME database.

mate_vfs_mime_action_launch ()

MateVFSResult       mate_vfs_mime_action_launch         (MateVFSMimeAction *action,
                                                         GList *uris);

Launches the given mime action with the given parameters. If the action is an application the command line parameters will be expanded as required by the application. The application will also be launched in a terminal if that is required. If the application only supports one argument per instance then multiple instances of the application will be launched.

If the default action is a component it will be launched with the component viewer application defined using the mateconf value: /desktop/mate/application/component_viewer/exec. The parameters s and c in the command line will be replaced with the list of parameters and the default component IID respectively.

Since 2.4

mate_vfs_mime_action_launch_with_env ()

MateVFSResult       mate_vfs_mime_action_launch_with_env
                                                        (MateVFSMimeAction *action,
                                                         GList *uris,
                                                         char **envp);

Same as mate_vfs_mime_action_launch() except that the application or component viewer will be launched with the given environment.

Since 2.4

mate_vfs_mime_action_free ()

void                mate_vfs_mime_action_free           (MateVFSMimeAction *action);

Frees a MateVFSMimeAction *.

mate_vfs_mime_id_in_application_list ()

gboolean            mate_vfs_mime_id_in_application_list
                                                        (const char *id,
                                                         GList *applications);

Check whether an application id is in a list of MateVFSMimeApplications.

mate_vfs_mime_id_in_component_list ()

gboolean            mate_vfs_mime_id_in_component_list  (const char *iid,
                                                         GList *components);

mate_vfs_mime_remove_application_from_list ()

GList *             mate_vfs_mime_remove_application_from_list
                                                        (GList *applications,
                                                         const char *application_id,
                                                         gboolean *did_remove);

Remove an application specified by id from a list of MateVFSMimeApplications.

mate_vfs_mime_remove_component_from_list ()

GList *             mate_vfs_mime_remove_component_from_list
                                                        (GList *components,
                                                         const char *iid,
                                                         gboolean *did_remove);

mate_vfs_mime_id_list_from_component_list ()

GList *             mate_vfs_mime_id_list_from_component_list
                                                        (GList *components);

mate_vfs_mime_id_list_from_application_list ()

GList *             mate_vfs_mime_id_list_from_application_list
                                                        (GList *applications);

Create a list of application ids from a list of MateVFSMimeApplications.

mate_vfs_mime_freeze ()

void                mate_vfs_mime_freeze                (void);

Freezes the mime data so that you can do multiple updates to the data in one batch without needing to back the files to disk or reading them.

mate_vfs_mime_thaw ()

void                mate_vfs_mime_thaw                  (void);

UnFreezes the mime data so that you can do multiple updates to the data in one batch without needing to back the files to disk or reading them.

mate_vfs_mime_info_reload ()

void                mate_vfs_mime_info_reload           (void);

Reload the MIME database from disk and notify any listeners holding active MateVFSMIMEMonitor objects.

mate_vfs_mime_type_is_known ()

gboolean            mate_vfs_mime_type_is_known         (const char *mime_type);

This function returns TRUE if mime_type is in the MIME database at all.

mate_vfs_mime_get_value ()

const char *        mate_vfs_mime_get_value             (const char *mime_type,
                                                         const char *key);

This function retrieves the value associated with key in the given MateMimeContext. The string is private, you should not free the result.

mate_vfs_mime_set_value ()

MateVFSResult       mate_vfs_mime_set_value             (const char *mime_type,
                                                         const char *key,
                                                         const char *value);

This function will set the value for the key and it will save it to the user' file if necessary. You should not free the key/value passed to this function. They are used internally.

mate_vfs_mime_get_key_list ()

GList *             mate_vfs_mime_get_key_list          (const char *mime_type);

mate_vfs_mime_keys_list_free ()

void                mate_vfs_mime_keys_list_free        (GList *mime_type_list);

mate_vfs_mime_get_extensions_list ()

GList *             mate_vfs_mime_get_extensions_list   (const char *mime_type);

Get the file extensions associated with mime type mime_type.

mate_vfs_mime_extensions_list_free ()

void                mate_vfs_mime_extensions_list_free  (GList *list);

Call this function on the list returned by mate_vfs_mime_get_extensions_list() to free the list and all of its elements.

mate_vfs_mime_get_extensions_string ()

char *              mate_vfs_mime_get_extensions_string (const char *mime_type);

mate_vfs_mime_get_extensions_pretty_string ()

char *              mate_vfs_mime_get_extensions_pretty_string
                                                        (const char *mime_type);

mate_vfs_get_registered_mime_types ()

GList *             mate_vfs_get_registered_mime_types  (void);

mate_vfs_mime_registered_mime_type_list_free ()

void                mate_vfs_mime_registered_mime_type_list_free
                                                        (GList *list);

mate_vfs_mime_set_registered_type_key ()

MateVFSResult       mate_vfs_mime_set_registered_type_key
                                                        (const char *mime_type,
                                                         const char *key,
                                                         const char *data);

mate_vfs_mime_set_extensions_list ()

MateVFSResult       mate_vfs_mime_set_extensions_list   (const char *mime_type,
                                                         const char *extensions_list);

mate_vfs_mime_registered_mime_type_delete ()

void                mate_vfs_mime_registered_mime_type_delete
                                                        (const char *mime_type);

mate_vfs_mime_reset ()

void                mate_vfs_mime_reset                 (void);