source/blender/editors/include/UI_abstract_view.hh

@@ -19,16 +19,21 @@
 
 #include <array>
 #include <memory>
+#include <optional>
 
 #include "DNA_defs.h"
+#include "DNA_vec_types.h"
 
 #include "BLI_span.hh"
 #include "BLI_string_ref.hh"
 
+#include "UI_interface.hh"
+
 struct bContext;
 struct uiBlock;
 struct uiLayout;
 struct uiViewItemHandle;
+struct ViewLink;
 struct wmDrag;
 struct wmNotifier;
 
@@ -38,8 +43,13 @@ class AbstractViewItem;
 class AbstractViewItemDropController;
 class AbstractViewItemDragController;
 
+/** The view drop controller can share logic with the view item drop controller for now, so just an
+ * alias. */
+using AbstractViewDropController = AbstractViewItemDropController;
+
 class AbstractView {
   friend class AbstractViewItem;
+  friend struct ::ViewLink;
 
   bool is_reconstructed_ = false;
   /**
@@ -51,9 +61,21 @@ class AbstractView {
    */
   std::unique_ptr<std::array<char, MAX_NAME>> rename_buffer_;
 
+  /* See #get_bounds(). */
+  std::optional<rcti> bounds_;
+
  public:
   virtual ~AbstractView() = default;
 
+  /**
+   * If a view wants to support dropping data into it, it has to return a drop controller here.
+   * That is an object implementing #AbstractViewDropController.
+   *
+   * \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<AbstractViewDropController> create_drop_controller() const;
+
   /** Listen to a notifier, returning true if a redraw is needed. */
   virtual bool listen(const wmNotifier &) const;
 
@@ -70,6 +92,11 @@ class AbstractView {
   void end_renaming();
   Span<char> get_rename_buffer() const;
   MutableSpan<char> get_rename_buffer();
+  /**
+   * Get the rectangle containing all the view items that are in the layout, in button space.
+   * Updated as part of #UI_block_end(), before that it's unset.
+   */
+  std::optional<rcti> get_bounds() const;
 
  protected:
   AbstractView() = default;
@@ -225,35 +252,12 @@ class AbstractViewItemDragController {
  * 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 {
+class AbstractViewItemDropController : public DropControllerInterface {
  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. */

source/blender/editors/include/UI_interface.h

@@ -3274,18 +3274,12 @@ void UI_view_item_context_menu_build(struct bContext *C,
  * \return True if dragging started successfully, otherwise false.
  */
 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);
-/**
- * Let a view item handle a drop event.
- * \return True if the drop was handled by the view item.
- */
-bool UI_view_item_drop_handle(struct bContext *C,
-                              const uiViewItemHandle *item_,
-                              const struct ListBase *drags);
 
+/**
+ * \param xy: Coordinate to find a view item at, in window space.
+ * \param pad: Extra padding added to the bounding box of the view.
+ */
+uiViewHandle *UI_region_view_find_at(const struct ARegion *region, const int xy[2], int pad);
 /**
  * \param xy: Coordinate to find a view item at, in window space.
  */

source/blender/editors/include/UI_interface.hh

@@ -18,11 +18,17 @@ namespace blender::nodes::geo_eval_log {
 struct GeometryAttributeInfo;
 }
 
+struct ARegion;
+struct bContext;
 struct PointerRNA;
 struct StructRNA;
 struct uiBlock;
+struct uiLayout;
 struct uiList;
 struct uiSearchItems;
+struct uiViewHandle;
+struct uiViewItemHandle;
+struct wmDrag;
 
 namespace blender::ui {
 
@@ -54,6 +60,39 @@ void attribute_search_add_items(StringRefNull str,
                                 uiSearchItems *items,
                                 bool is_first);
 
+/**
+ * Interface class to implement dropping for various kinds of UI elements. This isn't used widely,
+ * only UI views and view items use it. Would probably be nice to have more general support for
+ * dropping this way.
+ */
+class DropControllerInterface {
+ public:
+  DropControllerInterface() = default;
+  virtual ~DropControllerInterface() = default;
+
+  /**
+   * Check if the data dragged with \a drag can be dropped on the element 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 UI element. 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 the element using this drop controller. Should
+   * explain what happens when dropping the data onto this UI element. Will only be used if
+   * #DropControllerInterface::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 UI element
+   * this controller is for.
+   */
+  virtual bool on_drop(bContext *C, const wmDrag &drag) const = 0;
+};
+
 }  // namespace blender::ui
 
 enum eUIListFilterResult {
@@ -110,6 +149,33 @@ void UI_list_filter_and_sort_items(uiList *ui_list,
                                    const char *propname,
                                    uiListItemGetNameFn get_name_fn = nullptr);
 
+std::unique_ptr<blender::ui::DropControllerInterface> UI_view_drop_controller(
+    const uiViewHandle *view_handle);
+std::unique_ptr<blender::ui::DropControllerInterface> UI_view_item_drop_controller(
+    const uiViewItemHandle *item_handle);
+
+/**
+ * Let a drop controller handle a drop event.
+ * \return True if the dropping was successful.
+ */
+bool UI_drop_controller_apply_drop(bContext &C,
+                                   const blender::ui::DropControllerInterface &drop_controller,
+                                   const ListBase &drags);
+/**
+ * Call #DropControllerInterface::drop_tooltip() and return the result as newly allocated C string
+ * (unless the result is empty, returns null then). Needs freeing with MEM_freeN().
+ */
+char *UI_drop_controller_drop_tooltip(const blender::ui::DropControllerInterface &drop_controller,
+                                      const wmDrag &drag);
+
+/**
+ * Try to find a view item with a drop controller under the mouse cursor, or if not found, a view
+ * with a drop controller.
+ * \param xy: Coordinate to find a drop controller at, in window space.
+ */
+std::unique_ptr<blender::ui::DropControllerInterface> UI_region_views_find_drop_controller_at(
+    const ARegion *region, const int xy[2]);
+
 /**
  * Override this for all available view types.
  */

source/blender/editors/interface/CMakeLists.txt

@@ -46,6 +46,7 @@ set(SRC
   interface_context_path.cc
   interface_drag.cc
   interface_draw.cc
+  interface_drop.cc
   interface_dropboxes.cc
   interface_handlers.cc
   interface_icons.cc

source/blender/editors/interface/interface.cc

@@ -2014,6 +2014,8 @@ void UI_block_end_ex(const bContext *C, uiBlock *block, const int xy[2], int r_x
       break;
   }
 
+  ui_block_views_bounds_calc(block);
+
   if (block->rect.xmin == 0.0f && block->rect.xmax == 0.0f) {
     UI_block_bounds_set_normal(block, 0);
   }

source/blender/editors/interface/interface_drop.cc

@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup edinterface
+ */
+
+#include "UI_interface.hh"
+
+using namespace blender::ui;
+
+bool UI_drop_controller_apply_drop(bContext &C,
+                                   const DropControllerInterface &drop_controller,
+                                   const ListBase &drags)
+{
+
+  const char *disabled_hint_dummy = nullptr;
+  LISTBASE_FOREACH (const wmDrag *, drag, &drags) {
+    if (drop_controller.can_drop(*drag, &disabled_hint_dummy)) {
+      return drop_controller.on_drop(&C, *drag);
+    }
+  }
+
+  return false;
+}
+
+char *UI_drop_controller_drop_tooltip(const DropControllerInterface &drop_controller,
+                                      const wmDrag &drag)
+{
+  const std::string tooltip = drop_controller.drop_tooltip(drag);
+  return tooltip.empty() ? nullptr : BLI_strdup(tooltip.c_str());
+}

source/blender/editors/interface/interface_dropboxes.cc

@@ -20,6 +20,9 @@
 #include "WM_api.h"
 
 #include "UI_interface.h"
+#include "UI_interface.hh"
+
+using namespace blender::ui;
 
 /* -------------------------------------------------------------------- */
 /** \name View Drag/Drop Callbacks
@@ -28,28 +31,28 @@
 static bool ui_view_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event)
 {
   const ARegion *region = CTX_wm_region(C);
-  const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, event->xy);
-  if (!hovered_item) {
+
+  std::unique_ptr<DropControllerInterface> drop_controller =
+      UI_region_views_find_drop_controller_at(region, event->xy);
+  if (!drop_controller) {
     return false;
   }
 
   if (drag->drop_state.free_disabled_info) {
     MEM_SAFE_FREE(drag->drop_state.disabled_info);
   }
-
   drag->drop_state.free_disabled_info = false;
-  return UI_view_item_can_drop(hovered_item, drag, &drag->drop_state.disabled_info);
+
+  return drop_controller->can_drop(*drag, &drag->drop_state.disabled_info);
 }
 
 static char *ui_view_drop_tooltip(bContext *C, wmDrag *drag, const int xy[2], wmDropBox * /*drop*/)
 {
   const ARegion *region = CTX_wm_region(C);
-  const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, xy);
-  if (!hovered_item) {
-    return nullptr;
-  }
+  std::unique_ptr<DropControllerInterface> drop_controller =
+      UI_region_views_find_drop_controller_at(region, xy);
 
-  return UI_view_item_drop_tooltip(hovered_item, drag);
+  return UI_drop_controller_drop_tooltip(*drop_controller, *drag);
 }
 
 /** \} */

source/blender/editors/interface/interface_intern.hh

@@ -1452,6 +1452,7 @@ void ui_interface_tag_script_reload_queries();
 /* interface_view.cc */
 
 void ui_block_free_views(uiBlock *block);
+void ui_block_views_bounds_calc(const uiBlock *block);
 void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *listener_params);
 uiViewHandle *ui_block_view_find_matching_in_old_block(const uiBlock *new_block,
                                                        const uiViewHandle *new_view);

source/blender/editors/interface/interface_ops.cc

@@ -47,6 +47,7 @@
 #include "RNA_types.h"
 
 #include "UI_interface.h"
+#include "UI_interface.hh"
 
 #include "interface_intern.hh"
 
@@ -65,6 +66,8 @@
 #include "ED_screen.h"
 #include "ED_text.h"
 
+using namespace blender::ui;
+
 /* -------------------------------------------------------------------- */
 /** \name Immediate redraw helper
  *
@@ -2351,7 +2354,7 @@ static void UI_OT_list_start_filter(wmOperatorType *ot)
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name UI Tree-View Drop Operator
+/** \name UI View Drop Operator
  * \{ */
 
 static bool ui_view_drop_poll(bContext *C)
@@ -2361,9 +2364,7 @@ static bool ui_view_drop_poll(bContext *C)
   if (region == nullptr) {
     return false;
   }
-  const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, win->eventstate->xy);
-
-  return hovered_item != nullptr;
+  return UI_region_views_find_drop_controller_at(region, win->eventstate->xy) != nullptr;
 }
 
 static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *event)
@@ -2373,10 +2374,11 @@ static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *
   }
 
   const ARegion *region = CTX_wm_region(C);
