UI: Port view item features to base class, merge view item button types

No user visible changes expected.

Merges the tree row and grid tile button types, which were mostly doing
the same things. The idea is that there is a button type for
highlighting, as well as supporting general view item features (e.g.
renaming, drag/drop, etc.). So instead there is a view item button type
now. Also ports view item features like renaming, custom context menus,
drag controllers and drop controllers to `ui::AbstractViewItem` (the new
base class for all view items).

This should be quite an improvement because:
- Merges code that was duplicated over view items.
- Mentioned features (renaming, drag & drop, ...) are much easier to
  implement in new view types now. Most of it comes "for free".
- Further features will immediately become availalbe to all views (e.g.
  selection).
- Simplifies APIs, there don't have to be functions for individual view
  item types anymore.
- View item classes are split and thus less overwhelming visually.
- View item buttons now share all code (drawing, handling, etc.)
- We're soon running out of available button types, this commit merges
  two into one.

I was hoping I could do this in multiple smaller commits, but things
were quite intertwined so that would've taken quite some effort.

4 files changed, 242 insertions, 187 deletions

diff --git a/source/blender/editors/include/UI_abstract_view.hh b/source/blender/editors/include/UI_abstract_view.hh
index fdb7069e7c4..dfddace8899 100644
--- a/source/blender/editors/include/UI_abstract_view.hh
+++ b/source/blender/editors/include/UI_abstract_view.hh
@@ -3,11 +3,16 @@
 /** \file
  * \ingroup editorui
  *
- * Base for all views (UIs to display data sets), supporting common features.
+ * Base class for all views (UIs to display data sets) and view items, supporting common features.
  * https://wiki.blender.org/wiki/Source/Interface/Views
  *
  * One of the most important responsibilities of the base class is managing reconstruction,
- * enabling state that is persistent over reconstructions/redraws.
+ * enabling state that is persistent over reconstructions/redraws. Other features:
+ * - Renaming
+ * - Custom context menus
+ * - Notifier listening
+ * - Drag controllers (dragging view items)
+ * - Drop controllers (dropping onto/into view items)
  */
 
 #pragma once
@@ -18,15 +23,25 @@
 #include "DNA_defs.h"
 
 #include "BLI_span.hh"
+#include "BLI_string_ref.hh"
 
-struct wmNotifier;
+struct bContext;
 struct uiBlock;
