static gboolean checkMimeTypeForFilter(GtkFileFilter* filter, const gchar* mimeType)
{
GtkFileFilterInfo filter_info;
filter_info.contains = GTK_FILE_FILTER_MIME_TYPE;
filter_info.mime_type = mimeType;
return gtk_file_filter_filter(filter, &filter_info);
}
static void filter_dir(fpick_dd *dt, const char *pattern)
{
#if GTK2VERSION >= 4 /* GTK+ 2.4+ */
GtkFileFilter *filt = gtk_file_filter_new();
GtkFileFilterInfo info;
gtk_file_filter_add_pattern(filt, pattern);
info.contains = GTK_FILE_FILTER_DISPLAY_NAME;
#endif
int *cols = dt->fcols, *map = dt->fmap;
int i, cnt = dt->cnt;
char *s;
for (i = 0; i < cnt; i++ , cols += COL_MAX)
{
s = RELREF(cols[COL_NAME]);
/* Filter files, let directories pass */
if (pattern[0] && (s[0] == 'F'))
{
#if GTK2VERSION >= 4 /* GTK+ 2.4+ */
info.display_name = s + 1;
if (!gtk_file_filter_filter(filt, &info)) continue;
#else
if (!fpick_fnmatch(pattern, s + 1)) continue;
#endif
}
*map++ = i;
}
dt->cntx = map - dt->fmap;
#if GTK2VERSION >= 4 /* GTK+ 2.4+ */
gtk_object_sink(GTK_OBJECT(filt));
#endif
}
gboolean
rejilla_mime_filter_filter (RejillaMimeFilter * filter, const char *filename,
const char *uri, const char *display_name, const char *mime_type)
{
GtkTreeModel *model;
GtkFileFilterInfo info;
GtkFileFilter *item;
GtkTreeIter row;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (filter->combo));
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (filter->combo), &row) == FALSE)
return TRUE;
gtk_tree_model_get (model, &row,
REJILLA_MIME_FILTER_FILTER_COL, &item,
-1);
info.contains = gtk_file_filter_get_needed (item);
if (info.contains & GTK_FILE_FILTER_FILENAME)
info.filename = (gchar *) filename;
if (info.contains & GTK_FILE_FILTER_URI)
info.uri = (gchar *) uri;
if (info.contains & GTK_FILE_FILTER_DISPLAY_NAME)
info.display_name = (gchar *) display_name;
if (info.contains & GTK_FILE_FILTER_MIME_TYPE)
info.mime_type = (gchar *) mime_type;
return gtk_file_filter_filter (item, &info);
}
/**
* gnm_app_history_get_list:
*
* creating it if necessary.
*
* Return value: (element-type char) (transfer full): the list, which must be
* freed along with the strings in it.
**/
GSList *
gnm_app_history_get_list (int max_elements)
{
GSList *res = NULL;
GList *items, *l;
GtkFileFilter *filter;
int n_elements = 0;
if (app->recent == NULL)
return NULL;
items = gtk_recent_manager_get_items (app->recent);
items = g_list_sort (items, (GCompareFunc)compare_mru);
filter = gnm_app_create_opener_filter (NULL);
for (l = items; l && n_elements < max_elements; l = l->next) {
GtkRecentInfo *ri = l->data;
const char *uri = gtk_recent_info_get_uri (ri);
gboolean want_it;
if (gtk_recent_info_has_application (ri, g_get_application_name ())) {
want_it = TRUE;
} else {
GtkFileFilterInfo fi;
char *display_name = g_filename_display_basename (uri);
memset (&fi, 0, sizeof (fi));
fi.contains = (GTK_FILE_FILTER_MIME_TYPE |
GTK_FILE_FILTER_URI |
GTK_FILE_FILTER_DISPLAY_NAME);
fi.uri = uri;
fi.mime_type = gtk_recent_info_get_mime_type (ri);
fi.display_name = display_name;
want_it = gtk_file_filter_filter (filter, &fi);
g_free (display_name);
}
if (want_it) {
char *filename = go_filename_from_uri (uri);
if (filename && !g_file_test (filename, G_FILE_TEST_EXISTS))
want_it = FALSE;
g_free (filename);
}
if (want_it) {
res = g_slist_prepend (res, g_strdup (uri));
n_elements++;
}
}
g_list_free_full (items, (GDestroyNotify)gtk_recent_info_unref);
g_object_ref_sink (filter);
g_object_unref (filter);
return g_slist_reverse (res);
}
/*#
@method filter GtkFileFilter
@brief Tests whether a file should be displayed according to filter.
@param filter_info a GtkFileFilterInfo structure containing information about a file.
@return TRUE if the file should be displayed
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.
*/
FALCON_FUNC FileFilter::filter( VMARG )
{
Item* i_info = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_info || !i_info->isObject() || !IS_DERIVED( i_info, GtkFileFilterInfo ) )
throw_inv_params( "GtkFilefilterInfo" );
#endif
vm->retval( (bool) gtk_file_filter_filter( GET_FILEFILTER( vm->self() ),
GET_FILEFILTERINFO( *i_info ) ) );
}
static VALUE
ffil_filter(VALUE self, VALUE contains, VALUE filename, VALUE uri, VALUE display_name, VALUE mime_type)
{
GtkFileFilterInfo info;
info.contains = RVAL2GFLAGS(contains, GTK_TYPE_FILE_FILTER_FLAGS);
info.filename = RVAL2CSTR(filename);
info.uri = RVAL2CSTR(uri);
info.display_name = RVAL2CSTR(display_name);
info.mime_type = RVAL2CSTR(mime_type);
return CBOOL2RVAL(gtk_file_filter_filter(_SELF(self), &info));
}
gboolean gtk_filename_filter(const char *filename, GtkFileFilter * filter)
{
gboolean ret = FALSE;
GtkFileFilterInfo info;
info.contains = GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_DISPLAY_NAME;
gchar *lower_name = g_ascii_strdown(filename, -1);
info.filename = info.display_name = lower_name;
if (gtk_file_filter_filter(filter, &info)) {
ret = TRUE;
}
g_free(lower_name);
return ret;
}
int
clip_GTK_FILEFILTERFILTER(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
ClipVar *cv = _clip_spar(cm, 2);
GtkFileFilterInfo info;
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, MAP_t);
_map_to_file_filter_info(cm, cv, &info);
_clip_retl(cm, gtk_file_filter_filter(GTK_FILE_FILTER(cfilter->object), &info));
return 0;
err:
return 1;
}
/**
* parole_pl_parser_can_parse_data:
* @data: data.
* @len: length of data.
*
* Get if the Parole parser can parse from the passed data.
*
* Returns: TRUE if it can parse from the data, FALSE otherwise.
*
* Since: 0.2
*/
gboolean parole_pl_parser_can_parse_data (const guchar *data, gint len)
{
gchar *mime_type = NULL;
gboolean result_uncertain;
gboolean result = FALSE;
mime_type = g_content_type_guess (NULL, data, len, &result_uncertain);
if ( mime_type && result_uncertain == FALSE )
{
GtkFileFilter *filter = g_object_ref_sink (parole_get_supported_playlist_filter ());
GtkFileFilterInfo filter_info;
g_debug ("Mime_type=%s", mime_type);
filter_info.mime_type = mime_type;
filter_info.contains = GTK_FILE_FILTER_MIME_TYPE;
result = gtk_file_filter_filter (filter, &filter_info);
g_object_unref (filter);
g_free (mime_type);
}
return result;
}