-  uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, event->xy);
+  std::unique_ptr<DropControllerInterface> drop_controller =
+      UI_region_views_find_drop_controller_at(region, event->xy);
 
-  if (!UI_view_item_drop_handle(
-          C, hovered_item, static_cast<const ListBase *>(event->customdata))) {
+  if (!UI_drop_controller_apply_drop(
+          *C, *drop_controller, *static_cast<const ListBase *>(event->customdata))) {
     return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
   }
 
@@ -2385,9 +2387,9 @@ static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *
 
 static void UI_OT_view_drop(wmOperatorType *ot)
 {
-  ot->name = "View drop";
+  ot->name = "View Drop";
   ot->idname = "UI_OT_view_drop";
-  ot->description = "Drag and drop items onto a data-set item";
+  ot->description = "Drag and drop onto a data-set or item within the data-set";
 
   ot->invoke = ui_view_drop_invoke;
   ot->poll = ui_view_drop_poll;

source/blender/editors/interface/views/abstract_view.cc

@@ -62,6 +62,12 @@ void AbstractView::update_from_old(uiBlock &new_block)
 /** \name Default implementations of virtual functions
  * \{ */
 
+std::unique_ptr<AbstractViewDropController> AbstractView::create_drop_controller() const
+{
+  /* There's no drop controller (and hence no drop support) by default. */
+  return nullptr;
+}
+
 bool AbstractView::listen(const wmNotifier & /*notifier*/) const
 {
   /* Nothing by default. */
@@ -104,6 +110,25 @@ MutableSpan<char> AbstractView::get_rename_buffer()
   return *rename_buffer_;
 }
 
+std::optional<rcti> AbstractView::get_bounds() const
+{
+  return bounds_;
+}
+
 /** \} */
 
 }  // namespace blender::ui
+
+/* ---------------------------------------------------------------------- */
+/** \name C-API
+ * \{ */
+
+using namespace blender::ui;
+
+std::unique_ptr<DropControllerInterface> UI_view_drop_controller(const uiViewHandle *view_handle)
+{
+  const AbstractView &view = reinterpret_cast<const AbstractView &>(*view_handle);
+  return view.create_drop_controller();
+}
+
+/** \} */

source/blender/editors/interface/views/abstract_view_item.cc

@@ -264,45 +264,6 @@ class ViewItemAPIWrapper {
 
     return true;
   }
-
-  static bool can_drop(const AbstractViewItem &item,
-                       const wmDrag &drag,
-                       const char **r_disabled_hint)
-  {
-    const std::unique_ptr<AbstractViewItemDropController> drop_controller =
-        item.create_drop_controller();
-    if (!drop_controller) {
-      return false;
-    }
-
-    return drop_controller->can_drop(drag, r_disabled_hint);
-  }
-
-  static std::string drop_tooltip(const AbstractViewItem &item, const wmDrag &drag)
-  {
-    const std::unique_ptr<AbstractViewItemDropController> drop_controller =
-        item.create_drop_controller();
-    if (!drop_controller) {
-      return {};
-    }
-
-    return drop_controller->drop_tooltip(drag);
-  }
-
-  static bool drop_handle(bContext &C, const AbstractViewItem &item, const ListBase &drags)
-  {
-    std::unique_ptr<AbstractViewItemDropController> drop_controller =
-        item.create_drop_controller();
-
-    const char *disabled_hint_dummy = nullptr;
-    LISTBASE_FOREACH (const wmDrag *, drag, &drags) {
-      if (drop_controller->can_drop(*drag, &disabled_hint_dummy)) {
-        return drop_controller->on_drop(&C, *drag);
-      }
-    }
-
-    return false;
-  }
 };
 
 }  // namespace blender::ui
