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