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; }