@@ -348,26 +309,11 @@ bool UI_view_item_drag_start(bContext *C, const uiViewItemHandle *item_)
   return ViewItemAPIWrapper::drag_start(*C, item);
 }
 
-bool UI_view_item_can_drop(const uiViewItemHandle *item_,
-                           const wmDrag *drag,
-                           const char **r_disabled_hint)
+std::unique_ptr<DropControllerInterface> UI_view_item_drop_controller(
+    const uiViewItemHandle *item_handle)
 {
-  const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
-  return ViewItemAPIWrapper::can_drop(item, *drag, r_disabled_hint);
-}
-
-char *UI_view_item_drop_tooltip(const uiViewItemHandle *item_, const wmDrag *drag)
-{
-  const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
-
-  const std::string tooltip = ViewItemAPIWrapper::drop_tooltip(item, *drag);
-  return tooltip.empty() ? nullptr : BLI_strdup(tooltip.c_str());
-}
-
-bool UI_view_item_drop_handle(bContext *C, const uiViewItemHandle *item_, const ListBase *drags)
-{
-  const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
-  return ViewItemAPIWrapper::drop_handle(*C, item, *drags);
+  const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_handle);
+  return item.create_drop_controller();
 }
 
 /** \} */

source/blender/editors/interface/views/interface_view.cc

