X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkfilefilter.c;h=5b060960c07e1848439fb501d02d9a02ac87cbb7;hb=b9e189150bfd62c9e956e29324622058672600f0;hp=826c171937b1cdc49712b5aecf7e942e8576b979;hpb=56913b4b3b4d5cb49d375d22a3521748bf9d897e;p=~andy%2Fgtk diff --git a/gtk/gtkfilefilter.c b/gtk/gtkfilefilter.c index 826c17193..5b060960c 100644 --- a/gtk/gtkfilefilter.c +++ b/gtk/gtkfilefilter.c @@ -13,15 +13,67 @@ * 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. + * License along with this library. If not, see . */ +/** + * SECTION:gtkfilefilter + * @Short_description: A filter for selecting a file subset + * @Title: GtkFileFilter + * @see_also: #GtkFileChooser + * + * A GtkFileFilter can be used to restrict the files being shown in a + * #GtkFileChooser. Files can be filtered based on their name (with + * gtk_file_filter_add_pattern()), on their mime type (with + * gtk_file_filter_add_mime_type()), or by a custom filter function + * (with gtk_file_filter_add_custom()). + * + * Filtering by mime types handles aliasing and subclassing of mime + * types; e.g. a filter for text/plain also matches a file with mime + * type application/rtf, since application/rtf is a subclass of + * text/plain. Note that #GtkFileFilter allows wildcards for the + * subtype of a mime type, so you can e.g. filter for image/*. + * + * Normally, filters are used by adding them to a #GtkFileChooser, + * see gtk_file_chooser_add_filter(), but it is also possible + * to manually use a filter on a file with gtk_file_filter_filter(). + * + * + * GtkFileFilter as GtkBuildable + * + * The GtkFileFilter implementation of the GtkBuildable interface + * supports adding rules using the <mime-types>, <patterns> and + * <applications> elements and listing the rules within. Specifying + * a <mime-type> or <pattern> is the same + * as calling gtk_recent_filter_add_mime_type() or gtk_recent_filter_add_pattern() + * + * + * A UI definition fragment specifying GtkFileFilter rules + * + * + * text/plain + * image/* + * + * + * *.txt + * *.png + * + * + * ]]> + * + * + * + */ + +#include "config.h" #include +#include + #include "gtkfilefilter.h" -#include "gtkobject.h" +#include "gtkbuildable.h" +#include "gtkintl.h" #include "gtkprivate.h" typedef struct _GtkFileFilterClass GtkFileFilterClass; @@ -34,18 +86,19 @@ typedef struct _FilterRule FilterRule; typedef enum { FILTER_RULE_PATTERN, FILTER_RULE_MIME_TYPE, + FILTER_RULE_PIXBUF_FORMATS, FILTER_RULE_CUSTOM } FilterRuleType; struct _GtkFileFilterClass { - GtkObjectClass parent_class; + GInitiallyUnownedClass parent_class; }; struct _GtkFileFilter { - GtkObject parent_instance; - + GInitiallyUnowned parent_instance; + gchar *name; GSList *rules; @@ -60,6 +113,7 @@ struct _FilterRule union { gchar *pattern; gchar *mime_type; + GSList *pixbuf_formats; struct { GtkFileFilterFunc func; gpointer data; @@ -68,36 +122,29 @@ struct _FilterRule } u; }; -static void gtk_file_filter_class_init (GtkFileFilterClass *class); static void gtk_file_filter_finalize (GObject *object); -static GObjectClass *parent_class; -GType -gtk_file_filter_get_type (void) -{ - static GType file_filter_type = 0; +static void gtk_file_filter_buildable_init (GtkBuildableIface *iface); +static gboolean gtk_file_filter_buildable_custom_tag_start (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + GMarkupParser *parser, + gpointer *data); +static void gtk_file_filter_buildable_custom_tag_end (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + gpointer *data); - if (!file_filter_type) - { - static const GTypeInfo file_filter_info = - { - sizeof (GtkFileFilterClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_file_filter_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (GtkFileFilter), - 0, /* n_preallocs */ - NULL /* init */ - }; - - file_filter_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkFileFilter", - &file_filter_info, 0); - } +G_DEFINE_TYPE_WITH_CODE (GtkFileFilter, gtk_file_filter, G_TYPE_INITIALLY_UNOWNED, + G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, + gtk_file_filter_buildable_init)) - return file_filter_type; +static void +gtk_file_filter_init (GtkFileFilter *object) +{ } static void @@ -105,8 +152,6 @@ gtk_file_filter_class_init (GtkFileFilterClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); - parent_class = g_type_class_peek_parent (class); - gobject_class->finalize = gtk_file_filter_finalize; } @@ -125,11 +170,14 @@ filter_rule_free (FilterRule *rule) 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_free (rule); + g_slice_free (FilterRule, rule); } static void @@ -140,12 +188,160 @@ gtk_file_filter_finalize (GObject *object) g_slist_foreach (filter->rules, (GFunc)filter_rule_free, NULL); g_slist_free (filter->rules); - if (filter->name) - g_free (filter->name); + g_free (filter->name); + + G_OBJECT_CLASS (gtk_file_filter_parent_class)->finalize (object); +} + +/* + * GtkBuildable implementation + */ +static void +gtk_file_filter_buildable_init (GtkBuildableIface *iface) +{ + iface->custom_tag_start = gtk_file_filter_buildable_custom_tag_start; + iface->custom_tag_end = gtk_file_filter_buildable_custom_tag_end; +} + +typedef enum { + PARSE_MIME_TYPES, + PARSE_PATTERNS +} ParserType; + +typedef struct { + GtkFileFilter *filter; + ParserType type; + GString *string; + gboolean parsing; +} SubParserData; + +static void +parser_start_element (GMarkupParseContext *context, + const gchar *element_name, + const gchar **names, + const gchar **values, + gpointer user_data, + GError **error) +{ + SubParserData *parser_data = (SubParserData*)user_data; + + if (strcmp (element_name, "mime-types") == 0) + return; + else if (strcmp (element_name, "mime-type") == 0) + { + parser_data->parsing = TRUE; + return; + } + else if (strcmp (element_name, "patterns") == 0) + return; + else if (strcmp (element_name, "pattern") == 0) + { + parser_data->parsing = TRUE; + return; + } + else + g_warning ("Unsupported tag for GtkFileFilter: %s\n", element_name); +} + +static void +parser_text_element (GMarkupParseContext *context, + const gchar *text, + gsize text_len, + gpointer user_data, + GError **error) +{ + SubParserData *parser_data = (SubParserData*)user_data; + + if (parser_data->parsing) + g_string_append_len (parser_data->string, text, text_len); +} + +static void +parser_end_element (GMarkupParseContext *context, + const gchar *element_name, + gpointer user_data, + GError **error) +{ + SubParserData *parser_data = (SubParserData*)user_data; + + if (parser_data->string) + { + switch (parser_data->type) + { + case PARSE_MIME_TYPES: + gtk_file_filter_add_mime_type (parser_data->filter, parser_data->string->str); + break; + case PARSE_PATTERNS: + gtk_file_filter_add_pattern (parser_data->filter, parser_data->string->str); + break; + default: + break; + } + } - parent_class->finalize (object); + g_string_set_size (parser_data->string, 0); + parser_data->parsing = FALSE; } +static const GMarkupParser sub_parser = + { + parser_start_element, + parser_end_element, + parser_text_element, + }; + +static gboolean +gtk_file_filter_buildable_custom_tag_start (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + GMarkupParser *parser, + gpointer *data) +{ + SubParserData *parser_data = NULL; + + if (strcmp (tagname, "mime-types") == 0) + { + parser_data = g_slice_new0 (SubParserData); + parser_data->string = g_string_new (""); + parser_data->type = PARSE_MIME_TYPES; + parser_data->filter = GTK_FILE_FILTER (buildable); + + *parser = sub_parser; + *data = parser_data; + } + else if (strcmp (tagname, "patterns") == 0) + { + parser_data = g_slice_new0 (SubParserData); + parser_data->string = g_string_new (""); + parser_data->type = PARSE_PATTERNS; + parser_data->filter = GTK_FILE_FILTER (buildable); + + *parser = sub_parser; + *data = parser_data; + } + + return parser_data != NULL; +} + +static void +gtk_file_filter_buildable_custom_tag_end (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + gpointer *data) +{ + if (strcmp (tagname, "mime-types") == 0 || + strcmp (tagname, "patterns") == 0) + { + SubParserData *parser_data = (SubParserData*)data; + + g_string_free (parser_data->string, TRUE); + g_slice_free (SubParserData, parser_data); + } +} + + /** * gtk_file_filter_new: * @@ -155,11 +351,10 @@ gtk_file_filter_finalize (GObject *object) * 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 (); + * |[ + * GtkFileFilter *filter = gtk_file_filter_new (); * gtk_file_filter_add_pattern (filter, "*"); - * + * ]| * * Return value: a new #GtkFileFilter * @@ -174,7 +369,7 @@ gtk_file_filter_new (void) /** * gtk_file_filter_set_name: * @filter: a #GtkFileFilter - * @name: the human-readable-name for the filter, or %NULL + * @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 @@ -189,8 +384,7 @@ gtk_file_filter_set_name (GtkFileFilter *filter, { g_return_if_fail (GTK_IS_FILE_FILTER (filter)); - if (filter->name) - g_free (filter->name); + g_free (filter->name); filter->name = g_strdup (name); } @@ -207,7 +401,7 @@ gtk_file_filter_set_name (GtkFileFilter *filter, * * Since: 2.4 **/ -G_CONST_RETURN gchar * +const gchar * gtk_file_filter_get_name (GtkFileFilter *filter) { g_return_val_if_fail (GTK_IS_FILE_FILTER (filter), NULL); @@ -241,7 +435,7 @@ gtk_file_filter_add_mime_type (GtkFileFilter *filter, g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (mime_type != NULL); - rule = g_new (FilterRule, 1); + 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); @@ -267,7 +461,7 @@ gtk_file_filter_add_pattern (GtkFileFilter *filter, g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (pattern != NULL); - rule = g_new (FilterRule, 1); + rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_PATTERN; rule->needed = GTK_FILE_FILTER_DISPLAY_NAME; rule->u.pattern = g_strdup (pattern); @@ -275,6 +469,30 @@ gtk_file_filter_add_pattern (GtkFileFilter *filter, 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 @@ -305,7 +523,7 @@ gtk_file_filter_add_custom (GtkFileFilter *filter, g_return_if_fail (GTK_IS_FILE_FILTER (filter)); g_return_if_fail (func != NULL); - rule = g_new (FilterRule, 1); + rule = g_slice_new (FilterRule); rule->type = FILTER_RULE_CUSTOM; rule->needed = needed; rule->u.custom.func = func; @@ -345,7 +563,7 @@ gtk_file_filter_get_needed (GtkFileFilter *filter) * * Tests whether a file should be displayed according to @filter. * The #GtkFileFilterInfo structure @filter_info should include - * the fields returned feom gtk_file_filter_get_needed(). + * 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 @@ -371,14 +589,42 @@ gtk_file_filter_filter (GtkFileFilter *filter, switch (rule->type) { case FILTER_RULE_MIME_TYPE: - if (filter_info->mime_type != NULL - && strcmp (rule->u.mime_type, filter_info->mime_type) == 0) + if (filter_info->mime_type != NULL && + g_content_type_is_a (filter_info->mime_type, rule->u.mime_type)) return TRUE; break; case FILTER_RULE_PATTERN: - if (_gtk_fnmatch (rule->u.pattern, filter_info->display_name)) + 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;