/* GTK - The GIMP Toolkit
* gtkfilefilter.c: Filters for selecting a file subset
* Copyright (C) 2003, Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include "gtkfilefilter.h"
#include "gtkintl.h"
#include "gtkprivate.h"
#include "gtkalias.h"
typedef struct _GtkFileFilterClass GtkFileFilterClass;
typedef struct _FilterRule FilterRule;
#define GTK_FILE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_FILTER, GtkFileFilterClass))
#define GTK_IS_FILE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_FILTER))
#define GTK_FILE_FILTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_FILTER, GtkFileFilterClass))
typedef enum {
FILTER_RULE_PATTERN,
FILTER_RULE_MIME_TYPE,
FILTER_RULE_PIXBUF_FORMATS,
FILTER_RULE_CUSTOM
} FilterRuleType;
struct _GtkFileFilterClass
{
GtkObjectClass parent_class;
};
struct _GtkFileFilter
{
GtkObject parent_instance;
gchar *name;
GSList *rules;
GtkFileFilterFlags needed;
};
struct _FilterRule
{
FilterRuleType type;
GtkFileFilterFlags needed;
union {
gchar *pattern;
gchar *mime_type;
GSList *pixbuf_formats;
struct {
GtkFileFilterFunc func;
gpointer data;
GDestroyNotify notify;
} custom;
} u;
};
static void gtk_file_filter_finalize (GObject *object);
G_DEFINE_TYPE (GtkFileFilter, gtk_file_filter, GTK_TYPE_OBJECT)
static void
gtk_file_filter_init (GtkFileFilter *object)
{
}
static void
gtk_file_filter_class_init (GtkFileFilterClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
gobject_class->finalize = gtk_file_filter_finalize;
}
static void
filter_rule_free (FilterRule *rule)
{
switch (rule->type)
{
case FILTER_RULE_MIME_TYPE:
g_free (rule->u.mime_type);
break;
case FILTER_RULE_PATTERN:
g_free (rule->u.pattern);
break;
case FILTER_RULE_CUSTOM:
if (rule->u.custom.notify)
rule->u.custom.notify (rule->u.custom.data);
break;
case FILTER_RULE_PIXBUF_FORMATS:
g_slist_free (rule->u.pixbuf_formats);
break;
default:
g_assert_not_reached ();
}
g_slice_free (FilterRule, rule);
}
static void
gtk_file_filter_finalize (GObject *object)
{
GtkFileFilter *filter = GTK_FILE_FILTER (object);
g_slist_foreach (filter->rules, (GFunc)filter_rule_free, NULL);
g_slist_free (filter->rules);
g_free (filter->name);
G_OBJECT_CLASS (gtk_file_filter_parent_class)->finalize (object);
}
/**
* gtk_file_filter_new:
*
* Creates a new #GtkFileFilter with no rules added to it.
* Such a filter doesn't accept any files, so is not
* particularly useful until you add rules with
* gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(),
* or gtk_file_filter_add_custom(). To create a filter
* that accepts any file, use:
* |[
* GtkFileFilter *filter = gtk_file_filter_new ();
* gtk_file_filter_add_pattern (filter, "*");
* ]|
*
* Return value: a new #GtkFileFilter
*
* Since: 2.4
**/
GtkFileFilter *
gtk_file_filter_new (void)
{
return g_object_new (GTK_TYPE_FILE_FILTER, NULL);
}
/**
* gtk_file_filter_set_name:
* @filter: a #GtkFileFilter
* @name: (allow-none): the human-readable-name for the filter, or %NULL
* to remove any existing name.
*
* Sets the human-readable name of the filter; this is the string
* that will be displayed in the file selector user interface if
* there is a selectable list of filters.
*
* Since: 2.4
**/
void
gtk_file_filter_set_name (GtkFileFilter *filter,
const gchar *name)
{
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_free (filter->name);
filter->name = g_strdup (name);
}
/**
* gtk_file_filter_get_name:
* @filter: a #GtkFileFilter
*
* Gets the human-readable name for the filter. See gtk_file_filter_set_name().
*
* Return value: The human-readable name of the filter,
* or %NULL. This value is owned by GTK+ and must not
* be modified or freed.
*
* Since: 2.4
**/
const gchar *
gtk_file_filter_get_name (GtkFileFilter *filter)
{
g_return_val_if_fail (GTK_IS_FILE_FILTER (filter), NULL);
return filter->name;
}
static void
file_filter_add_rule (GtkFileFilter *filter,
FilterRule *rule)
{
filter->needed |= rule->needed;
filter->rules = g_slist_append (filter->rules, rule);
}
/**
* gtk_file_filter_add_mime_type:
* @filter: A #GtkFileFilter
* @mime_type: name of a MIME type
*
* Adds a rule allowing a given mime type to @filter.
*
* Since: 2.4
**/
void
gtk_file_filter_add_mime_type (GtkFileFilter *filter,
const gchar *mime_type)
{
FilterRule *rule;
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (mime_type != NULL);
rule = g_slice_new (FilterRule);
rule->type = FILTER_RULE_MIME_TYPE;
rule->needed = GTK_FILE_FILTER_MIME_TYPE;
rule->u.mime_type = g_strdup (mime_type);
file_filter_add_rule (filter, rule);
}
/**
* gtk_file_filter_add_pattern:
* @filter: a #GtkFileFilter
* @pattern: a shell style glob
*
* Adds a rule allowing a shell style glob to a filter.
*
* Since: 2.4
**/
void
gtk_file_filter_add_pattern (GtkFileFilter *filter,
const gchar *pattern)
{
FilterRule *rule;
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (pattern != NULL);
rule = g_slice_new (FilterRule);
rule->type = FILTER_RULE_PATTERN;
rule->needed = GTK_FILE_FILTER_DISPLAY_NAME;
rule->u.pattern = g_strdup (pattern);
file_filter_add_rule (filter, rule);
}
/**
* gtk_file_filter_add_pixbuf_formats:
* @filter: a #GtkFileFilter
*
* Adds a rule allowing image files in the formats supported
* by GdkPixbuf.
*
* Since: 2.6
**/
void
gtk_file_filter_add_pixbuf_formats (GtkFileFilter *filter)
{
FilterRule *rule;
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
rule = g_slice_new (FilterRule);
rule->type = FILTER_RULE_PIXBUF_FORMATS;
rule->needed = GTK_FILE_FILTER_MIME_TYPE;
rule->u.pixbuf_formats = gdk_pixbuf_get_formats ();
file_filter_add_rule (filter, rule);
}
/**
* gtk_file_filter_add_custom:
* @filter: a #GtkFileFilter
* @needed: bitfield of flags indicating the information that the custom
* filter function needs.
* @func: callback function; if the function returns %TRUE, then
* the file will be displayed.
* @data: data to pass to @func
* @notify: function to call to free @data when it is no longer needed.
*
* Adds rule to a filter that allows files based on a custom callback
* function. The bitfield @needed which is passed in provides information
* about what sorts of information that the filter function needs;
* this allows GTK+ to avoid retrieving expensive information when
* it isn't needed by the filter.
*
* Since: 2.4
**/
void
gtk_file_filter_add_custom (GtkFileFilter *filter,
GtkFileFilterFlags needed,
GtkFileFilterFunc func,
gpointer data,
GDestroyNotify notify)
{
FilterRule *rule;
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (func != NULL);
rule = g_slice_new (FilterRule);
rule->type = FILTER_RULE_CUSTOM;
rule->needed = needed;
rule->u.custom.func = func;
rule->u.custom.data = data;
rule->u.custom.notify = notify;
file_filter_add_rule (filter, rule);
}
/**
* gtk_file_filter_get_needed:
* @filter: a #GtkFileFilter
*
* Gets the fields that need to be filled in for the structure
* passed to gtk_file_filter_filter()
*
* This function will not typically be used by applications; it
* is intended principally for use in the implementation of
* #GtkFileChooser.
*
* Return value: bitfield of flags indicating needed fields when
* calling gtk_file_filter_filter()
*
* Since: 2.4
**/
GtkFileFilterFlags
gtk_file_filter_get_needed (GtkFileFilter *filter)
{
return filter->needed;
}
/**
* gtk_file_filter_filter:
* @filter: a #GtkFileFilter
* @filter_info: a #GtkFileFilterInfo structure containing information
* about a file.
*
* Tests whether a file should be displayed according to @filter.
* The #GtkFileFilterInfo structure @filter_info should include
* the fields returned from gtk_file_filter_get_needed().
*
* This function will not typically be used by applications; it
* is intended principally for use in the implementation of
* #GtkFileChooser.
*
* Return value: %TRUE if the file should be displayed
*
* Since: 2.4
**/
gboolean
gtk_file_filter_filter (GtkFileFilter *filter,
const GtkFileFilterInfo *filter_info)
{
GSList *tmp_list;
for (tmp_list = filter->rules; tmp_list; tmp_list = tmp_list->next)
{
FilterRule *rule = tmp_list->data;
if ((filter_info->contains & rule->needed) != rule->needed)
continue;
switch (rule->type)
{
case FILTER_RULE_MIME_TYPE:
if (filter_info->mime_type != NULL)
{
gchar *filter_content_type, *rule_content_type;
gboolean match;
filter_content_type = g_content_type_from_mime_type (filter_info->mime_type);
rule_content_type = g_content_type_from_mime_type (rule->u.mime_type);
match = g_content_type_is_a (filter_content_type, rule_content_type);
g_free (filter_content_type);
g_free (rule_content_type);
if (match)
return TRUE;
}
break;
case FILTER_RULE_PATTERN:
if (filter_info->display_name != NULL &&
_gtk_fnmatch (rule->u.pattern, filter_info->display_name, FALSE))
return TRUE;
break;
case FILTER_RULE_PIXBUF_FORMATS:
{
GSList *list;
if (!filter_info->mime_type)
break;
for (list = rule->u.pixbuf_formats; list; list = list->next)
{
int i;
gchar **mime_types;
mime_types = gdk_pixbuf_format_get_mime_types (list->data);
for (i = 0; mime_types[i] != NULL; i++)
{
if (strcmp (mime_types[i], filter_info->mime_type) == 0)
{
g_strfreev (mime_types);
return TRUE;
}
}
g_strfreev (mime_types);
}
break;
}
case FILTER_RULE_CUSTOM:
if (rule->u.custom.func (filter_info, rule->u.custom.data))
return TRUE;
break;
}
}
return FALSE;
}
#define __GTK_FILE_FILTER_C__
#include "gtkaliasdef.c"