tree_display.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include <cstdint>
#include <memory>
 
struct ID;
struct LayerCollection;
struct Library;
struct ListBase;
struct Main;
struct Scene;
struct Strip;
struct SpaceOutliner;
struct ViewLayer;
struct WorkSpace;
 
namespace blender::ed::outliner {
 
struct TreeElement;
class TreeElementID;

struct TreeSourceData {
  Main *bmain;
  WorkSpace *workspace;
  Scene *scene;
  ViewLayer *view_layer;
 
  TreeSourceData(Main &bmain, WorkSpace &workspace, Scene &scene, ViewLayer &view_layer)
      : bmain(&bmain), workspace(&workspace), scene(&scene), view_layer(&view_layer)
  {
  }
};
 
/* -------------------------------------------------------------------- */
/* Tree-Display Interface */

class AbstractTreeDisplay {
 public:
  AbstractTreeDisplay(SpaceOutliner &space_outliner) : space_outliner_(space_outliner) {}
  virtual ~AbstractTreeDisplay() = default;
 
  static std::unique_ptr<AbstractTreeDisplay> create_from_display_mode(
      int /*eSpaceOutliner_Mode*/ mode, SpaceOutliner &space_outliner);

  static TreeElement *add_element(SpaceOutliner *space_outliner,
                                  ListBase *lb,
                                  ID *owner_id,
                                  void *create_data,
                                  TreeElement *parent,
                                  short type,
                                  short index,
                                  const bool expand = true);

  virtual ListBase build_tree(const TreeSourceData &source_data) = 0;

  virtual bool supports_mode_column() const;

  virtual bool is_lazy_built() const;

  TreeElement *add_element(ListBase *lb,
                           ID *owner_id,
                           void *create_data,
                           TreeElement *parent,
                           short type,
                           short index,
                           const bool expand = true);
 
 protected:
  SpaceOutliner &space_outliner_;
};
 
/* -------------------------------------------------------------------- */
/* View Layer Tree-Display */

class TreeDisplayViewLayer final : public AbstractTreeDisplay {
  Scene *scene_ = nullptr;
  ViewLayer *view_layer_ = nullptr;
  bool show_objects_ = true;
 
 public:
  TreeDisplayViewLayer(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
  bool supports_mode_column() const override;
 
 private:
  void add_view_layer(Scene &, ListBase &, TreeElement *);
  void add_layer_collections_recursive(ListBase &, ListBase &, TreeElement &);
  void add_layer_collection_objects(ListBase &, LayerCollection &, TreeElement &);
  void add_layer_collection_objects_children(TreeElement &);
};
 
/* -------------------------------------------------------------------- */
/* Library Tree-Display */

class TreeDisplayLibraries final : public AbstractTreeDisplay {
 public:
  TreeDisplayLibraries(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
 private:
  TreeElement *add_library_contents(Main &, ListBase &, Library *);
  bool library_id_filter_poll(const Library *lib, ID *id) const;
  short id_filter_get() const;
};
 
/* -------------------------------------------------------------------- */
/* Library Overrides Tree-Display. */

class TreeDisplayOverrideLibraryProperties final : public AbstractTreeDisplay {
 public:
  TreeDisplayOverrideLibraryProperties(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
 private:
  ListBase add_library_contents(Main &);
  short id_filter_get() const;
};

class TreeDisplayOverrideLibraryHierarchies final : public AbstractTreeDisplay {
 public:
  TreeDisplayOverrideLibraryHierarchies(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
  bool is_lazy_built() const override;
 
 private:
  ListBase build_hierarchy_for_lib_or_main(Main *bmain,
                                           TreeElement &parent_te,
                                           Library *lib = nullptr);
};
 
/* -------------------------------------------------------------------- */
/* Video Sequencer Tree-Display */
 
enum class StripAddOp : int8_t { Noop = 0, Add, None };

class TreeDisplaySequencer final : public AbstractTreeDisplay {
 public:
  TreeDisplaySequencer(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
 private:
  TreeElement *add_sequencer_contents() const;
  StripAddOp need_add_strip_dup(Strip *strip) const;
  void add_strip_dup(Strip *strip, TreeElement *te, short index);
};
 
/* -------------------------------------------------------------------- */
/* Orphaned Data Tree-Display */

class TreeDisplayIDOrphans final : public AbstractTreeDisplay {
 public:
  TreeDisplayIDOrphans(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
 private:
  bool datablock_has_orphans(ListBase &) const;
};
 
/* -------------------------------------------------------------------- */
/* Scenes Tree-Display */

class TreeDisplayScenes final : public AbstractTreeDisplay {
 public:
  TreeDisplayScenes(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
  bool supports_mode_column() const override;
};
 
/* -------------------------------------------------------------------- */
/* Data API Tree-Display */

class TreeDisplayDataAPI final : public AbstractTreeDisplay {
 public:
  TreeDisplayDataAPI(SpaceOutliner &space_outliner);
 
  ListBase build_tree(const TreeSourceData &source_data) override;
 
  bool is_lazy_built() const override;
};
 
}  // namespace blender::ed::outliner