@@ -24,6 +24,7 @@
 #include "BKE_screen.h"
 
 #include "BLI_listbase.h"
+#include "BLI_map.hh"
 
 #include "ED_screen.h"
 
@@ -44,6 +45,8 @@ using namespace blender::ui;
 struct ViewLink : public Link {
   std::string idname;
   std::unique_ptr<AbstractView> view;
+
+  static void views_bounds_calc(const uiBlock &block);
 };
 
 template<class T>
@@ -81,6 +84,51 @@ void ui_block_free_views(uiBlock *block)
   }
 }
 
+void ViewLink::views_bounds_calc(const uiBlock &block)
+{
+  Map<AbstractView *, rcti> views_bounds;
+
+  rcti minmax;
+  BLI_rcti_init_minmax(&minmax);
+  LISTBASE_FOREACH (ViewLink *, link, &block.views) {
+    views_bounds.add(link->view.get(), minmax);
+  }
+
+  LISTBASE_FOREACH (uiBut *, but, &block.buttons) {
+    if (but->type != UI_BTYPE_VIEW_ITEM) {
+      continue;
+    }
+    uiButViewItem *view_item_but = static_cast<uiButViewItem *>(but);
+    if (!view_item_but->view_item) {
+      continue;
+    }
+
+    /* Get the view from the button. */
+    AbstractViewItem &view_item = reinterpret_cast<AbstractViewItem &>(*view_item_but->view_item);
+    AbstractView &view = view_item.get_view();
+
+    rcti &bounds = views_bounds.lookup(&view);
+    rcti but_rcti{};
+    BLI_rcti_rctf_copy_round(&but_rcti, &view_item_but->rect);
+    BLI_rcti_do_minmax_rcti(&bounds, &but_rcti);
+  }
+
+  for (const auto item : views_bounds.items()) {
+    const rcti &bounds = item.value;
+    if (BLI_rcti_is_empty(&bounds)) {
+      continue;
+    }
+
+    AbstractView &view = *item.key;
+    view.bounds_ = bounds;
+  }
+}
+
+void ui_block_views_bounds_calc(const uiBlock *block)
+{
+  ViewLink::views_bounds_calc(*block);
+}
+
 void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *listener_params)
 {
   ARegion *region = listener_params->region;
@@ -92,6 +140,35 @@ void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *l
   }
 }
 
