24#include "RNA_prototypes.hh"
42using node_interface::bNodeTreeInterfaceItemReference;
44class NodePanelViewItem;
45class NodeSocketViewItem;
46class NodeTreeInterfaceView;
48class NodeTreeInterfaceDragController :
public AbstractViewItemDragController {
53 explicit NodeTreeInterfaceDragController(NodeTreeInterfaceView &view, bNodeTree &tree);
54 ~NodeTreeInterfaceDragController()
override =
default;
56 std::optional<eWM_DragDataType> get_drag_type()
const override;
58 void *create_drag_data()
const override;
61class NodeSocketDropTarget :
public TreeViewItemDropTarget {
63 bNodeTreeInterfaceSocket &socket_;
66 explicit NodeSocketDropTarget(NodeSocketViewItem &item, bNodeTreeInterfaceSocket &socket);
68 bool can_drop(
const wmDrag &drag,
const char **r_disabled_hint)
const override;
69 std::string drop_tooltip(
const DragInfo &drag_info)
const override;
70 bool on_drop(bContext * ,
const DragInfo &drag_info)
const override;
73class NodePanelDropTarget :
public TreeViewItemDropTarget {
75 bNodeTreeInterfacePanel &panel_;
78 explicit NodePanelDropTarget(NodePanelViewItem &item, bNodeTreeInterfacePanel &panel);
80 bool can_drop(
const wmDrag &drag,
const char **r_disabled_hint)
const override;
81 std::string drop_tooltip(
const DragInfo &drag_info)
const override;
82 bool on_drop(bContext *
C,
const DragInfo &drag_info)
const override;
85class NodeSocketViewItem :
public BasicTreeViewItem {
88 bNodeTreeInterfaceSocket &socket_;
91 NodeSocketViewItem(bNodeTree &nodetree,
92 bNodeTreeInterface &interface,
93 bNodeTreeInterfaceSocket &socket)
94 : BasicTreeViewItem(socket.name(), ICON_NONE), nodetree_(nodetree), socket_(socket)
96 set_is_active_fn([interface, &socket]() {
return interface.active_item() == &socket.item; });
97 set_on_activate_fn([&interface](bContext & , BasicTreeViewItem &new_active) {
98 NodeSocketViewItem &self =
static_cast<NodeSocketViewItem &
>(new_active);
99 interface.active_item_set(&self.socket_.item,
false);
103 void build_row(Layout &row)
override
106 row.enabled_set(
false);
109 row.use_property_decorate_set(
false);
111 Layout &input_socket_layout = row.row(
true);
118 input_socket_layout.label(
"", ICON_BLANK1);
121 this->add_label(row,
IFACE_(label_.c_str()));
123 Layout &output_socket_layout = row.row(
true);
130 output_socket_layout.label(
"", ICON_BLANK1);
134 std::optional<bool> should_be_selected()
const override
139 void set_selected(
const bool select)
override
146 bool matches(
const AbstractViewItem &other)
const override
148 const NodeSocketViewItem *other_item =
dynamic_cast<const NodeSocketViewItem *
>(&other);
149 if (other_item ==
nullptr) {
153 return &socket_ == &other_item->socket_;
156 bool supports_renaming()
const override
160 bool rename(
const bContext &
C, StringRefNull new_name)
override
162 MEM_SAFE_DELETE(socket_.name_);
165 nodetree_.tree_interface.tag_item_property_changed();
170 StringRef get_rename_string()
const override
172 return socket_.name();
175 void delete_item(bContext *
C)
override
178 nodetree_.tree_interface.remove_item(socket_.item);
184 std::unique_ptr<AbstractViewItemDragController> create_drag_controller()
const override;
185 std::unique_ptr<TreeViewItemDropTarget> create_drop_target()
override;
188class NodePanelViewItem :
public BasicTreeViewItem {
190 bNodeTree &nodetree_;
191 bNodeTreeInterfacePanel &panel_;
192 bNodeTreeInterfaceSocket *toggle_ =
nullptr;
195 NodePanelViewItem(bNodeTree &nodetree,
196 bNodeTreeInterface &interface,
197 bNodeTreeInterfacePanel &panel)
198 : BasicTreeViewItem(panel.name(), ICON_NONE), nodetree_(nodetree), panel_(panel)
200 set_is_active_fn([interface, &panel]() {
return interface.active_item() == &panel.item; });
201 set_on_activate_fn([&interface](bContext & , BasicTreeViewItem &new_active) {
202 NodePanelViewItem &self =
static_cast<NodePanelViewItem &
>(new_active);
203 interface.active_item_set(&self.panel_.item,
false);
205 toggle_ = panel.header_toggle_socket();
206 is_always_collapsible_ =
true;
209 void build_row(Layout &row)
override
212 row.enabled_set(
false);
215 if (toggle_ !=
nullptr) {
216 Layout &toggle_layout = row.row(
true);
221 this->add_label(row,
IFACE_(label_.c_str()));
223 Layout &sub = row.row(
true);
224 sub.use_property_decorate_set(
false);
227 std::optional<bool> should_be_selected()
const override
232 void set_selected(
const bool select)
override
243 bool matches(
const AbstractViewItem &other)
const override
245 const NodePanelViewItem *other_item =
dynamic_cast<const NodePanelViewItem *
>(&other);
246 if (other_item ==
nullptr) {
250 return &panel_ == &other_item->panel_;
253 std::optional<bool> should_be_collapsed()
const override
258 bool set_collapsed(
const bool collapsed)
override
267 bool supports_renaming()
const override
271 bool rename(
const bContext &
C, StringRefNull new_name)
override
274 &nodetree_.id, RNA_NodeTreeInterfacePanel, &panel_);
280 StringRef get_rename_string()
const override
282 return panel_.name();
285 void delete_item(bContext *
C)
override
288 nodetree_.tree_interface.remove_item(panel_.item);
294 std::unique_ptr<AbstractViewItemDragController> create_drag_controller()
const override;
295 std::unique_ptr<TreeViewItemDropTarget> create_drop_target()
override;
298class NodeTreeInterfaceView :
public AbstractTreeView {
300 bNodeTree &nodetree_;
301 bNodeTreeInterface &interface_;
304 explicit NodeTreeInterfaceView(bNodeTree &nodetree, bNodeTreeInterface &interface)
305 : nodetree_(nodetree), interface_(interface)
309 bNodeTree &nodetree()
314 bNodeTreeInterface &interface()
319 void build_tree()
override
322 this->add_items_for_panel_recursive(interface_.root_panel, *
this);
326 void add_items_for_panel_recursive(bNodeTreeInterfacePanel &parent,
328 const bNodeTreeInterfaceItem *skip_item =
nullptr)
330 for (bNodeTreeInterfaceItem *item : parent.items()) {
331 if (item == skip_item) {
334 switch (item->item_type) {
338 NodeSocketViewItem &socket_item = parent_item.add_tree_item<NodeSocketViewItem>(
339 nodetree_, interface_, *socket);
340 socket_item.uncollapse_by_default();
346 NodePanelViewItem &panel_item = parent_item.add_tree_item<NodePanelViewItem>(
347 nodetree_, interface_, *panel);
348 panel_item.uncollapse_by_default();
350 const bNodeTreeInterfaceSocket *skip_item = panel->header_toggle_socket();
351 add_items_for_panel_recursive(
352 *panel, panel_item,
reinterpret_cast<const bNodeTreeInterfaceItem *
>(skip_item));
360std::unique_ptr<AbstractViewItemDragController> NodeSocketViewItem::create_drag_controller()
const
365 return std::make_unique<NodeTreeInterfaceDragController>(
366 static_cast<NodeTreeInterfaceView &
>(this->get_tree_view()), nodetree_);
369std::unique_ptr<TreeViewItemDropTarget> NodeSocketViewItem::create_drop_target()
371 return std::make_unique<NodeSocketDropTarget>(*
this, socket_);
374std::unique_ptr<AbstractViewItemDragController> NodePanelViewItem::create_drag_controller()
const
379 return std::make_unique<NodeTreeInterfaceDragController>(
380 static_cast<NodeTreeInterfaceView &
>(this->get_tree_view()), nodetree_);
383std::unique_ptr<TreeViewItemDropTarget> NodePanelViewItem::create_drop_target()
385 return std::make_unique<NodePanelDropTarget>(*
this, panel_);
388NodeTreeInterfaceDragController::NodeTreeInterfaceDragController(NodeTreeInterfaceView &view,
390 : AbstractViewItemDragController(view), tree_(tree)
394std::optional<eWM_DragDataType> NodeTreeInterfaceDragController::get_drag_type()
const
399void gather_drag_items_recursive(bNodeTreeInterfacePanel &panel,
400 Vector<bNodeTreeInterfaceItem *> &r_items,
401 const bool parent_selected)
403 for (bNodeTreeInterfaceItem *item : panel.items()) {
405 if (parent_selected) {
409 bool is_selected =
false;
410 switch (item->item_type) {
411 case NodeTreeInterfaceItemType::Panel: {
412 bNodeTreeInterfacePanel *panel = node_interface::get_item_as<bNodeTreeInterfacePanel>(
415 gather_drag_items_recursive(*panel, r_items, is_selected);
418 case NodeTreeInterfaceItemType::Socket: {
419 bNodeTreeInterfaceSocket *socket = node_interface::get_item_as<bNodeTreeInterfaceSocket>(
427 r_items.append(item);
432void *NodeTreeInterfaceDragController::create_drag_data()
const
434 Vector<bNodeTreeInterfaceItem *> drag_items;
435 gather_drag_items_recursive(tree_.tree_interface.root_panel, drag_items,
false);
439 drag_data->
tree = &tree_;
443 std::copy(drag_items.begin(), drag_items.end(), drag_data->
items);
449 BLI_assert(drag.type == WM_DRAG_NODE_TREE_INTERFACE);
453bool is_dragging_parent_panel(
const wmDrag &drag,
const bNodeTreeInterfaceItem &drop_target_item)
455 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
464 if (
const bNodeTreeInterfacePanel *panel =
465 node_interface::get_item_as<bNodeTreeInterfacePanel>(drag_data->
items[i]))
467 if (panel->contains(drop_target_item)) {
475NodeSocketDropTarget::NodeSocketDropTarget(NodeSocketViewItem &item,
476 bNodeTreeInterfaceSocket &socket)
481bool NodeSocketDropTarget::can_drop(
const wmDrag &drag,
const char ** )
const
483 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
486 if (is_dragging_parent_panel(drag, socket_.item)) {
492std::string NodeSocketDropTarget::drop_tooltip(
const DragInfo &drag_info)
const
494 switch (drag_info.drop_location) {
495 case DropLocation::Into:
497 case DropLocation::Before:
498 return TIP_(
"Insert before socket");
499 case DropLocation::After:
500 return TIP_(
"Insert after socket");
505bool on_drop_interface_items(bContext *
C,
506 const DragInfo &drag_info,
508 bNodeTreeInterfaceItem &drop_target_item)
513 bNodeTreeInterface &
interface = ntree.tree_interface;
514 bNodeTreeInterfaceItem *original_active = interface.active_item();
516 bNodeTreeInterfacePanel *parent =
nullptr;
518 switch (drag_info.drop_location) {
519 case DropLocation::Into: {
521 if (drop_target_item.item_type != NodeTreeInterfaceItemType::Panel) {
524 parent = node_interface::get_item_as<bNodeTreeInterfacePanel>(&drop_target_item);
525 const bool has_toggle = parent->header_toggle_socket() !=
nullptr;
529 case DropLocation::Before:
530 case DropLocation::After: {
532 parent = interface.find_item_parent(drop_target_item,
true);
534 const int offset = (drag_info.drop_location == DropLocation::After) ? 1 : 0;
535 position = parent->items().as_span().first_index_try(&drop_target_item) + offset;
539 if (parent ==
nullptr ||
position < 0) {
544 bNodeTreeInterfaceItem *drag_item = drag_data->
items[i];
545 interface.move_item_to_parent(*drag_item, parent,
position);
547 position = parent->item_position(*drag_item) + 1;
550 interface.active_item_set(original_active);
558bool NodeSocketDropTarget::on_drop(bContext *
C,
const DragInfo &drag_info)
const
560 bNodeTree &nodetree = this->get_view<NodeTreeInterfaceView>().nodetree();
561 return on_drop_interface_items(
C, drag_info, nodetree, socket_.item);
564NodePanelDropTarget::NodePanelDropTarget(NodePanelViewItem &item, bNodeTreeInterfacePanel &panel)
569bool NodePanelDropTarget::can_drop(
const wmDrag &drag,
const char ** )
const
571 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
574 if (is_dragging_parent_panel(drag, panel_.item)) {
580std::string NodePanelDropTarget::drop_tooltip(
const DragInfo &drag_info)
const
582 switch (drag_info.drop_location) {
583 case DropLocation::Into:
584 return TIP_(
"Insert into panel");
585 case DropLocation::Before:
586 return TIP_(
"Insert before panel");
587 case DropLocation::After:
588 return TIP_(
"Insert after panel");
593bool NodePanelDropTarget::on_drop(bContext *
C,
const DragInfo &drag_info)
const
595 bNodeTree &nodetree = get_view<NodeTreeInterfaceView>().nodetree();
596 return on_drop_interface_items(
C, drag_info, nodetree, panel_.item);
616 "Node Tree Declaration Tree View",
617 std::make_unique<nodes::NodeTreeInterfaceView>(nodetree, interface));
#define ID_IS_LINKED(_id)
#define ID_IS_EDITABLE(_id)
#define SET_FLAG_FROM_TEST(value, test, flag)
virtual bool set_collapsed(bool collapsed)
void set_default_rows(int default_rows)
virtual void set_selected(const bool select)
void allow_multiselect_items()
void set_context_menu_title(const std::string &title)
static void build_tree_view(const bContext &C, AbstractTreeView &tree_view, Layout &layout, bool add_box=true)
void * MEM_new_zeroed(size_t len, const char *str)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str)
T & get_item_as(bNodeTreeInterfaceItem &item)
AbstractGridView * block_add_view(Block &block, StringRef idname, std::unique_ptr< AbstractGridView > grid_view)
void template_node_socket(Layout *layout, bContext *C, const float color[4])
TreeViewItemContainer TreeViewOrItem
void template_tree_interface(Layout *layout, const bContext *C, PointerRNA *ptr)
void WM_main_add_notifier(uint type, void *reference)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void ED_undo_grouped_push(bContext *C, const char *str, UndoEncodeHints hints=UndoEncodeHints(0))
void RNA_property_update(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
bool RNA_struct_is_a(const StructRNA *type, const StructRNA *srna)
@ WM_DRAG_NODE_TREE_INTERFACE
@ NODE_INTERFACE_PANEL_IS_COLLAPSED
@ NODE_INTERFACE_PANEL_SELECT
void RNA_property_string_set(PointerRNA *ptr, PropertyRNA *prop, const char *value)
void ED_undo_push(bContext *C, const char *str, UndoEncodeHints hints=UndoEncodeHints(0))
void BKE_main_ensure_invariants(Main &bmain, std::optional< Span< ID * > > modified_ids=std::nullopt)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
Main * CTX_data_main(const bContext *C)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
@ NODE_INTERFACE_SOCKET_SELECT
@ NODE_INTERFACE_SOCKET_OUTPUT
@ NODE_INTERFACE_SOCKET_INPUT
bNodeTreeInterfaceItem ** items