Pileus Git - ~andy/gtk/blob - gtk/gtkfilefilter.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkfilefilter.c: Filters for selecting a file subset
   3  * Copyright (C) 2003, Red Hat, Inc.
   4  *
   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.
   9  *
  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.
  14  *
  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.
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23
  24 #include "gtkfilefilter.h"
  25 #include "gtkintl.h"
  26 #include "gtkprivate.h"
  27
  28 typedef struct _GtkFileFilterClass GtkFileFilterClass;
  29 typedef struct _FilterRule FilterRule;
  30
  31 #define GTK_FILE_FILTER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_FILTER, GtkFileFilterClass))
  32 #define GTK_IS_FILE_FILTER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_FILTER))
  33 #define GTK_FILE_FILTER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_FILTER, GtkFileFilterClass))
  34
  35 typedef enum {
  36   FILTER_RULE_PATTERN,
  37   FILTER_RULE_MIME_TYPE,
  38   FILTER_RULE_PIXBUF_FORMATS,
  39   FILTER_RULE_CUSTOM
  40 } FilterRuleType;
  41
  42 struct _GtkFileFilterClass
  43 {
  44   GtkObjectClass parent_class;
  45 };
  46
  47 struct _GtkFileFilter
  48 {
  49   GtkObject parent_instance;
  50
  51   gchar *name;
  52   GSList *rules;
  53
  54   GtkFileFilterFlags needed;
  55 };
  56
  57 struct _FilterRule
  58 {
  59   FilterRuleType type;
  60   GtkFileFilterFlags needed;
  61
  62   union {
  63     gchar *pattern;
  64     gchar *mime_type;
  65     GSList *pixbuf_formats;
  66     struct {
  67       GtkFileFilterFunc func;
  68       gpointer data;
  69       GDestroyNotify notify;
  70     } custom;
  71   } u;
  72 };
  73
  74 static void gtk_file_filter_finalize   (GObject            *object);
  75
  76
  77 G_DEFINE_TYPE (GtkFileFilter, gtk_file_filter, GTK_TYPE_OBJECT)
  78
  79 static void
  80 gtk_file_filter_init (GtkFileFilter *object)
  81 {
  82 }
  83
  84 static void
  85 gtk_file_filter_class_init (GtkFileFilterClass *class)
  86 {
  87   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
  88
  89   gobject_class->finalize = gtk_file_filter_finalize;
  90 }
  91
  92 static void
  93 filter_rule_free (FilterRule *rule)
  94 {
  95   switch (rule->type)
  96     {
  97     case FILTER_RULE_MIME_TYPE:
  98       g_free (rule->u.mime_type);
  99       break;
 100     case FILTER_RULE_PATTERN:
 101       g_free (rule->u.pattern);
 102       break;
 103     case FILTER_RULE_CUSTOM:
 104       if (rule->u.custom.notify)
 105         rule->u.custom.notify (rule->u.custom.data);
 106       break;
 107     case FILTER_RULE_PIXBUF_FORMATS:
 108       g_slist_free (rule->u.pixbuf_formats);
 109       break;
 110     default:
 111       g_assert_not_reached ();
 112     }
 113
 114   g_slice_free (FilterRule, rule);
 115 }
 116
 117 static void
 118 gtk_file_filter_finalize (GObject  *object)
 119 {
 120   GtkFileFilter *filter = GTK_FILE_FILTER (object);
 121
 122   g_slist_foreach (filter->rules, (GFunc)filter_rule_free, NULL);
 123   g_slist_free (filter->rules);
 124
 125   g_free (filter->name);
 126
 127   G_OBJECT_CLASS (gtk_file_filter_parent_class)->finalize (object);
 128 }
 129
 130 /**
 131  * gtk_file_filter_new:
 132  *
 133  * Creates a new #GtkFileFilter with no rules added to it.
 134  * Such a filter doesn't accept any files, so is not
 135  * particularly useful until you add rules with
 136  * gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(),
 137  * or gtk_file_filter_add_custom(). To create a filter
 138  * that accepts any file, use:
 139  * |[
 140  * GtkFileFilter *filter = gtk_file_filter_new ();
 141  * gtk_file_filter_add_pattern (filter, "*");
 142  * ]|
 143  *
 144  * Return value: a new #GtkFileFilter
 145  *
 146  * Since: 2.4
 147  **/
 148 GtkFileFilter *
 149 gtk_file_filter_new (void)
 150 {
 151   return g_object_new (GTK_TYPE_FILE_FILTER, NULL);
 152 }
 153
 154 /**
 155  * gtk_file_filter_set_name:
 156  * @filter: a #GtkFileFilter
 157  * @name: (allow-none): the human-readable-name for the filter, or %NULL
 158  *   to remove any existing name.
 159  *
 160  * Sets the human-readable name of the filter; this is the string
 161  * that will be displayed in the file selector user interface if
 162  * there is a selectable list of filters.
 163  *
 164  * Since: 2.4
 165  **/
 166 void
 167 gtk_file_filter_set_name (GtkFileFilter *filter,
 168                           const gchar   *name)
 169 {
 170   g_return_if_fail (GTK_IS_FILE_FILTER (filter));
 171
 172   g_free (filter->name);
 173
 174   filter->name = g_strdup (name);
 175 }
 176
 177 /**
 178  * gtk_file_filter_get_name:
 179  * @filter: a #GtkFileFilter
 180  *
 181  * Gets the human-readable name for the filter. See gtk_file_filter_set_name().
 182  *
 183  * Return value: The human-readable name of the filter,
 184  *   or %NULL. This value is owned by GTK+ and must not
 185  *   be modified or freed.
 186  *
 187  * Since: 2.4
 188  **/
 189 G_CONST_RETURN gchar *
 190 gtk_file_filter_get_name (GtkFileFilter *filter)
 191 {
 192   g_return_val_if_fail (GTK_IS_FILE_FILTER (filter), NULL);
 193
 194   return filter->name;
 195 }
 196
 197 static void
 198 file_filter_add_rule (GtkFileFilter *filter,
 199                       FilterRule    *rule)
 200 {
 201   filter->needed |= rule->needed;
 202   filter->rules = g_slist_append (filter->rules, rule);
 203 }
 204
 205 /**
 206  * gtk_file_filter_add_mime_type:
 207  * @filter: A #GtkFileFilter
 208  * @mime_type: name of a MIME type
 209  *
 210  * Adds a rule allowing a given mime type to @filter.
 211  *
 212  * Since: 2.4
 213  **/
 214 void
 215 gtk_file_filter_add_mime_type (GtkFileFilter *filter,
 216                                const gchar   *mime_type)
 217 {
 218   FilterRule *rule;
 219
 220   g_return_if_fail (GTK_IS_FILE_FILTER (filter));
 221   g_return_if_fail (mime_type != NULL);
 222
 223   rule = g_slice_new (FilterRule);
 224   rule->type = FILTER_RULE_MIME_TYPE;
 225   rule->needed = GTK_FILE_FILTER_MIME_TYPE;
 226   rule->u.mime_type = g_strdup (mime_type);
 227
 228   file_filter_add_rule (filter, rule);
 229 }
 230
 231 /**
 232  * gtk_file_filter_add_pattern:
 233  * @filter: a #GtkFileFilter
 234  * @pattern: a shell style glob
 235  *
 236  * Adds a rule allowing a shell style glob to a filter.
 237  *
 238  * Since: 2.4
 239  **/
 240 void
 241 gtk_file_filter_add_pattern (GtkFileFilter *filter,
 242                              const gchar   *pattern)
 243 {
 244   FilterRule *rule;
 245
 246   g_return_if_fail (GTK_IS_FILE_FILTER (filter));
 247   g_return_if_fail (pattern != NULL);
 248
 249   rule = g_slice_new (FilterRule);
 250   rule->type = FILTER_RULE_PATTERN;
 251   rule->needed = GTK_FILE_FILTER_DISPLAY_NAME;
 252   rule->u.pattern = g_strdup (pattern);
 253
 254   file_filter_add_rule (filter, rule);
 255 }
 256
 257 /**
 258  * gtk_file_filter_add_pixbuf_formats:
 259  * @filter: a #GtkFileFilter
 260  *
 261  * Adds a rule allowing image files in the formats supported
 262  * by GdkPixbuf.
 263  *
 264  * Since: 2.6
 265  **/
 266 void
 267 gtk_file_filter_add_pixbuf_formats (GtkFileFilter *filter)
 268 {
 269   FilterRule *rule;
 270
 271   g_return_if_fail (GTK_IS_FILE_FILTER (filter));
 272
 273   rule = g_slice_new (FilterRule);
 274   rule->type = FILTER_RULE_PIXBUF_FORMATS;
 275   rule->needed = GTK_FILE_FILTER_MIME_TYPE;
 276   rule->u.pixbuf_formats = gdk_pixbuf_get_formats ();
 277   file_filter_add_rule (filter, rule);
 278 }
 279
 280
 281 /**
 282  * gtk_file_filter_add_custom:
 283  * @filter: a #GtkFileFilter
 284  * @needed: bitfield of flags indicating the information that the custom
 285  *          filter function needs.
 286  * @func: callback function; if the function returns %TRUE, then
 287  *   the file will be displayed.
 288  * @data: data to pass to @func
 289  * @notify: function to call to free @data when it is no longer needed.
 290  *
 291  * Adds rule to a filter that allows files based on a custom callback
 292  * function. The bitfield @needed which is passed in provides information
 293  * about what sorts of information that the filter function needs;
 294  * this allows GTK+ to avoid retrieving expensive information when
 295  * it isn't needed by the filter.
 296  *
 297  * Since: 2.4
 298  **/
 299 void
 300 gtk_file_filter_add_custom (GtkFileFilter         *filter,
 301                             GtkFileFilterFlags     needed,
 302                             GtkFileFilterFunc      func,
 303                             gpointer               data,
 304                             GDestroyNotify         notify)
 305 {
 306   FilterRule *rule;
 307
 308   g_return_if_fail (GTK_IS_FILE_FILTER (filter));
 309   g_return_if_fail (func != NULL);
 310
 311   rule = g_slice_new (FilterRule);
 312   rule->type = FILTER_RULE_CUSTOM;
 313   rule->needed = needed;
 314   rule->u.custom.func = func;
 315   rule->u.custom.data = data;
 316   rule->u.custom.notify = notify;
 317
 318   file_filter_add_rule (filter, rule);
 319 }
 320
 321 /**
 322  * gtk_file_filter_get_needed:
 323  * @filter: a #GtkFileFilter
 324  *
 325  * Gets the fields that need to be filled in for the structure
 326  * passed to gtk_file_filter_filter()
 327  *
 328  * This function will not typically be used by applications; it
 329  * is intended principally for use in the implementation of
 330  * #GtkFileChooser.
 331  *
 332  * Return value: bitfield of flags indicating needed fields when
 333  *   calling gtk_file_filter_filter()
 334  *
 335  * Since: 2.4
 336  **/
 337 GtkFileFilterFlags
 338 gtk_file_filter_get_needed (GtkFileFilter *filter)
 339 {
 340   return filter->needed;
 341 }
 342
 343 /**
 344  * gtk_file_filter_filter:
 345  * @filter: a #GtkFileFilter
 346  * @filter_info: a #GtkFileFilterInfo structure containing information
 347  *  about a file.
 348  *
 349  * Tests whether a file should be displayed according to @filter.
 350  * The #GtkFileFilterInfo structure @filter_info should include
 351  * the fields returned from gtk_file_filter_get_needed().
 352  *
 353  * This function will not typically be used by applications; it
 354  * is intended principally for use in the implementation of
 355  * #GtkFileChooser.
 356  *
 357  * Return value: %TRUE if the file should be displayed
 358  *
 359  * Since: 2.4
 360  **/
 361 gboolean
 362 gtk_file_filter_filter (GtkFileFilter           *filter,
 363                         const GtkFileFilterInfo *filter_info)
 364 {
 365   GSList *tmp_list;
 366
 367   for (tmp_list = filter->rules; tmp_list; tmp_list = tmp_list->next)
 368     {
 369       FilterRule *rule = tmp_list->data;
 370
 371       if ((filter_info->contains & rule->needed) != rule->needed)
 372         continue;
 373
 374       switch (rule->type)
 375         {
 376         case FILTER_RULE_MIME_TYPE:
 377           if (filter_info->mime_type != NULL &&
 378               g_content_type_is_a (filter_info->mime_type, rule->u.mime_type))
 379             return TRUE;
 380           break;
 381         case FILTER_RULE_PATTERN:
 382           if (filter_info->display_name != NULL &&
 383               _gtk_fnmatch (rule->u.pattern, filter_info->display_name, FALSE))
 384             return TRUE;
 385           break;
 386         case FILTER_RULE_PIXBUF_FORMATS:
 387           {
 388             GSList *list;
 389
 390             if (!filter_info->mime_type)
 391               break;
 392
 393             for (list = rule->u.pixbuf_formats; list; list = list->next)
 394               {
 395                 int i;
 396                 gchar **mime_types;
 397
 398                 mime_types = gdk_pixbuf_format_get_mime_types (list->data);
 399
 400                 for (i = 0; mime_types[i] != NULL; i++)
 401                   {
 402                     if (strcmp (mime_types[i], filter_info->mime_type) == 0)
 403                       {
 404                         g_strfreev (mime_types);
 405                         return TRUE;
 406                       }
 407                   }
 408
 409                 g_strfreev (mime_types);
 410               }
 411             break;
 412           }
 413         case FILTER_RULE_CUSTOM:
 414           if (rule->u.custom.func (filter_info, rule->u.custom.data))
 415             return TRUE;
 416           break;
 417         }
 418     }
 419
 420   return FALSE;
 421 }