+/* Similar to #ui_but_find_mouse_over_ex(). */
+uiViewHandle *UI_region_view_find_at(const ARegion *region, const int xy[2], const int pad)
+{
+  if (!ui_region_contains_point_px(region, xy)) {
+    return nullptr;
+  }
+  LISTBASE_FOREACH (uiBlock *, block, &region->uiblocks) {
+    float mx = xy[0], my = xy[1];
+    ui_window_to_block_fl(region, block, &mx, &my);
+
+    LISTBASE_FOREACH (ViewLink *, view_link, &block->views) {
+      std::optional<rcti> bounds = view_link->view->get_bounds();
+      if (!bounds) {
+        continue;
+      }
+
+      rcti padded_bounds = *bounds;
+      if (pad) {
+        BLI_rcti_pad(&padded_bounds, pad, pad);
+      }
+      if (BLI_rcti_isect_pt(&padded_bounds, mx, my)) {
+        return reinterpret_cast<uiViewHandle *>(view_link->view.get());
+      }
+    }
+  }
+
+  return nullptr;
+}
+
 uiViewItemHandle *UI_region_views_find_item_at(const ARegion *region, const int xy[2])
 {
   uiButViewItem *item_but = (uiButViewItem *)ui_view_item_find_mouse_over(region, xy);
@@ -112,6 +189,32 @@ uiViewItemHandle *UI_region_views_find_active_item(const ARegion *region)
   return item_but->view_item;
 }
 
