1 /* GTK - The GIMP Toolkit
2 * gtkrecentfilter.h - Filter object for recently used resources
3 * Copyright (C) 2006, Emmanuele Bassi
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
24 #include "gtkrecentfilter.h"
25 #include "gtkobject.h"
27 #include "gtkprivate.h"
32 #define XDG_PREFIX _gtk_xdg
33 #include "xdgmime/xdgmime.h"
36 typedef struct _GtkRecentFilterClass GtkRecentFilterClass;
37 typedef struct _FilterRule FilterRule;
41 FILTER_RULE_DISPLAY_NAME,
42 FILTER_RULE_MIME_TYPE,
43 FILTER_RULE_PIXBUF_FORMATS,
44 FILTER_RULE_APPLICATION,
50 struct _GtkRecentFilter
52 GtkObject parent_instance;
57 GtkRecentFilterFlags needed;
60 struct _GtkRecentFilterClass
62 GtkObjectClass parent_class;
68 GtkRecentFilterFlags needed;
74 GSList *pixbuf_formats;
79 GtkRecentFilterFunc func;
81 GDestroyNotify data_destroy;
86 G_DEFINE_TYPE (GtkRecentFilter, gtk_recent_filter, GTK_TYPE_OBJECT)
90 filter_rule_free (FilterRule *rule)
94 case FILTER_RULE_MIME_TYPE:
95 g_free (rule->u.mime_type);
100 case FILTER_RULE_DISPLAY_NAME:
101 g_free (rule->u.pattern);
103 case FILTER_RULE_PIXBUF_FORMATS:
104 g_slist_free (rule->u.pixbuf_formats);
106 case FILTER_RULE_AGE:
108 case FILTER_RULE_APPLICATION:
109 g_free (rule->u.application);
111 case FILTER_RULE_GROUP:
112 g_free (rule->u.group);
114 case FILTER_RULE_CUSTOM:
115 if (rule->u.custom.data_destroy)
116 rule->u.custom.data_destroy (rule->u.custom.data);
119 g_assert_not_reached ();
127 gtk_recent_filter_finalize (GObject *object)
129 GtkRecentFilter *filter = GTK_RECENT_FILTER (object);
131 g_free (filter->name);
135 g_slist_foreach (filter->rules,
136 (GFunc) filter_rule_free,
138 g_slist_free (filter->rules);
141 G_OBJECT_CLASS (gtk_recent_filter_parent_class)->finalize (object);
145 gtk_recent_filter_class_init (GtkRecentFilterClass *klass)
147 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
149 gobject_class->finalize = gtk_recent_filter_finalize;
153 gtk_recent_filter_init (GtkRecentFilter *filter)
163 * gtk_recent_filter_new:
165 * Creates a new #GtkRecentFilter with no rules added to it.
166 * Such filter does not accept any recently used resources, so is not
167 * particularly useful until you add rules with
168 * gtk_recent_filter_add_pattern(), gtk_recent_filter_add_mime_type(),
169 * gtk_recent_filter_add_application(), gtk_recent_filter_add_age().
170 * To create a filter that accepts any recently used resource, use:
172 * GtkRecentFilter *filter = gtk_recent_filter_new ();
173 * gtk_recent_filter_add_pattern (filter, "*");
176 * Return value: a new #GtkRecentFilter
181 gtk_recent_filter_new (void)
183 return g_object_new (GTK_TYPE_RECENT_FILTER, NULL);
187 * gtk_recent_filter_set_name:
188 * @filter: a #GtkRecentFilter
189 * @name: then human readable name of @filter
191 * Sets the human-readable name of the filter; this is the string
192 * that will be displayed in the recently used resources selector
193 * user interface if there is a selectable list of filters.
198 gtk_recent_filter_set_name (GtkRecentFilter *filter,
201 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
203 g_free (filter->name);
206 filter->name = g_strdup (name);
210 * gtk_recent_filter_get_name:
211 * @filter: a #GtkRecentFilter
213 * Gets the human-readable name for the filter.
214 * See gtk_recent_filter_set_name().
216 * Return value: the name of the filter, or %NULL. The returned string
217 * is owned by the filter object and should not be freed.
221 G_CONST_RETURN gchar *
222 gtk_recent_filter_get_name (GtkRecentFilter *filter)
224 g_return_val_if_fail (GTK_IS_RECENT_FILTER (filter), NULL);
230 * gtk_recent_filter_get_needed:
231 * @filter: a #GtkRecentFilter
233 * Gets the fields that need to be filled in for the structure
234 * passed to gtk_recent_filter_filter()
236 * This function will not typically be used by applications; it
237 * is intended principally for use in the implementation of
240 * Return value: bitfield of flags indicating needed fields when
241 * calling gtk_recent_filter_filter()
246 gtk_recent_filter_get_needed (GtkRecentFilter *filter)
248 return filter->needed;
252 recent_filter_add_rule (GtkRecentFilter *filter,
255 filter->needed |= rule->needed;
256 filter->rules = g_slist_append (filter->rules, rule);
260 * gtk_recent_filter_add_mime_type:
261 * @filter: a #GtkRecentFilter
262 * @mime_type: a MIME type
264 * Adds a rule that allows resources based on their registered MIME type.
269 gtk_recent_filter_add_mime_type (GtkRecentFilter *filter,
270 const gchar *mime_type)
274 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
275 g_return_if_fail (mime_type != NULL);
277 rule = g_new0 (FilterRule, 1);
278 rule->type = FILTER_RULE_MIME_TYPE;
279 rule->needed = GTK_RECENT_FILTER_MIME_TYPE;
280 rule->u.mime_type = g_strdup (mime_type);
282 recent_filter_add_rule (filter, rule);
286 * gtk_recent_filter_add_pattern:
287 * @filter: a #GtkRecentFilter
288 * @pattern: a file pattern
290 * Adds a rule that allows resources based on a pattern matching their
296 gtk_recent_filter_add_pattern (GtkRecentFilter *filter,
297 const gchar *pattern)
301 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
302 g_return_if_fail (pattern != NULL);
304 rule = g_new0 (FilterRule, 1);
305 rule->type = FILTER_RULE_DISPLAY_NAME;
306 rule->needed = GTK_RECENT_FILTER_DISPLAY_NAME;
307 rule->u.pattern = g_strdup (pattern);
309 recent_filter_add_rule (filter, rule);
313 * gtk_recent_filter_add_pixbuf_formats:
314 * @filter: a #GtkRecentFilter
316 * Adds a rule allowing image files in the formats supported
322 gtk_recent_filter_add_pixbuf_formats (GtkRecentFilter *filter)
326 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
328 rule = g_new0 (FilterRule, 1);
329 rule->type = FILTER_RULE_PIXBUF_FORMATS;
330 rule->needed = GTK_RECENT_FILTER_MIME_TYPE;
331 rule->u.pixbuf_formats = gdk_pixbuf_get_formats ();
333 recent_filter_add_rule (filter, rule);
337 * gtk_recent_filter_add_application:
338 * @filter: a #GtkRecentFilter
339 * @application: an application name
341 * Adds a rule that allows resources based on the name of the application
342 * that has registered them.
347 gtk_recent_filter_add_application (GtkRecentFilter *filter,
348 const gchar *application)
352 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
353 g_return_if_fail (application != NULL);
355 rule = g_new0 (FilterRule, 1);
356 rule->type = FILTER_RULE_APPLICATION;
357 rule->needed = GTK_RECENT_FILTER_APPLICATION;
358 rule->u.application = g_strdup (application);
360 recent_filter_add_rule (filter, rule);
364 * gtk_recent_filter_add_group:
365 * @filter: a #GtkRecentFilter
366 * @group: a group name
368 * Adds a rule that allows resources based on the name of the group
369 * to which they belong
374 gtk_recent_filter_add_group (GtkRecentFilter *filter,
379 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
380 g_return_if_fail (group != NULL);
382 rule = g_new0 (FilterRule, 1);
383 rule->type = FILTER_RULE_GROUP;
384 rule->needed = GTK_RECENT_FILTER_GROUP;
385 rule->u.group = g_strdup (group);
387 recent_filter_add_rule (filter, rule);
391 * gtk_recent_filter_add_age:
392 * @filter: a #GtkRecentFilter
393 * @days: number of days
395 * Adds a rule that allows resources based on their age - that is, the number
396 * of days elapsed since they were last modified.
401 gtk_recent_filter_add_age (GtkRecentFilter *filter,
406 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
408 rule = g_new0 (FilterRule, 1);
409 rule->type = FILTER_RULE_AGE;
410 rule->needed = GTK_RECENT_FILTER_AGE;
413 recent_filter_add_rule (filter, rule);
417 * gtk_recent_filter_add_custom:
418 * @filter: a #GtkRecentFilter
419 * @needed: bitfield of flags indicating the information that the custom
420 * filter function needs.
421 * @func: callback function; if the function returns %TRUE, then
422 * the file will be displayed.
423 * @data: data to pass to @func
424 * @data_destroy: function to call to free @data when it is no longer needed.
426 * Adds a rule to a filter that allows resources based on a custom callback
427 * function. The bitfield @needed which is passed in provides information
428 * about what sorts of information that the filter function needs;
429 * this allows GTK+ to avoid retrieving expensive information when
430 * it isn't needed by the filter.
435 gtk_recent_filter_add_custom (GtkRecentFilter *filter,
436 GtkRecentFilterFlags needed,
437 GtkRecentFilterFunc func,
439 GDestroyNotify data_destroy)
443 g_return_if_fail (GTK_IS_RECENT_FILTER (filter));
444 g_return_if_fail (func != NULL);
446 rule = g_new0 (FilterRule, 1);
447 rule->type = FILTER_RULE_CUSTOM;
448 rule->needed = needed;
449 rule->u.custom.func = func;
450 rule->u.custom.data = data;
451 rule->u.custom.data_destroy = data_destroy;
453 recent_filter_add_rule (filter, rule);
458 * gtk_recent_filter_filter:
459 * @filter: a #GtkRecentFilter
460 * @filter_info: a #GtkRecentFilterInfo structure containing information
461 * about a recently used resource
463 * Tests whether a file should be displayed according to @filter.
464 * The #GtkRecentFilterInfo structure @filter_info should include
465 * the fields returned from gtk_recent_filter_get_needed().
467 * This function will not typically be used by applications; it
468 * is intended principally for use in the implementation of
471 * Return value: %TRUE if the file should be displayed
476 gtk_recent_filter_filter (GtkRecentFilter *filter,
477 const GtkRecentFilterInfo *filter_info)
481 g_return_val_if_fail (GTK_IS_RECENT_FILTER (filter), FALSE);
482 g_return_val_if_fail (filter_info != NULL, FALSE);
484 for (l = filter->rules; l != NULL; l = l->next)
486 FilterRule *rule = (FilterRule *) l->data;
488 if ((filter_info->contains & rule->needed) != rule->needed)
493 case FILTER_RULE_MIME_TYPE:
494 if ((filter_info->mime_type != NULL)
496 && (xdg_mime_mime_type_subclass (filter_info->mime_type, rule->u.mime_type)))
498 && (strcmp (filter_info->mime_type, rule->u.mime_type) == 0))
502 case FILTER_RULE_APPLICATION:
503 if (filter_info->applications)
507 for (i = 0; filter_info->applications[i] != NULL; i++)
509 if (strcmp (filter_info->applications[i], rule->u.application) == 0)
514 case FILTER_RULE_GROUP:
515 if (filter_info->groups)
519 for (i = 0; filter_info->groups[i] != NULL; i++)
521 if (strcmp (filter_info->groups[i], rule->u.group) == 0)
526 case FILTER_RULE_PIXBUF_FORMATS:
529 if (!filter_info->mime_type)
532 for (list = rule->u.pixbuf_formats; list; list = list->next)
537 mime_types = gdk_pixbuf_format_get_mime_types (list->data);
539 for (i = 0; mime_types[i] != NULL; i++)
541 if (strcmp (mime_types[i], filter_info->mime_type) == 0)
543 g_strfreev (mime_types);
548 g_strfreev (mime_types);
552 case FILTER_RULE_URI:
553 if ((filter_info->uri != NULL) &&
554 _gtk_fnmatch (rule->u.uri, filter_info->uri, FALSE))
557 case FILTER_RULE_DISPLAY_NAME:
558 if ((filter_info->display_name != NULL) &&
559 _gtk_fnmatch (rule->u.pattern, filter_info->display_name, FALSE))
562 case FILTER_RULE_AGE:
563 if ((filter_info->age != -1) &&
564 (filter_info->age < rule->u.age))
567 case FILTER_RULE_CUSTOM:
568 if (rule->u.custom.func (filter_info, rule->u.custom.data))
577 #define __GTK_RECENT_FILTER_C__
578 #include "gtkaliasdef.c"