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