/* GTK - The GIMP Toolkit * gtkfilefilter.c: Filters for selecting a file subset * Copyright (C) 2003, Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include "config.h" #include #include "gtkfilefilter.h" #include "gtkintl.h" #include "gtkprivate.h" #include "gtkalias.h" typedef struct _GtkFileFilterClass GtkFileFilterClass; typedef struct _FilterRule FilterRule; #define GTK_FILE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_FILTER, GtkFileFilterClass)) #define GTK_IS_FILE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_FILTER)) #define GTK_FILE_FILTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_FILTER, GtkFileFilterClass)) typedef enum { FILTER_RULE_PATTERN, FILTER_RULE_MIME_TYPE, FILTER_RULE_PIXBUF_FORMATS, FILTER_RULE_CUSTOM } FilterRuleType; struct _GtkFileFilterClass { GtkObjectClass parent_class; }; struct _GtkFileFilter { GtkObject parent_instance; gchar *name; GSList *rules; GtkFileFilterFlags needed; }; struct _FilterRule { FilterRuleType type; GtkFileFilterFlags needed; union { gchar *pattern; gchar *mime_type; GSList *pixbuf_formats; struct { GtkFileFilterFunc func; gpointer data; GDestroyNotify notify; } custom; } u; }; static void gtk_file_filter_finalize (GObject *object); G_DEFINE_TYPE (GtkFileFilter, gtk_file_filter, GTK_TYPE_OBJECT) static void gtk_file_filter_init (GtkFileFilter *object) { } static void gtk_file_filter_class_init (GtkFileFilterClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); gobject_class->finalize = gtk_file_filter_finalize; } static void filter_rule_free (FilterRule *rule) { switch (rule->type) { case FILTER_RULE_MIME_TYPE: g_free (rule->u.mime_type); break; case FILTER_RULE_PATTERN: g_free (rule->u.pattern); break; case FILTER_RULE_CUSTOM: if (rule->u.custom.notify) rule->u.custom.notify (rule->u.custom.data); break; case FILTER_RULE_PIXBUF_FORMATS: g_slist_free (rule->u.pixbuf_formats); break; default: g_assert_not_reached (); } g_slice_free (FilterRule, rule); } static void gtk_file_filter_finalize (GObject *object) { GtkFileFilter *filter = GTK_FILE_FILTER (object); g_slist_foreach (filter->rules, (GFunc)filter_rule_free, NULL); g_slist_free (filter->rules); g_free (filter->name); G_OBJECT_CLASS (gtk_file_filter_parent_class)->finalize (object); } /** * gtk_file_filter_new: * * Creates a new #GtkFileFilter with no rules added to it. * Such a filter doesn't accept any files, so is not * particularly useful until you add rules with * gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(), * or gtk_file_filter_add_custom(). To create a filter * that accepts any file, use: * |[ * GtkFileFilter *filter = gtk_file_filter_new (); * gtk_file_filter_add_pattern (filter, "*"); * ]| * * Return value: a new #GtkFileFilter * * Since: 2.4 **/ GtkFileFilter * gtk_file_filter_new (void) { return g_object_new (GTK_TYPE_FILE_FILTER, NULL); } /** * gtk_file_filter_set_name: * @filter: a #GtkFileFilter * @name: (allow-none): the human-readable-name for the filter, or %NULL * to remove any existing name. * * Sets the human-readable name of the filter; this is the string * that will be displayed in the file selector user interface if * there is a selectable list of filters. * * Since: 2.4 **/ void gtk_file_filter_set_name (GtkFileFilter *filter, const gchar *name) { g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_free (filter->name); filter->name = g_strdup (name); } /** * gtk_file_filter_get_name: * @filter: a #GtkFileFilter * * Gets the human-readable name for the filter. See gtk_file_filter_set_name(). * * Return value: The human-readable name of the filter, * or %NULL. This value is owned by GTK+ and must not * be modified or freed. * * Since: 2.4 **/ const gchar * gtk_file_filter_get_name (GtkFileFilter *filter) { g_return_val_if_fail (GTK_IS_FILE_FILTER (filter), NULL); return filter->name; } static void file_filter_add_rule (GtkFileFilter *filter, FilterRule *rule) { filter->needed |= rule->needed; filter->rules = g_slist_append (filter->rules, rule); } /** * gtk_file_filter_add_mime_type: * @filter: A #GtkFileFilter * @mime_type: name of a MIME type * * Adds a rule allowing a given mime type to @filter. * * Since: 2.4 **/ void gtk_file_filter_add_mime_type (GtkFileFilter *filter, const gchar *mime_type) { FilterRule *rule; g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (mime_type != NULL); rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_MIME_TYPE; rule->needed = GTK_FILE_FILTER_MIME_TYPE; rule->u.mime_type = g_strdup (mime_type); file_filter_add_rule (filter, rule); } /** * gtk_file_filter_add_pattern: * @filter: a #GtkFileFilter * @pattern: a shell style glob * * Adds a rule allowing a shell style glob to a filter. * * Since: 2.4 **/ void gtk_file_filter_add_pattern (GtkFileFilter *filter, const gchar *pattern) { FilterRule *rule; g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (pattern != NULL); rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_PATTERN; rule->needed = GTK_FILE_FILTER_DISPLAY_NAME; rule->u.pattern = g_strdup (pattern); file_filter_add_rule (filter, rule); } /** * gtk_file_filter_add_pixbuf_formats: * @filter: a #GtkFileFilter * * Adds a rule allowing image files in the formats supported * by GdkPixbuf. * * Since: 2.6 **/ void gtk_file_filter_add_pixbuf_formats (GtkFileFilter *filter) { FilterRule *rule; g_return_if_fail (GTK_IS_FILE_FILTER (filter)); rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_PIXBUF_FORMATS; rule->needed = GTK_FILE_FILTER_MIME_TYPE; rule->u.pixbuf_formats = gdk_pixbuf_get_formats (); file_filter_add_rule (filter, rule); } /** * gtk_file_filter_add_custom: * @filter: a #GtkFileFilter * @needed: bitfield of flags indicating the information that the custom * filter function needs. * @func: callback function; if the function returns %TRUE, then * the file will be displayed. * @data: data to pass to @func * @notify: function to call to free @data when it is no longer needed. * * Adds rule to a filter that allows files based on a custom callback * function. The bitfield @needed which is passed in provides information * about what sorts of information that the filter function needs; * this allows GTK+ to avoid retrieving expensive information when * it isn't needed by the filter. * * Since: 2.4 **/ void gtk_file_filter_add_custom (GtkFileFilter *filter, GtkFileFilterFlags needed, GtkFileFilterFunc func, gpointer data, GDestroyNotify notify) { FilterRule *rule; g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (func != NULL); rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_CUSTOM; rule->needed = needed; rule->u.custom.func = func; rule->u.custom.data = data; rule->u.custom.notify = notify; file_filter_add_rule (filter, rule); } /** * gtk_file_filter_get_needed: * @filter: a #GtkFileFilter * * Gets the fields that need to be filled in for the structure * passed to gtk_file_filter_filter() * * This function will not typically be used by applications; it * is intended principally for use in the implementation of * #GtkFileChooser. * * Return value: bitfield of flags indicating needed fields when * calling gtk_file_filter_filter() * * Since: 2.4 **/ GtkFileFilterFlags gtk_file_filter_get_needed (GtkFileFilter *filter) { return filter->needed; } /** * gtk_file_filter_filter: * @filter: a #GtkFileFilter * @filter_info: a #GtkFileFilterInfo structure containing information * about a file. * * Tests whether a file should be displayed according to @filter. * The #GtkFileFilterInfo structure @filter_info should include * the fields returned from gtk_file_filter_get_needed(). * * This function will not typically be used by applications; it * is intended principally for use in the implementation of * #GtkFileChooser. * * Return value: %TRUE if the file should be displayed * * Since: 2.4 **/ gboolean gtk_file_filter_filter (GtkFileFilter *filter, const GtkFileFilterInfo *filter_info) { GSList *tmp_list; for (tmp_list = filter->rules; tmp_list; tmp_list = tmp_list->next) { FilterRule *rule = tmp_list->data; if ((filter_info->contains & rule->needed) != rule->needed) continue; switch (rule->type) { case FILTER_RULE_MIME_TYPE: if (filter_info->mime_type != NULL) { gchar *filter_content_type, *rule_content_type; gboolean match; filter_content_type = g_content_type_from_mime_type (filter_info->mime_type); rule_content_type = g_content_type_from_mime_type (rule->u.mime_type); match = g_content_type_is_a (filter_content_type, rule_content_type); g_free (filter_content_type); g_free (rule_content_type); if (match) return TRUE; } break; case FILTER_RULE_PATTERN: if (filter_info->display_name != NULL && _gtk_fnmatch (rule->u.pattern, filter_info->display_name, FALSE)) return TRUE; break; case FILTER_RULE_PIXBUF_FORMATS: { GSList *list; if (!filter_info->mime_type) break; for (list = rule->u.pixbuf_formats; list; list = list->next) { int i; gchar **mime_types; mime_types = gdk_pixbuf_format_get_mime_types (list->data); for (i = 0; mime_types[i] != NULL; i++) { if (strcmp (mime_types[i], filter_info->mime_type) == 0) { g_strfreev (mime_types); return TRUE; } } g_strfreev (mime_types); } break; } case FILTER_RULE_CUSTOM: if (rule->u.custom.func (filter_info, rule->u.custom.data)) return TRUE; break; } } return FALSE; } #define __GTK_FILE_FILTER_C__ #include "gtkaliasdef.c"