+std::unique_ptr<DropControllerInterface> UI_region_views_find_drop_controller_at(
+    const ARegion *region, const int xy[2])
+{
+  const uiViewItemHandle *hovered_view_item = UI_region_views_find_item_at(region, xy);
+  if (hovered_view_item) {
+    std::unique_ptr<DropControllerInterface> drop_controller = UI_view_item_drop_controller(
+        hovered_view_item);
+    if (drop_controller) {
+      return drop_controller;
+    }
+  }
+
+  /* Get style for some sensible padding around the view items. */
+  const uiStyle *style = UI_style_get_dpi();
+  const uiViewHandle *hovered_view = UI_region_view_find_at(region, xy, style->buttonspacex);
+  if (hovered_view) {
+    std::unique_ptr<DropControllerInterface> drop_controller = UI_view_drop_controller(
+        hovered_view);
+    if (drop_controller) {
+      return drop_controller;
+    }
+  }
+
+  return nullptr;
+}
+
 static StringRef ui_block_view_find_idname(const uiBlock &block, const AbstractView &view)
 {
   /* First get the idname the of the view we're looking for. */

source/blender/editors/space_file/asset_catalog_tree_view.cc

@@ -113,7 +113,7 @@ class AssetCatalogDropController : public ui::AbstractViewItemDropController {
 
   bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const override;
   std::string drop_tooltip(const wmDrag &drag) const override;
-  bool on_drop(struct bContext *C, const wmDrag &drag) override;
+  bool on_drop(struct bContext *C, const wmDrag &drag) const override;
 
   ::AssetLibrary &get_asset_library() const;
 
@@ -151,7 +151,7 @@ class AssetCatalogTreeViewAllItem : public ui::BasicTreeViewItem {
 
     bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const override;
     std::string drop_tooltip(const wmDrag &drag) const override;
-    bool on_drop(struct bContext *C, const wmDrag &drag) override;
+    bool on_drop(struct bContext *C, const wmDrag &drag) const override;
   };
 
   std::unique_ptr<ui::AbstractViewItemDropController> create_drop_controller() const override;
@@ -165,7 +165,7 @@ class AssetCatalogTreeViewUnassignedItem : public ui::BasicTreeViewItem {
 
     bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const override;
     std::string drop_tooltip(const wmDrag &drag) const override;
-    bool on_drop(struct bContext *C, const wmDrag &drag) override;
+    bool on_drop(struct bContext *C, const wmDrag &drag) const override;
   };
 
   std::unique_ptr<ui::AbstractViewItemDropController> create_drop_controller() const override;
@@ -429,7 +429,7 @@ std::string AssetCatalogDropController::drop_tooltip_asset_list(const wmDrag &dr
   return basic_tip;
 }
 
-bool AssetCatalogDropController::on_drop(struct bContext *C, const wmDrag &drag)
+bool AssetCatalogDropController::on_drop(struct bContext *C, const wmDrag &drag) const
 {
   if (drag.type == WM_DRAG_ASSET_CATALOG) {
     return drop_asset_catalog_into_catalog(
@@ -623,7 +623,7 @@ std::string AssetCatalogTreeViewAllItem::DropController::drop_tooltip(const wmDr
 }
 
 bool AssetCatalogTreeViewAllItem::DropController::on_drop(struct bContext * /*C*/,
-                                                          const wmDrag &drag)
+                                                          const wmDrag &drag) const
 {
   BLI_assert(drag.type == WM_DRAG_ASSET_CATALOG);
   return AssetCatalogDropController::drop_asset_catalog_into_catalog(
@@ -667,7 +667,7 @@ std::string AssetCatalogTreeViewUnassignedItem::DropController::drop_tooltip(
 }
 
 bool AssetCatalogTreeViewUnassignedItem::DropController::on_drop(struct bContext *C,
-                                                                 const wmDrag &drag)
+                                                                 const wmDrag &drag) const
 {
   /* Assign to nil catalog ID. */
   return AssetCatalogDropController::drop_assets_into_catalog(