filelist_intern.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2007 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <cstdint>
#include <memory>
 
#include "BLI_fileops.h"
 
#include "DNA_listBase.h"
#include "DNA_space_enums.h"
#include "DNA_space_types.h"
 
#define FILEDIR_NBR_ENTRIES_UNSET -1
 
using FileUID = uint32_t;
 
struct AssetLibraryReference;
struct BlendHandle;
struct FileDirEntry;
struct FileIndexerType;
struct GHash;
struct ID;
struct PreviewImage;
struct ThreadQueue;
struct TaskPool;
 
namespace blender {
namespace asset_system {
class AssetLibrary;
class AssetRepresentation;
}  // namespace asset_system
namespace ed::asset_browser {
class AssetCatalogFilterSettings;
}
}  // namespace blender
 
/* ------------------FILELIST------------------------ */
 
struct FileListInternEntry {
  FileListInternEntry *next = nullptr, *prev = nullptr;
 
  FileUID uid = 0;
 
  eFileSel_File_Types typeflag = eFileSel_File_Types(0);
  int blentype = 0;
 
  char *relpath = nullptr;
  char *redirection_path = nullptr;
  const char *name = nullptr;
  bool free_name = false;

  struct {
    ID *id = nullptr;
 
    /* For the few file types that have the preview already in memory. For others, there's delayed
     * preview reading from disk. Non-owning pointer. */
    PreviewImage *preview_image = nullptr;
  } local_data;

  std::weak_ptr<blender::asset_system::AssetRepresentation> asset;
 
  /* See #FILE_ENTRY_BLENDERLIB_NO_PREVIEW. */
  bool blenderlib_has_no_preview = false;

  eFileAttributes attributes = eFileAttributes(0);
  BLI_stat_t st = {0};

  blender::asset_system::AssetRepresentation *get_asset() const
  {
    if (std::shared_ptr<blender::asset_system::AssetRepresentation> asset_ptr = asset.lock()) {
      /* Returning a raw pointer from a shared pointer and destructing the shared pointer
       * immediately afterwards isn't entirely clean. But it's just a way to get the raw pointer
       * from the weak pointer. Nothing should free the asset in the asset library meanwhile, so
       * this should be fine really. */
      BLI_assert(asset_ptr.use_count() > 1);
      return asset_ptr.get();
    }
    return nullptr;
  }
};
 
struct FileListIntern {
  ListBase entries;
  FileListInternEntry **filtered;
 
  FileUID curr_uid; /* Used to generate UID during internal listing. */
};
 
#define FILELIST_ENTRYCACHESIZE_DEFAULT 1024 /* Keep it a power of two! */
struct FileListEntryCache {
  size_t size = 0; /* The size of the cache... */
 
  int flags = 0;
 
  /* This one gathers all entries from both block and misc caches. Used for easy bulk-freeing. */
  ListBase cached_entries = {};
 
  /* Block cache: all entries between start and end index.
   * used for part of the list on display. */
  FileDirEntry **block_entries = nullptr;
  int block_start_index = 0;
  int block_end_index = 0;
  int block_center_index = 0;
  int block_cursor = 0;
 
  /* Misc cache: random indices, FIFO behavior.
   * NOTE: Not 100% sure we actually need that, time will say. */
  int misc_cursor = 0;
  int *misc_entries_indices = nullptr;
  GHash *misc_entries = nullptr;
 
  /* Allows to quickly get a cached entry from its UID. */
  GHash *uids = nullptr;
 
  /* Previews handling. */
  TaskPool *previews_pool = nullptr;
  ThreadQueue *previews_done = nullptr;
  int previews_todo_count = 0;
 
  FileListEntryCache();
  ~FileListEntryCache();
};

enum {
  FLC_PREVIEWS_ACTIVE = 1 << 0,
};
 
struct FileListEntryPreview {
  char filepath[FILE_MAX_LIBEXTRA];
  uint flags;
  int index;
  int icon_id;
};
 
