UI_abstract_view.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include <array>
#include <memory>
#include <optional>
#include <string>
 
#include "DNA_defs.h"
#include "DNA_vec_types.h"
 
#include "BLI_span.hh"
#include "BLI_string_ref.hh"
 
#include "UI_interface.hh"
 
#include "WM_types.hh"
 
struct bContext;
struct uiBlock;
struct uiButViewItem;
struct uiLayout;
struct ViewLink;
struct wmNotifier;
 
namespace blender::ui {
 
class AbstractViewItem;
class AbstractViewItemDragController;
 
enum class ViewScrollDirection {
  UP,
  DOWN,
};
 
class AbstractView {
  friend class AbstractViewItem;
  friend struct ::ViewLink;
 
  bool is_reconstructed_ = false;
  std::unique_ptr<std::array<char, MAX_NAME>> rename_buffer_;
  /* Search/filter string from the previous redraw, stored to detect changes. */
  std::string prev_filter_string_;
 
  bool needs_filtering_ = true;
 
  /* See #get_bounds(). */
  std::optional<rcti> bounds_;
 
  std::string context_menu_title;
  bool popup_keep_open_ = false;
 
 public:
  virtual ~AbstractView() = default;
  virtual std::unique_ptr<DropTargetInterface> create_drop_target();

  virtual bool listen(const wmNotifier &) const;

  virtual bool begin_filtering(const bContext &C) const;
 
  virtual void draw_overlays(const ARegion &region, const uiBlock &block) const;
 
  virtual void foreach_view_item(FunctionRef<void(AbstractViewItem &)> iter_fn) const = 0;
 
  virtual bool supports_scrolling() const;

  virtual bool is_fully_visible() const;
 
  virtual void scroll(ViewScrollDirection direction);

  virtual std::optional<uiViewState> persistent_state() const;
  virtual void persistent_state_apply(const uiViewState &state);

  void register_item(AbstractViewItem &item);

  bool is_renaming() const;
  bool begin_renaming();
  void end_renaming();
  Span<char> get_rename_buffer() const;
  MutableSpan<char> get_rename_buffer();
  std::optional<rcti> get_bounds() const;
 
  std::string get_context_menu_title() const;
  void set_context_menu_title(const std::string &title);
 
  bool get_popup_keep_open() const;
  void set_popup_keep_open();
 
  void clear_search_highlight();
 
 protected:
  AbstractView() = default;

  virtual void change_state_delayed();
 
  virtual void update_children_from_old(const AbstractView &old_view) = 0;

  void update_from_old(uiBlock &new_block);
  bool is_reconstructed() const;
 
  void filter(std::optional<StringRef> filter_str);
  const AbstractViewItem *search_highlight_item() const;
};
 
class AbstractViewItem {
  friend class AbstractView;
  friend class ViewItemAPIWrapper;
 
 protected:
  AbstractView *view_ = nullptr;
  uiButViewItem *view_item_but_ = nullptr;
  bool is_activatable_ = true;
  bool is_interactive_ = true;
  bool is_active_ = false;
  bool is_renaming_ = false;
  bool is_highlighted_search_ = false;

  bool is_filtered_visible_ = true;

  bool is_always_collapsible_ = false;
 
 public:
  virtual ~AbstractViewItem() = default;
 
  virtual void build_context_menu(bContext &C, uiLayout &column) const;

  virtual void on_activate(bContext &C);
  virtual std::optional<bool> should_be_active() const;

  virtual bool supports_renaming() const;
  virtual bool rename(const bContext &C, StringRefNull new_name);
  virtual StringRef get_rename_string() const;

  virtual std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const;
  virtual std::unique_ptr<DropTargetInterface> create_item_drop_target();

  virtual std::optional<std::string> debug_name() const;
 
  bool is_filtered_visible() const;

  AbstractView &get_view() const;

  uiButViewItem *view_item_button() const;

  void disable_interaction();
  bool is_interactive() const;
 
  void disable_activatable();
  void activate(bContext &C);
  void deactivate();
  bool is_active() const;
  bool is_search_highlight() const;
 
  bool is_renaming() const;
  void begin_renaming();
  void end_renaming();
  void rename_apply(const bContext &C);
 
 protected:
  AbstractViewItem() = default;

  virtual bool matches(const AbstractViewItem &other) const = 0;

  virtual void update_from_old(const AbstractViewItem &old);

  virtual bool set_state_active();

  virtual void change_state_delayed();

  virtual bool should_be_filtered_visible(StringRefNull filter_string) const;

  void add_rename_button(uiBlock &block);
};
 
/* ---------------------------------------------------------------------- */

class AbstractViewItemDragController {
 protected:
  AbstractView &view_;
 
 public:
  AbstractViewItemDragController(AbstractView &view);
  virtual ~AbstractViewItemDragController() = default;
 
  virtual eWM_DragDataType get_drag_type() const = 0;
  virtual void *create_drag_data() const = 0;
  virtual void on_drag_start();

  template<class ViewType> inline ViewType &get_view() const;
};
 
template<class ViewType> ViewType &AbstractViewItemDragController::get_view() const
{
  static_assert(std::is_base_of_v<AbstractView, ViewType>,
                "Type must derive from and implement the ui::AbstractView interface");
  return dynamic_cast<ViewType &>(view_);
}

 
}  // namespace blender::ui