Blender V5.3
filelist_filter.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2007 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
11
12#include "BLI_fnmatch.hh"
13#include "BLI_listbase.hh"
14#include "BLI_path_utils.hh"
15#include "BLI_string.hh"
16#include "BLI_string_search.hh"
17#include "BLI_string_utf8.hh"
18#include "BLI_uuid.hh"
19#include "BLI_vector.hh"
20
21#include "BKE_idtype.hh"
22
23#include "../file_intern.hh"
24#include "../filelist.hh"
25#include "filelist_intern.hh"
26
27namespace blender {
28
29/* True if should be hidden, based on current filtering. */
30static bool is_filtered_hidden(const char *filename,
32 const FileListInternEntry *file)
33{
34 if ((filename[0] == '.') && (filename[1] == '\0')) {
35 return true; /* Ignore. */
36 }
37
38 if (filter->flags & FLF_HIDE_PARENT) {
39 if (filename[0] == '.' && filename[1] == '.' && filename[2] == '\0') {
40 return true; /* Ignore. */
41 }
42 }
43
44 /* Check for _OUR_ "hidden" attribute. This not only mirrors OS-level hidden file
45 * attribute but is also set for Linux/Mac "dot" files. See `filelist_readjob_list_dir`.
46 */
47 if ((filter->flags & FLF_HIDE_DOT) && (file->attributes & FILE_ATTR_HIDDEN)) {
48 return true;
49 }
50
51 /* For data-blocks (but not the group directories), check the asset-only filter. */
52 if (!(file->typeflag & FILE_TYPE_DIR) && (file->typeflag & FILE_TYPE_BLENDERLIB) &&
53 (filter->flags & FLF_ASSETS_ONLY) && !(file->typeflag & FILE_TYPE_ASSET))
54 {
55 return true;
56 }
57
58 return false;
59}
60
66{
67 if (filter->filter_search[0] == '\0') {
68 return true;
69 }
70
71 /* If there's a filter string, apply it as filter even if FLF_DO_FILTER is not set. */
72 return fnmatch(filter->filter_search, file->relpath, FNM_CASEFOLD) == 0;
73}
74
80{
81 if (filter->filter_search[0] == '\0') {
82 return true;
83 }
84
85 /* If there's a filter string, apply it as filter even if FLF_DO_FILTER is not set. */
86 return fnmatch(filter->filter_search, file->name, FNM_CASEFOLD) == 0;
87}
88
91{
92 if (is_filtered_hidden(file->relpath, filter, file)) {
93 return false;
94 }
95
96 if (FILENAME_IS_CURRPAR(file->relpath)) {
97 return false;
98 }
99
100 /* We only check for types if some type are enabled in filtering. */
101 if (filter->filter && (filter->flags & FLF_DO_FILTER)) {
102 if (file->typeflag & FILE_TYPE_DIR) {
105 return false;
106 }
107 }
108 else {
109 if (!(filter->filter & FILE_TYPE_FOLDER)) {
110 return false;
111 }
112 }
113 }
114 else {
115 if (!(file->typeflag & filter->filter)) {
116 return false;
117 }
118 }
119 }
120 return true;
121}
122
123bool is_filtered_file(FileListInternEntry *file, const char * /*root*/, FileListFilter *filter)
124{
125 return is_filtered_file_type(file, filter) &&
127}
128
130 const short id_code,
131 const char *name,
132 const FileListFilter *filter)
133{
134 if (!is_filtered_file_type(file, filter)) {
135 return false;
136 }
137
138 /* We only check for types if some type are enabled in filtering. */
139 if ((filter->filter || filter->filter_id) && (filter->flags & FLF_DO_FILTER)) {
140 if (id_code) {
141 if (!name && (filter->flags & FLF_HIDE_LIB_DIR)) {
142 return false;
143 }
144
145 const uint64_t filter_id = BKE_idtype_idcode_to_idfilter(id_code);
146 if (!(filter_id & filter->filter_id)) {
147 return false;
148 }
149 }
150 }
151
152 return true;
153}
154
160{
161 if (asset_system::AssetRepresentation *asset = file->get_asset()) {
162 return &asset->get_metadata();
163 }
164 return nullptr;
165}
166
168{
169 /* Not used yet for the asset view template. */
170 if (!filter->asset_catalog_filter) {
171 return;
172 }
174 "prepare_filter_asset_library() should only be called when the file browser is "
175 "in asset browser mode");
176
177 file_ensure_updated_catalog_filter_data(filter->asset_catalog_filter, filelist->asset_library);
178}
179
181{
183 const AssetMetaData &asset_data = asset->get_metadata();
184
185 /* Not used yet for the asset view template. */
186 if (filter->asset_catalog_filter &&
187 !file_is_asset_visible_in_catalog_filter_settings(filter->asset_catalog_filter, &asset_data))
188 {
189 return false;
190 }
191
192 const bool is_online = asset->is_online_only();
193 if (((filter->flags & FLF_ASSETS_HIDE_ONLINE) != 0) && is_online) {
194 return false;
195 }
196 if (((filter->flags & FLF_ASSETS_HIDE_OFFLINE) != 0) && !is_online) {
197 return false;
198 }
200 return false;
201 }
202
203 /* The actual string search is handled for the whole list at once, to allow sorting of the
204 * results. */
205 return true;
206}
207
209 const char * /*root*/,
211{
212 if (file->typeflag & FILE_TYPE_BLENDERLIB) {
213 return is_filtered_id_file_type(file, file->blentype, file->name, filter);
214 }
215 return is_filtered_file_type(file, filter);
216}
217
219{
220 return is_filtered_lib_type(file, root, filter) && is_filtered_file_relpath(file, filter);
221}
222
224 const char * /*dir*/,
226{
227 /* "Filtered" means *not* being filtered out... So return true if the file should be visible. */
228 return is_filtered_id_file_type(file, file->blentype, file->name, filter) &&
230}
231
233{
235 return is_filtered_main_assets(file, root, filter);
236 }
237
238 return is_filtered_lib_type(file, root, filter) && is_filtered_asset(file, filter);
239}
240
242{
243 filelist->flags |= FL_NEED_FILTERING;
244}
245
247{
248 return (filelist->flags & FL_NEED_FILTERING);
249}
250
252 FileListInternEntry **entries_to_filter,
253 int entries_num)
254{
255 const FileListFilter &filter = filelist->filter_data;
256 if (filter.filter_search[0] == '\0') {
257 /* No search text, just copy over the pre-filtered list. */
258 if (filelist->filelist_intern.filtered) {
259 MEM_delete(filelist->filelist_intern.filtered);
260 }
262 sizeof(*filelist->filelist_intern.filtered) * size_t(entries_num), __func__));
263 memcpy(filelist->filelist_intern.filtered,
264 entries_to_filter,
265 sizeof(*filelist->filelist_intern.filtered) * size_t(entries_num));
266 filelist->filelist.entries_filtered_num = entries_num;
267 return;
268 }
269
270 /* `filter->filter_search` contains "*the search text*". */
271 char filter_search_buf[sizeof(FileListFilter::filter_search)];
272 const size_t string_length = STRNCPY_RLEN(filter_search_buf, filter.filter_search);
273
274 /* When doing a name comparison, get rid of the leading/trailing asterisks. */
275 filter_search_buf[string_length - 1] = '\0';
276 const char *search_str = filter_search_buf + 1;
277
280
281 for (int i = 0; i < entries_num; i++) {
282 FileListInternEntry *file = entries_to_filter[i];
284 if (asset_data) {
285 std::string searchable_string = file->name;
286 for (const AssetTag &asset_tag : asset_data->tags) {
287 searchable_string += " ";
288 searchable_string += asset_tag.name;
289 }
290 search.add(searchable_string, file);
291 }
292 else {
293 search.add(file->name, file);
294 }
295 }
296
297 const Vector<FileListInternEntry *> results = search.query(search_str);
298
299 if (filelist->filelist_intern.filtered) {
300 MEM_delete(filelist->filelist_intern.filtered);
301 }
302
303 const int num_filtered = results.size();
305 sizeof(*filelist->filelist_intern.filtered) * size_t(num_filtered), __func__));
306 for (int i = 0; i < num_filtered; i++) {
307 filelist->filelist_intern.filtered[i] = results[i];
308 }
309 filelist->filelist.entries_filtered_num = num_filtered;
310}
311
313{
314 int num_filtered = 0;
315 const int num_files = filelist->filelist.entries_num;
316 FileListInternEntry **filtered_tmp;
317
319 return;
320 }
321
322 if (!(filelist->flags & FL_NEED_FILTERING)) {
323 /* Assume it has already been filtered, nothing else to do! */
324 return;
325 }
326
327 if (filelist->flags & FL_NEED_RESET_GLOB) {
328 filelist_reset_glob(filelist);
329 }
330
332 if (filelist->max_recursion) {
333 /* Never show lib ID 'categories' directories when we are in 'flat' mode, unless
334 * root path is a blend file. */
335 char dir[FILE_MAX_LIBEXTRA];
336 if (!filelist_islibrary(filelist, dir, nullptr)) {
338 }
339 }
340
341 if (filelist->prepare_filter_fn) {
342 filelist->prepare_filter_fn(filelist, &filelist->filter_data);
343 }
344
345 filtered_tmp = MEM_new_array_uninitialized<FileListInternEntry *>(num_files, __func__);
346
347 /* Filter remap & count how many files are left after filter in a single loop. */
348 for (FileListInternEntry &file : filelist->filelist_intern.entries) {
349 if (filelist->filter_fn(&file, filelist->filelist.root, &filelist->filter_data)) {
350 filtered_tmp[num_filtered++] = &file;
351 }
352 }
353
354 if (filelist->tags & FILELIST_TAGS_APPLY_FUZZY_SEARCH) {
355 filelist_filter_and_sort_assets(filelist, filtered_tmp, num_filtered);
356 }
357 else {
358 if (filelist->filelist_intern.filtered) {
359 MEM_delete(filelist->filelist_intern.filtered);
360 }
362 num_filtered, __func__);
363 memcpy(filelist->filelist_intern.filtered,
364 filtered_tmp,
365 sizeof(*filelist->filelist_intern.filtered) * size_t(num_filtered));
366 filelist->filelist.entries_filtered_num = num_filtered;
367 }
368
369 // printf("Filtered: %d over %d entries\n", num_filtered, filelist->filelist.entries_num);
370
372 filelist->flags &= ~FL_NEED_FILTERING;
373
374 MEM_delete(filtered_tmp);
375}
376
378 const bool do_filter,
379 const bool hide_dot,
380 const bool hide_parent,
381 const uint64_t filter,
382 const uint64_t filter_id,
383 const bool filter_assets_only,
384 const bool filter_assets_hide_online,
385 const bool filter_assets_hide_offline,
386 const char *filter_search)
387{
388 bool update = false;
389
390 if (((filelist->filter_data.flags & FLF_DO_FILTER) != 0) != (do_filter != 0)) {
391 filelist->filter_data.flags ^= FLF_DO_FILTER;
392 update = true;
393 }
394 if (((filelist->filter_data.flags & FLF_HIDE_DOT) != 0) != (hide_dot != 0)) {
395 filelist->filter_data.flags ^= FLF_HIDE_DOT;
396 update = true;
397 }
398 if (((filelist->filter_data.flags & FLF_HIDE_PARENT) != 0) != (hide_parent != 0)) {
399 filelist->filter_data.flags ^= FLF_HIDE_PARENT;
400 update = true;
401 }
402 if (((filelist->filter_data.flags & FLF_ASSETS_ONLY) != 0) != (filter_assets_only != 0)) {
403 filelist->filter_data.flags ^= FLF_ASSETS_ONLY;
404 update = true;
405 }
406 if (((filelist->filter_data.flags & FLF_ASSETS_HIDE_ONLINE) != 0) !=
407 (filter_assets_hide_online != 0))
408 {
410 update = true;
411 }
412 if (((filelist->filter_data.flags & FLF_ASSETS_HIDE_OFFLINE) != 0) !=
413 (filter_assets_hide_offline != 0))
414 {
416 update = true;
417 }
418 if (filelist->filter_data.filter != filter) {
419 filelist->filter_data.filter = filter;
420 update = true;
421 }
422 const uint64_t new_filter_id = (filter & FILE_TYPE_BLENDERLIB) ? filter_id : FILTER_ID_ALL;
423 if (filelist->filter_data.filter_id != new_filter_id) {
424 filelist->filter_data.filter_id = new_filter_id;
425 update = true;
426 }
427 if (BLI_strcmp_ignore_pad(filelist->filter_data.filter_search, filter_search, '*') != 0) {
429 filter_search,
430 '*',
431 sizeof(filelist->filter_data.filter_search));
432 update = true;
433 }
434
435 if (update) {
436 /* And now, free filtered data so that we know we have to filter again. */
438 }
439}
440
441} // namespace blender
Main runtime representation of an asset.
#define FILENAME_IS_CURRPAR(_n)
#define STRNCPY_RLEN(dst, src)
#define FILTER_ID_ALL
Definition DNA_ID.h:1241
#define FILE_MAX_LIBEXTRA
#define ELEM(...)
#define BLI_assert_msg(a, msg)
int64_t size() const
void add(const StringRef str, T *user_data, const int weight=0)
Vector< T * > query(const StringRef query) const
#define FILEDIR_NBR_ENTRIES_UNSET
bool skip_experimental_asset_catalog(const UUID &catalog_id)
std::string filename(const std::string_view &str, size_t pos)
BMesh Iterators.
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
uint64_t BKE_idtype_idcode_to_idfilter(short idcode)
Definition idtype.cc:473
unsigned __int64 uint64_t
Definition BKE_text.h:91
void filelist_tag_needs_filtering(FileList *filelist)
bool filelist_intern_entry_is_main_file(const FileListInternEntry *intern_entry)
Definition filelist.cc:452
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
@ FLF_ASSETS_HIDE_OFFLINE
void filelist_reset_glob(FileList *filelist)
Definition filelist.cc:1176
bool is_filtered_asset_library(FileListInternEntry *file, const char *root, FileListFilter *filter)
static void filelist_filter_and_sort_assets(FileList *filelist, FileListInternEntry **entries_to_filter, int entries_num)
void prepare_filter_asset_library(const FileList *filelist, FileListFilter *filter)
static bool is_filtered_hidden(const char *filename, const FileListFilter *filter, const FileListInternEntry *file)
char char * BLI_strncpy_ensure_pad(char *__restrict dst, const char *__restrict src, char pad, size_t dst_maxncpy) ATTR_NONNULL(1
void filelist_setfilter_options(FileList *filelist, bool do_filter, bool hide_dot, bool hide_parent, uint64_t filter, uint64_t filter_id, bool filter_assets_only, bool filter_assets_hide_online, bool filter_assets_hide_offline, const char *filter_search)
void filelist_cache_clear(FileListEntryCache *cache, size_t new_size)
Definition filelist.cc:846
bool is_filtered_main_assets(FileListInternEntry *file, const char *, FileListFilter *filter)
@ FILE_ATTR_HIDDEN
static bool is_filtered_file_relpath(const FileListInternEntry *file, const FileListFilter *filter)
static bool is_filtered_lib_type(FileListInternEntry *file, const char *, FileListFilter *filter)
bool filelist_islibrary(FileList *filelist, char *dir, char **r_group)
Definition filelist.cc:2120
static bool is_filtered_file_type(const FileListInternEntry *file, const FileListFilter *filter)
@ FILELIST_TAGS_APPLY_FUZZY_SEARCH
bool is_filtered_asset(FileListInternEntry *file, FileListFilter *filter)
static bool is_filtered_id_file_type(const FileListInternEntry *file, const short id_code, const char *name, const FileListFilter *filter)
void filelist_filter(FileList *filelist)
bool is_filtered_file(FileListInternEntry *file, const char *, FileListFilter *filter)
@ FILE_TYPE_BLENDER_BACKUP
static bool is_filtered_file_name(const FileListInternEntry *file, const FileListFilter *filter)
static AssetMetaData * filelist_file_internal_get_asset_data(const FileListInternEntry *file)
int char char int int int int BLI_strcmp_ignore_pad(const char *str1, const char *str2, char pad) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
bool is_filtered_lib(FileListInternEntry *file, const char *root, FileListFilter *filter)
bool filelist_needs_filtering(FileList *filelist)
The meta-data of an asset. By creating and giving this for a data-block (ID.asset_data),...
ListBaseT< AssetTag > tags
User defined tag. Currently only used by assets, could be used more often at some point....
asset_system::AssetRepresentation * get_asset() const
ListBaseT< FileListInternEntry > entries
FileListInternEntry ** filtered
void(*) prepare_filter_fn(const FileList *filelist, FileListFilter *filter)
FileListEntryCache * filelist_cache
FileDirEntryArr filelist
FileListFilter filter_data
bool(*) filter_fn(FileListInternEntry *file, const char *root, FileListFilter *filter)
FileListIntern filelist_intern
asset_system::AssetLibrary * asset_library