/* Dummy wrapper around FileListEntryPreview to ensure we do not access freed memory when freeing
 * tasks' data (see #74609). */
struct FileListEntryPreviewTaskData {
  FileListEntryPreview *preview;
};
 
struct FileListFilter {
  uint64_t filter;
  uint64_t filter_id;
  char filter_glob[FILE_MAXFILE];
  char filter_search[66]; /* + 2 for heading/trailing implicit '*' wildcards. */
  short flags;
 
  blender::ed::asset_browser::AssetCatalogFilterSettings *asset_catalog_filter;
};

enum {
  FLF_DO_FILTER = 1 << 0,
  FLF_HIDE_DOT = 1 << 1,
  FLF_HIDE_PARENT = 1 << 2,
  FLF_HIDE_LIB_DIR = 1 << 3,
  FLF_ASSETS_ONLY = 1 << 4,
};
 
struct FileListReadJob;
struct FileList {
  FileDirEntryArr filelist;
 
  eFileSelectType type;
  /* The library this list was created for. Stored here so we know when to re-read. */
  AssetLibraryReference *asset_library_ref;
  blender::asset_system::AssetLibrary *asset_library; /* Non-owning. */
 
  short flags;
 
  short sort;
 
  FileListFilter filter_data;

  const FileIndexerType *indexer;
 
  FileListIntern filelist_intern;
 
  FileListEntryCache *filelist_cache;

  GHash *selection_state;
 
  short max_recursion;
  short recursion_level;
 
  BlendHandle *libfiledata;

  bool (*check_dir_fn)(const FileList *filelist,
                       char dirpath[FILE_MAX_LIBEXTRA],
                       const bool do_change);

  void (*read_job_fn)(FileListReadJob *job_params, bool *stop, bool *do_update, float *progress);

  bool (*filter_fn)(FileListInternEntry *file, const char *root, FileListFilter *filter);
  void (*prepare_filter_fn)(const FileList *filelist, FileListFilter *filter);

  short tags;
};

enum {
  FL_FORCE_RESET = 1 << 0,
  /* Don't do a full reset (unless #FL_FORCE_RESET is also set), only reset files representing main
   * data (assets from the current file/#Main). */
  FL_FORCE_RESET_MAIN_FILES = 1 << 1,
  FL_IS_READY = 1 << 2,
  FL_IS_PENDING = 1 << 3,
  FL_NEED_SORTING = 1 << 4,
  FL_NEED_FILTERING = 1 << 5,
  FL_SORT_INVERT = 1 << 6,
  FL_RELOAD_ASSET_LIBRARY = 1 << 7,
};

enum FileListTags {
  FILELIST_TAGS_USES_MAIN_DATA = (1 << 0),
  FILELIST_TAGS_NO_THREADS = (1 << 2),
};
 
enum class SpecialFileImages {
  Document,
  Folder,
  Parent,
  /* Keep this last. */
  _Max,
};
 
void filelist_cache_clear(FileListEntryCache *cache, size_t new_size);
 
bool filelist_intern_entry_is_main_file(const FileListInternEntry *intern_entry);
 
void prepare_filter_asset_library(const FileList *filelist, FileListFilter *filter);

bool is_filtered_file(FileListInternEntry *file, const char * /*root*/, FileListFilter *filter);
bool is_filtered_asset(FileListInternEntry *file, FileListFilter *filter);
bool is_filtered_lib(FileListInternEntry *file, const char *root, FileListFilter *filter);
bool is_filtered_main(FileListInternEntry *file, const char * /*dir*/, FileListFilter *filter);
bool is_filtered_main_assets(FileListInternEntry *file,
                             const char * /*dir*/,
                             FileListFilter *filter);
bool is_filtered_asset_library(FileListInternEntry *file,
                               const char *root,
                               FileListFilter *filter);