+struct uiBut;
+struct uiLayout;
+struct uiViewItemHandle;
+struct wmDrag;
+struct wmNotifier;
 
 namespace blender::ui {
 
 class AbstractViewItem;
+class AbstractViewItemDropController;
+class AbstractViewItemDragController;
 
 class AbstractView {
+  friend class AbstractViewItem;
+
   bool is_reconstructed_ = false;
   /**
    * Only one item can be renamed at a time. So rather than giving each item an own rename buffer
@@ -43,6 +58,12 @@ class AbstractView {
   /** Listen to a notifier, returning true if a redraw is needed. */
   virtual bool listen(const wmNotifier &) const;
 
+  /**
+   * Makes \a item valid for display in this view. Behavior is undefined for items not registered
+   * with this.
+   */
+  void register_item(AbstractViewItem &item);
+
   /** Only one item can be renamed at a time. */
   bool is_renaming() const;
   /** \return If renaming was started successfully. */
@@ -63,7 +84,6 @@ class AbstractView {
    * After this, reconstruction is complete (see #is_reconstructed()).
    */
   void update_from_old(uiBlock &new_block);
-
   /**
    * Check if the view is fully (re-)constructed. That means, both the build function and
    * #update_from_old() have finished.
@@ -72,16 +92,86 @@ class AbstractView {
 };
 
 class AbstractViewItem {
+  friend class AbstractView;
+  friend class ViewItemAPIWrapper;
+
  protected:
+  /**
+   * The view this item is a part of, and was registered for using #AbstractView::register_item().
+   * If this wasn't done, the behavior of items is undefined.
+   */
+  AbstractView *view_ = nullptr;
   bool is_active_ = false;
+  bool is_renaming_ = false;
 
  public:
   virtual ~AbstractViewItem() = default;
 
+  virtual void build_context_menu(bContext &C, uiLayout &column) const;
+
+  /**
+   * Queries if the view item supports renaming in principle. Renaming may still fail, e.g. if
+   * another item is already being renamed.
+   */
+  virtual bool supports_renaming() const;
+  /**
+   * Try renaming the item, or the data it represents. Can assume
+   * #AbstractViewItem::supports_renaming() returned true. Sub-classes that override this should
+   * usually call this, unless they have a custom #AbstractViewItem.matches() implementation.
+   *
+   * \return True if the renaming was successful.
+   */
+  virtual bool rename(StringRefNull new_name);
+  /**
+   * Get the string that should be used for renaming, typically the item's label. This string will
+   * not be modified, but if the renaming is canceled, the value will be reset to this.
+   */
+  virtual StringRef get_rename_string() const;
+
+  /**
+   * If an item wants to support being dragged, it has to return a drag controller here.
+   * That is an object implementing #AbstractViewItemDragController.
+   */
+  virtual std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const;
+  /**
+   * If an item wants to support dropping data into it, it has to return a drop controller here.
+   * That is an object implementing #AbstractViewItemDropController.
+   *
+   * \note This drop controller may be requested for each event. The view doesn't keep a drop
+   *       controller around currently. So it can not contain persistent state.
+   */
+  virtual std::unique_ptr<AbstractViewItemDropController> create_drop_controller() const;
+
+  /** Get the view this item is registered for using #AbstractView::register_item(). */
+  AbstractView &get_view() const;
+
+  /**
+   * Requires the view to have completed reconstruction, see #is_reconstructed(). Otherwise we
+   * can't be sure about the item state.
+   */
+  bool is_active() const;
+
+  bool is_renaming() const;
+  void begin_renaming();
+  void end_renaming();
+  void rename_apply();
+
+  template<typename ToType = AbstractViewItem>
+  static ToType *from_item_handle(uiViewItemHandle *handle);
+
  protected:
   AbstractViewItem() = default;
 
   /**
+   * Compare this item's identity to \a other to check if they represent the same data.
+   * Implementations can assume that the types match already (caller must check).
+   *
+   * Used to recognize an item from a previous redraw, to be able to keep its state (e.g. active,
+   * renaming, etc.).
+   */
+  virtual bool matches(const AbstractViewItem &other) const = 0;
+
+  /**
    * Copy persistent state (e.g. active, selection, etc.) from a matching item of
    * the last redraw to this item. If sub-classes introduce more advanced state they should
    * override this and make it update their state accordingly.
@@ -90,7 +180,101 @@ class AbstractViewItem {
    */
   virtual void update_from_old(const AbstractViewItem &old);
 
-  void set_view(AbstractView &view);
+  /**
+   * Add a text button for renaming the item to \a block. This must be used for the built-in
+   * renaming to work. This button is meant to appear temporarily. It is removed when renaming is
+   * done.
+   */
+  void add_rename_button(uiBlock &block);
 };
 
+template<typename ToType> ToType *AbstractViewItem::from_item_handle(uiViewItemHandle *handle)
+{
+  static_assert(std::is_base_of<AbstractViewItem, ToType>::value,
+                "Type must derive from and implement the AbstractViewItem interface");
+
+  return dynamic_cast<ToType *>(reinterpret_cast<AbstractViewItem *>(handle));
+}
+
+/* ---------------------------------------------------------------------- */
+/** \name Drag 'n Drop
+ * \{ */
+
+/**
+ * Class to enable dragging a view item. An item can return a drop controller for itself by
+ * implementing #AbstractViewItem::create_drag_controller().
+ */
+class AbstractViewItemDragController {
+ protected:
+  AbstractView &view_;
+
+ public:
+  AbstractViewItemDragController(AbstractView &view);
+  virtual ~AbstractViewItemDragController() = default;
+
+  virtual int get_drag_type() const = 0;
+  virtual void *create_drag_data() const = 0;
+  virtual void on_drag_start();
+
+  /** Request the view the item is registered for as type #ViewType. Throws a `std::bad_cast`
+   * exception if the view is not of the requested type. */
+  template<class ViewType> inline ViewType &get_view() const;
+};
+
+/**
+ * Class to define the behavior when dropping something onto/into a view item, plus the behavior
+ * when dragging over this item. An item can return a drop controller for itself via a custom
+ * implementation of #AbstractViewItem::create_drop_controller().
+ */
+class AbstractViewItemDropController {
+ protected:
+  AbstractView &view_;
+
+ public:
+  AbstractViewItemDropController(AbstractView &view);
+  virtual ~AbstractViewItemDropController() = default;
+
+  /**
+   * Check if the data dragged with \a drag can be dropped on the item this controller is for.
+   * \param r_disabled_hint: Return a static string to display to the user, explaining why dropping
+   *                         isn't possible on this item. Shouldn't be done too aggressively, e.g.
+   *                         don't set this if the drag-type can't be dropped here; only if it can
+   *                         but there's another reason it can't be dropped.
+   *                         Can assume this is a non-null pointer.
+   */
+  virtual bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const = 0;
+  /**
+   * Custom text to display when dragging over a view item. Should explain what happens when
+   * dropping the data onto this item. Will only be used if #AbstractViewItem::can_drop()
+   * returns true, so the implementing override doesn't have to check that again.
+   * The returned value must be a translated string.
+   */
+  virtual std::string drop_tooltip(const wmDrag &drag) const = 0;
+  /**
+   * Execute the logic to apply a drop of the data dragged with \a drag onto/into the item this
+   * controller is for.
+   */
+  virtual bool on_drop(struct bContext *C, const wmDrag &drag) = 0;
+
+  /** Request the view the item is registered for as type #ViewType. Throws a `std::bad_cast`
+   * exception if the view is not of the requested type. */
+  template<class ViewType> inline ViewType &get_view() const;
+};
+
+template<class ViewType> ViewType &AbstractViewItemDragController::get_view() const
+{
+  static_assert(std::is_base_of<AbstractView, ViewType>::value,
+                "Type must derive from and implement the ui::AbstractView interface");
+  return dynamic_cast<ViewType &>(view_);
+}
+
+template<class ViewType> ViewType &AbstractViewItemDropController::get_view() const
+{
+  static_assert(std::is_base_of<AbstractView, ViewType>::value,
+                "Type must derive from and implement the ui::AbstractView interface");
+  return dynamic_cast<ViewType &>(view_);
+}
+
+/** \} */
+
 }  // namespace blender::ui
diff --git a/source/blender/editors/include/UI_grid_view.hh b/source/blender/editors/include/UI_grid_view.hh
index 74ce16ccd85..805198f38ef 100644
--- a/source/blender/editors/include/UI_grid_view.hh
+++ b/source/blender/editors/include/UI_grid_view.hh
@@ -19,7 +19,7 @@
 struct bContext;
 struct PreviewImage;
 struct uiBlock;
-struct uiButGridTile;
+struct uiButViewItem;
 struct uiLayout;
 struct View2D;
 struct wmNotifier;
@@ -41,32 +41,22 @@ class AbstractGridViewItem : public AbstractViewItem {
  protected:
   /** Reference to a string that uniquely identifies this item in the view. */
   StringRef identifier_{};
-  /** Every visible item gets a button of type #UI_BTYPE_GRID_TILE during the layout building. */
-  uiButGridTile *grid_tile_but_ = nullptr;
+  /** Every visible item gets a button of type #UI_BTYPE_VIEW_ITEM during the layout building. */
+  uiButViewItem *view_item_but_ = nullptr;
 
  public:
   virtual ~AbstractGridViewItem() = default;
 
   virtual void build_grid_tile(uiLayout &layout) const = 0;
 
-  /**
-   * Compare this item's identifier to \a other to check if they represent the same data.
-   * Used to recognize an item from a previous redraw, to be able to keep its state (e.g. active,
-   * renaming, etc.).
-   */
-  bool matches(const AbstractGridViewItem &other) const;
-
   const AbstractGridView &get_view() const;
 
-  /**
-   * Requires the tree to have completed reconstruction, see #is_reconstructed(). Otherwise we
-   * can't be sure about the item state.
-   */
-  bool is_active() const;
-
  protected:
   AbstractGridViewItem(StringRef identifier);
 
+  /** See AbstractViewItem::matches(). */
+  virtual bool matches(const AbstractViewItem &other) const override;
+
   /** Called when the item's state changes from inactive to active. */
   virtual void on_activate();
   /**
diff --git a/source/blender/editors/include/UI_interface.h b/source/blender/editors/include/UI_interface.h
index f39c62d8e2b..99a1d038cca 100644
--- a/source/blender/editors/include/UI_interface.h
+++ b/source/blender/editors/include/UI_interface.h
@@ -74,10 +74,8 @@ typedef struct uiLayout uiLayout;
 typedef struct uiPopupBlockHandle uiPopupBlockHandle;
 /* C handle for C++ #ui::AbstractView type. */
 typedef struct uiViewHandle uiViewHandle;
-/* C handle for C++ #ui::AbstractTreeViewItem type. */
-typedef struct uiTreeViewItemHandle uiTreeViewItemHandle;
-/* C handle for C++ #ui::AbstractGridViewItem type. */
-typedef struct uiGridViewItemHandle uiGridViewItemHandle;
+/* C handle for C++ #ui::AbstractViewItem type. */
+typedef struct uiViewItemHandle uiViewItemHandle;
 
 /* Defines */
 
@@ -391,10 +389,8 @@ typedef enum {
   /** Resize handle (resize uilist). */
   UI_BTYPE_GRIP = 57 << 9,
   UI_BTYPE_DECORATOR = 58 << 9,
-  /* An item in a tree view. Parent items may be collapsible. */
-  UI_BTYPE_TREEROW = 59 << 9,
-  /* An item in a grid view. */
-  UI_BTYPE_GRID_TILE = 60 << 9,
+  /* An item a view (see #ui::AbstractViewItem). */
+  UI_BTYPE_VIEW_ITEM = 59 << 9,
 } eButType;
 
 #define BUTTYPE (63 << 9)
@@ -1685,8 +1681,6 @@ int UI_search_items_find_index(uiSearchItems *items, const char *name);
  */
 void UI_but_hint_drawstr_set(uiBut *but, const char *string);
 
-void UI_but_treerow_indentation_set(uiBut *but, int indentation);
-
 void UI_but_node_link_set(uiBut *but, struct bNodeSocket *socket, const float draw_color[4]);
 
 void UI_but_number_step_size_set(uiBut *but, float step_size);
@@ -3201,45 +3195,44 @@ void UI_interface_tag_script_reload(void);
 void UI_block_views_listen(const uiBlock *block,
                            const struct wmRegionListenerParams *listener_params);
 
-bool UI_grid_view_item_is_active(const uiGridViewItemHandle *item_handle);
-bool UI_tree_view_item_is_active(const uiTreeViewItemHandle *item);
-bool UI_grid_view_item_matches(const uiGridViewItemHandle *a, const uiGridViewItemHandle *b);
-bool UI_tree_view_item_matches(const uiTreeViewItemHandle *a, const uiTreeViewItemHandle *b);
+bool UI_view_item_is_active(const uiViewItemHandle *item_handle);
+bool UI_view_item_matches(const uiViewItemHandle *a_handle, const uiViewItemHandle *b_handle);
 /**
- * Attempt to start dragging the tree-item \a item_. This will not work if the tree item doesn't
- * support dragging, i.e. it won't create a drag-controller upon request.
- * \return True if dragging started successfully, otherwise false.
+ * Can \a item_handle be renamed right now? Note that this isn't just a mere wrapper around
+ * #AbstractViewItem::supports_renaming(). This also checks if there is another item being renamed,
+ * and returns false if so.
  */
-bool UI_tree_view_item_drag_start(struct bContext *C, uiTreeViewItemHandle *item_);
-bool UI_tree_view_item_can_drop(const uiTreeViewItemHandle *item_,
-                                const struct wmDrag *drag,
-                                const char **r_disabled_hint);
-char *UI_tree_view_item_drop_tooltip(const uiTreeViewItemHandle *item, const struct wmDrag *drag);
+bool UI_view_item_can_rename(const uiViewItemHandle *item_handle);
+void UI_view_item_begin_rename(uiViewItemHandle *item_handle);
+
+void UI_view_item_context_menu_build(struct bContext *C,
+                                     const uiViewItemHandle *item_handle,
+                                     uiLayout *column);
+
 /**
- * Let a tree-view item handle a drop event.
- * \return True if the drop was handled by the tree-view item.
+ * Attempt to start dragging \a item_. This will not work if the view item doesn't
+ * support dragging, i.e. if it won't create a drag-controller upon request.
+ * \return True if dragging started successfully, otherwise false.
  */
-bool UI_tree_view_item_drop_handle(struct bContext *C,
-                                   const uiTreeViewItemHandle *item_,
-                                   const struct ListBase *drags);
+bool UI_view_item_drag_start(struct bContext *C, const uiViewItemHandle *item_);
+bool UI_view_item_can_drop(const uiViewItemHandle *item_,
+                           const struct wmDrag *drag,
+                           const char **r_disabled_hint);
+char *UI_view_item_drop_tooltip(const uiViewItemHandle *item, const struct wmDrag *drag);
 /**
- * Can \a item_handle be renamed right now? Not that this isn't just a mere wrapper around
- * #AbstractTreeViewItem::can_rename(). This also checks if there is another item being renamed,
- * and returns false if so.
+ * Let a view item handle a drop event.
+ * \return True if the drop was handled by the view item.
  */
-bool UI_tree_view_item_can_rename(const uiTreeViewItemHandle *item_handle);
-void UI_tree_view_item_begin_rename(uiTreeViewItemHandle *item_handle);
-
-void UI_tree_view_item_context_menu_build(struct bContext *C,
-                                          const uiTreeViewItemHandle *item,
-                                          uiLayout *column);
+bool UI_view_item_drop_handle(struct bContext *C,
+                              const uiViewItemHandle *item_,
+                              const struct ListBase *drags);
 
 /**
- * \param xy: Coordinate to find a tree-row item at, in window space.
+ * \param xy: Coordinate to find a view item at, in window space.
  */
-uiTreeViewItemHandle *UI_block_tree_view_find_item_at(const struct ARegion *region,
-                                                      const int xy[2]) ATTR_NONNULL(1, 2);
-uiTreeViewItemHandle *UI_block_tree_view_find_active_item(const struct ARegion *region);
+uiViewItemHandle *UI_block_view_find_item_at(const struct ARegion *region, const int xy[2])
+    ATTR_NONNULL();
+uiViewItemHandle *UI_block_view_find_active_item(const struct ARegion *region);
 
 #ifdef __cplusplus
 }
diff --git a/source/blender/editors/include/UI_tree_view.hh b/source/blender/editors/include/UI_tree_view.hh
index fa427d96dd8..872a6085060 100644
--- a/source/blender/editors/include/UI_tree_view.hh
+++ b/source/blender/editors/include/UI_tree_view.hh
@@ -9,7 +9,6 @@
 
 #pragma once
 
-#include <array>
 #include <functional>
 #include <memory>
 #include <string>
@@ -25,18 +24,13 @@
 struct bContext;
 struct uiBlock;
 struct uiBut;
-struct uiButTreeRow;
+struct uiButViewItem;
 struct uiLayout;
-struct wmDrag;
-struct wmEvent;
-struct wmNotifier;
 
 namespace blender::ui {
 
 class AbstractTreeView;
 class AbstractTreeViewItem;
-class AbstractTreeViewItemDropController;
-class AbstractTreeViewItemDragController;
 
 /* ---------------------------------------------------------------------- */
 /** \name Tree-View Item Container
@@ -161,19 +155,17 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
 
  private:
   bool is_open_ = false;
-  bool is_renaming_ = false;
 
  protected:
   /** This label is used as the default way to identifying an item within its parent. */
   std::string label_{};
-  /** Every visible item gets a button of type #UI_BTYPE_TREEROW during the layout building. */
-  uiButTreeRow *tree_row_but_ = nullptr;
+  /** Every visible item gets a button of type #UI_BTYPE_VIEW_ITEM during the layout building. */
+  uiButViewItem *view_item_but_ = nullptr;
 
  public:
   virtual ~AbstractTreeViewItem() = default;
 
   virtual void build_row(uiLayout &row) = 0;
-  virtual void build_context_menu(bContext &C, uiLayout &column) const;
 
   AbstractTreeView &get_tree_view() const;
 
@@ -185,11 +177,6 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
    * can't be sure about the item state.
    */
   bool is_collapsed() const;
-  /**
-   * Requires the tree to have completed reconstruction, see #is_reconstructed(). Otherwise we
-   * can't be sure about the item state.
-   */
-  bool is_active() const;
 
  protected:
   /**
@@ -202,25 +189,19 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
    */
   virtual std::optional<bool> should_be_active() const;
 
-  /**
-   * Queries if the tree-view item supports renaming in principle. Renaming may still fail, e.g. if
-   * another item is already being renamed.
-   */
-  virtual bool supports_renaming() const;
-  /**
-   * Try renaming the item, or the data it represents. Can assume
-   * #AbstractTreeViewItem::supports_renaming() returned true. Sub-classes that override this
-   * should usually call this, unless they have a custom #AbstractTreeViewItem.matches().
-   *
-   * \return True if the renaming was successful.
-   */
-  virtual bool rename(StringRefNull new_name);
+  /** See AbstractViewItem::get_rename_string(). */
+  virtual StringRef get_rename_string() const override;
+  /** See AbstractViewItem::rename(). */
+  virtual bool rename(StringRefNull new_name) override;
 
   /**
    * Return whether the item can be collapsed. Used to disable collapsing for items with children.
    */
   virtual bool supports_collapsing() const;
 
+  /** See #AbstractViewItem::matches(). */
+  virtual bool matches(const AbstractViewItem &other) const override;
+
   /** See #AbstractViewItem::update_from_old(). */
   virtual void update_from_old(const AbstractViewItem &old) override;
 
@@ -230,22 +211,11 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
    * open/closed, active, etc.). Items are only matched if their parents also match.
    * By default this just matches the item's label (if the parents match!). If that isn't
    * good enough for a sub-class, that can override it.
-   */
-  virtual bool matches(const AbstractTreeViewItem &other) const;
-
-  /**
-   * If an item wants to support being dragged, it has to return a drag controller here.
-   * That is an object implementing #AbstractTreeViewItemDragController.
-   */
-  virtual std::unique_ptr<AbstractTreeViewItemDragController> create_drag_controller() const;
-  /**
-   * If an item wants to support dropping data into it, it has to return a drop controller here.
-   * That is an object implementing #AbstractTreeViewItemDropController.
    *
-   * \note This drop controller may be requested for each event. The tree-view doesn't keep a drop
-   *       controller around currently. So it can not contain persistent state.
+   * TODO #matches_single() is a rather temporary name, used to indicate that this only compares
+   * the item itself, not the parents. Item matching is expected to change quite a bit anyway.
    */
-  virtual std::unique_ptr<AbstractTreeViewItemDropController> create_drop_controller() const;
+  virtual bool matches_single(const AbstractTreeViewItem &other) const;
 
   /**
    * Activates this item, deactivates other items, calls the #AbstractTreeViewItem::on_activate()
@@ -263,29 +233,24 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
    */
   bool is_hovered() const;
   bool is_collapsible() const;
-  bool is_renaming() const;
 
   void ensure_parents_uncollapsed();
 
-  uiButTreeRow *tree_row_button();
+  uiButViewItem *view_item_button();
 
  private:
-  static void rename_button_fn(bContext *, void *, char *);
-  static AbstractTreeViewItem *find_tree_item_from_rename_button(const uiBut &but);
   static void tree_row_click_fn(struct bContext *, void *, void *);
   static void collapse_chevron_click_fn(bContext *, void *but_arg1, void *);
   static bool is_collapse_chevron_but(const uiBut *but);
 
   /** See #AbstractTreeView::change_state_delayed() */
   void change_state_delayed();
-  void end_renaming();
 
   void add_treerow_button(uiBlock &block);
   void add_indent(uiLayout &row) const;
   void add_collapse_chevron(uiBlock &block) const;
   void add_rename_button(uiLayout &row);
 
-  bool matches_including_parents(const AbstractTreeViewItem &other) const;
   bool has_active_child() const;
   int count_parents() const;
 };
@@ -293,69 +258,6 @@ class AbstractTreeViewItem : public AbstractViewItem, public TreeViewItemContain
 /** \} */
 
 /* ---------------------------------------------------------------------- */
-/** \name Drag 'n Drop
- * \{ */
-
-/**
- * Class to enable dragging a tree-item. An item can return a drop controller for itself via a
- * custom implementation of #AbstractTreeViewItem::create_drag_controller().
- */
-class AbstractTreeViewItemDragController {
- protected:
-  AbstractTreeView &tree_view_;
-
- public:
-  AbstractTreeViewItemDragController(AbstractTreeView &tree_view);
-  virtual ~AbstractTreeViewItemDragController() = default;
-
-  virtual int get_drag_type() const = 0;
-  virtual void *create_drag_data() const = 0;
-  virtual void on_drag_start();
-
-  template<class TreeViewType> inline TreeViewType &tree_view() const;
-};
-
-/**
- * Class to customize the drop behavior of a tree-item, plus the behavior when dragging over this
- * item. An item can return a drop controller for itself via a custom implementation of
- * #AbstractTreeViewItem::create_drop_controller().
- */
-class AbstractTreeViewItemDropController {
- protected:
-  AbstractTreeView &tree_view_;
-
- public:
-  AbstractTreeViewItemDropController(AbstractTreeView &tree_view);
-  virtual ~AbstractTreeViewItemDropController() = default;
-
-  /**
-   * Check if the data dragged with \a drag can be dropped on the item this controller is for.
-   * \param r_disabled_hint: Return a static string to display to the user, explaining why dropping
-   *                         isn't possible on this item. Shouldn't be done too aggressively, e.g.
-   *                         don't set this if the drag-type can't be dropped here; only if it can
-   *                         but there's another reason it can't be dropped.
-   *                         Can assume this is a non-null pointer.
-   */
-  virtual bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const = 0;
-  /**
-   * Custom text to display when dragging over a tree item. Should explain what happens when
-   * dropping the data onto this item. Will only be used if #AbstractTreeViewItem::can_drop()
-   * returns true, so the implementing override doesn't have to check that again.
-   * The returned value must be a translated string.
-   */
-  virtual std::string drop_tooltip(const wmDrag &drag) const = 0;
-  /**
-   * Execute the logic to apply a drop of the data dragged with \a drag onto/into the item this
-   * controller is for.
-   */
-  virtual bool on_drop(struct bContext *C, const wmDrag &drag) = 0;
-
-  template<class TreeViewType> inline TreeViewType &tree_view() const;
-};
-
-/** \} */
-
-/* ---------------------------------------------------------------------- */
 /** \name Predefined Tree-View Item Types
  *
  *  Common, Basic Tree-View Item Types.
@@ -426,18 +328,4 @@ inline ItemT &TreeViewItemContainer::add_tree_item(Args &&...args)
       add_tree_item(std::make_unique<ItemT>(std::forward<Args>(args)...)));
 }
 
-template<class TreeViewType> TreeViewType &AbstractTreeViewItemDragController::tree_view() const
-{
-  static_assert(std::is_base_of<AbstractTreeView, TreeViewType>::value,
-                "Type must derive from and implement the AbstractTreeView interface");
-  return static_cast<TreeViewType &>(tree_view_);
-}
-
-template<class TreeViewType> TreeViewType &AbstractTreeViewItemDropController::tree_view() const
-{
-  static_assert(std::is_base_of<AbstractTreeView, TreeViewType>::value,
-                "Type must derive from and implement the AbstractTreeView interface");
-  return static_cast<TreeViewType &>(tree_view_);
-}
-
 }  // namespace blender::ui