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