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