Blender V5.3
interface_template_node_tree_interface.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_context.hh"
10#include "BKE_library.hh"
13
14#include "BLI_string.hh"
15
16#include "BLT_translation.hh"
17
19
20#include "ED_node.hh"
21#include "ED_undo.hh"
22
23#include "RNA_access.hh"
24#include "RNA_prototypes.hh"
25
26#include "UI_interface.hh"
28#include "UI_resources.hh"
29#include "UI_tree_view.hh"
30
31#include "WM_api.hh"
32
33namespace blender {
34
36
37namespace ui {
38namespace nodes {
39
40namespace {
41
42using node_interface::bNodeTreeInterfaceItemReference;
43
44class NodePanelViewItem;
45class NodeSocketViewItem;
46class NodeTreeInterfaceView;
47
48class NodeTreeInterfaceDragController : public AbstractViewItemDragController {
49 private:
50 bNodeTree &tree_;
51
52 public:
53 explicit NodeTreeInterfaceDragController(NodeTreeInterfaceView &view, bNodeTree &tree);
54 ~NodeTreeInterfaceDragController() override = default;
55
56 std::optional<eWM_DragDataType> get_drag_type() const override;
57
58 void *create_drag_data() const override;
59};
60
61class NodeSocketDropTarget : public TreeViewItemDropTarget {
62 private:
63 bNodeTreeInterfaceSocket &socket_;
64
65 public:
66 explicit NodeSocketDropTarget(NodeSocketViewItem &item, bNodeTreeInterfaceSocket &socket);
67
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 * /*C*/, const DragInfo &drag_info) const override;
71};
72
73class NodePanelDropTarget : public TreeViewItemDropTarget {
74 private:
75 bNodeTreeInterfacePanel &panel_;
76
77 public:
78 explicit NodePanelDropTarget(NodePanelViewItem &item, bNodeTreeInterfacePanel &panel);
79
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;
83};
84
85class NodeSocketViewItem : public BasicTreeViewItem {
86 private:
87 bNodeTree &nodetree_;
88 bNodeTreeInterfaceSocket &socket_;
89
90 public:
91 NodeSocketViewItem(bNodeTree &nodetree,
92 bNodeTreeInterface &interface,
93 bNodeTreeInterfaceSocket &socket)
94 : BasicTreeViewItem(socket.name(), ICON_NONE), nodetree_(nodetree), socket_(socket)
95 {
96 set_is_active_fn([interface, &socket]() { return interface.active_item() == &socket.item; });
97 set_on_activate_fn([&interface](bContext & /*C*/, BasicTreeViewItem &new_active) {
98 NodeSocketViewItem &self = static_cast<NodeSocketViewItem &>(new_active);
99 interface.active_item_set(&self.socket_.item, false);
100 });
101 }
102
103 void build_row(Layout &row) override
104 {
105 if (ID_IS_LINKED(&nodetree_)) {
106 row.enabled_set(false);
107 }
108
109 row.use_property_decorate_set(false);
110
111 Layout &input_socket_layout = row.row(true);
112 if (socket_.flag & NODE_INTERFACE_SOCKET_INPUT) {
113 /* Context is not used by the template function. */
114 template_node_socket(&input_socket_layout, /*C*/ nullptr, socket_.socket_color());
115 }
116 else {
117 /* Blank item to align output socket labels with inputs. */
118 input_socket_layout.label("", ICON_BLANK1);
119 }
120
121 this->add_label(row, IFACE_(label_.c_str()));
122
123 Layout &output_socket_layout = row.row(true);
124 if (socket_.flag & NODE_INTERFACE_SOCKET_OUTPUT) {
125 /* Context is not used by the template function. */
126 template_node_socket(&output_socket_layout, /*C*/ nullptr, socket_.socket_color());
127 }
128 else {
129 /* Blank item to align input socket labels with outputs. */
130 output_socket_layout.label("", ICON_BLANK1);
131 }
132 }
133
134 std::optional<bool> should_be_selected() const override
135 {
136 return socket_.flag & NODE_INTERFACE_SOCKET_SELECT;
137 }
138
139 void set_selected(const bool select) override
140 {
143 }
144
145 protected:
146 bool matches(const AbstractViewItem &other) const override
147 {
148 const NodeSocketViewItem *other_item = dynamic_cast<const NodeSocketViewItem *>(&other);
149 if (other_item == nullptr) {
150 return false;
151 }
152
153 return &socket_ == &other_item->socket_;
154 }
155
156 bool supports_renaming() const override
157 {
158 return !ID_IS_LINKED(&nodetree_);
159 }
160 bool rename(const bContext &C, StringRefNull new_name) override
161 {
162 MEM_SAFE_DELETE(socket_.name_);
163
164 socket_.name_ = BLI_strdup(new_name.c_str());
165 nodetree_.tree_interface.tag_item_property_changed();
167 ED_undo_push(&const_cast<bContext &>(C), new_name.c_str());
168 return true;
169 }
170 StringRef get_rename_string() const override
171 {
172 return socket_.name();
173 }
174
175 void delete_item(bContext *C) override
176 {
177 Main *bmain = CTX_data_main(C);
178 nodetree_.tree_interface.remove_item(socket_.item);
179 BKE_main_ensure_invariants(*bmain, nodetree_.id);
181 ED_undo_grouped_push(C, "Delete Node Interface Item");
182 }
183
184 std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const override;
185 std::unique_ptr<TreeViewItemDropTarget> create_drop_target() override;
186};
187
188class NodePanelViewItem : public BasicTreeViewItem {
189 private:
190 bNodeTree &nodetree_;
191 bNodeTreeInterfacePanel &panel_;
192 bNodeTreeInterfaceSocket *toggle_ = nullptr;
193
194 public:
195 NodePanelViewItem(bNodeTree &nodetree,
196 bNodeTreeInterface &interface,
197 bNodeTreeInterfacePanel &panel)
198 : BasicTreeViewItem(panel.name(), ICON_NONE), nodetree_(nodetree), panel_(panel)
199 {
200 set_is_active_fn([interface, &panel]() { return interface.active_item() == &panel.item; });
201 set_on_activate_fn([&interface](bContext & /*C*/, BasicTreeViewItem &new_active) {
202 NodePanelViewItem &self = static_cast<NodePanelViewItem &>(new_active);
203 interface.active_item_set(&self.panel_.item, false);
204 });
205 toggle_ = panel.header_toggle_socket();
206 is_always_collapsible_ = true;
207 }
208
209 void build_row(Layout &row) override
210 {
211 if (ID_IS_LINKED(&nodetree_)) {
212 row.enabled_set(false);
213 }
214 /* Add boolean socket if panel has a toggle. */
215 if (toggle_ != nullptr) {
216 Layout &toggle_layout = row.row(true);
217 /* Context is not used by the template function. */
218 template_node_socket(&toggle_layout, /*C*/ nullptr, toggle_->socket_color());
219 }
220
221 this->add_label(row, IFACE_(label_.c_str()));
222
223 Layout &sub = row.row(true);
224 sub.use_property_decorate_set(false);
225 }
226
227 std::optional<bool> should_be_selected() const override
228 {
229 return panel_.flag & NODE_INTERFACE_PANEL_SELECT;
230 }
231
232 void set_selected(const bool select) override
233 {
236 /* `NodeSocketViewItem::set_selected` doesn't handle toggle sockets, so handle it here. */
237 if (toggle_) {
238 SET_FLAG_FROM_TEST(toggle_->flag, select, NODE_INTERFACE_SOCKET_SELECT);
239 }
240 }
241
242 protected:
243 bool matches(const AbstractViewItem &other) const override
244 {
245 const NodePanelViewItem *other_item = dynamic_cast<const NodePanelViewItem *>(&other);
246 if (other_item == nullptr) {
247 return false;
248 }
249
250 return &panel_ == &other_item->panel_;
251 }
252
253 std::optional<bool> should_be_collapsed() const override
254 {
255 return panel_.flag & NODE_INTERFACE_PANEL_IS_COLLAPSED;
256 }
257
258 bool set_collapsed(const bool collapsed) override
259 {
260 if (!AbstractTreeViewItem::set_collapsed(collapsed)) {
261 return false;
262 }
264 return true;
265 }
266
267 bool supports_renaming() const override
268 {
269 return !ID_IS_LINKED(&nodetree_);
270 }
271 bool rename(const bContext &C, StringRefNull new_name) override
272 {
273 PointerRNA panel_ptr = RNA_pointer_create_discrete(
274 &nodetree_.id, RNA_NodeTreeInterfacePanel, &panel_);
275 PropertyRNA *name_prop = RNA_struct_find_property(&panel_ptr, "name");
276 RNA_property_string_set(&panel_ptr, name_prop, new_name.c_str());
277 RNA_property_update(const_cast<bContext *>(&C), &panel_ptr, name_prop);
278 return true;
279 }
280 StringRef get_rename_string() const override
281 {
282 return panel_.name();
283 }
284
285 void delete_item(bContext *C) override
286 {
287 Main *bmain = CTX_data_main(C);
288 nodetree_.tree_interface.remove_item(panel_.item);
289 BKE_main_ensure_invariants(*bmain, nodetree_.id);
291 ED_undo_grouped_push(C, "Delete Node Interface Item");
292 }
293
294 std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const override;
295 std::unique_ptr<TreeViewItemDropTarget> create_drop_target() override;
296};
297
298class NodeTreeInterfaceView : public AbstractTreeView {
299 private:
300 bNodeTree &nodetree_;
301 bNodeTreeInterface &interface_;
302
303 public:
304 explicit NodeTreeInterfaceView(bNodeTree &nodetree, bNodeTreeInterface &interface)
305 : nodetree_(nodetree), interface_(interface)
306 {
307 }
308
309 bNodeTree &nodetree()
310 {
311 return nodetree_;
312 }
313
314 bNodeTreeInterface &interface()
315 {
316 return interface_;
317 }
318
319 void build_tree() override
320 {
321 /* Draw root items */
322 this->add_items_for_panel_recursive(interface_.root_panel, *this);
323 }
324
325 protected:
326 void add_items_for_panel_recursive(bNodeTreeInterfacePanel &parent,
327 TreeViewOrItem &parent_item,
328 const bNodeTreeInterfaceItem *skip_item = nullptr)
329 {
330 for (bNodeTreeInterfaceItem *item : parent.items()) {
331 if (item == skip_item) {
332 continue;
333 }
334 switch (item->item_type) {
336 bNodeTreeInterfaceSocket *socket = node_interface::get_item_as<bNodeTreeInterfaceSocket>(
337 item);
338 NodeSocketViewItem &socket_item = parent_item.add_tree_item<NodeSocketViewItem>(
339 nodetree_, interface_, *socket);
340 socket_item.uncollapse_by_default();
341 break;
342 }
344 bNodeTreeInterfacePanel *panel = node_interface::get_item_as<bNodeTreeInterfacePanel>(
345 item);
346 NodePanelViewItem &panel_item = parent_item.add_tree_item<NodePanelViewItem>(
347 nodetree_, interface_, *panel);
348 panel_item.uncollapse_by_default();
349 /* Skip over sockets which are a panel toggle. */
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));
353 break;
354 }
355 }
356 }
357 }
358};
359
360std::unique_ptr<AbstractViewItemDragController> NodeSocketViewItem::create_drag_controller() const
361{
362 if (!ID_IS_EDITABLE(&nodetree_.id)) {
363 return nullptr;
364 }
365 return std::make_unique<NodeTreeInterfaceDragController>(
366 static_cast<NodeTreeInterfaceView &>(this->get_tree_view()), nodetree_);
367}
368
369std::unique_ptr<TreeViewItemDropTarget> NodeSocketViewItem::create_drop_target()
370{
371 return std::make_unique<NodeSocketDropTarget>(*this, socket_);
372}
373
374std::unique_ptr<AbstractViewItemDragController> NodePanelViewItem::create_drag_controller() const
375{
376 if (!ID_IS_EDITABLE(&nodetree_.id)) {
377 return nullptr;
378 }
379 return std::make_unique<NodeTreeInterfaceDragController>(
380 static_cast<NodeTreeInterfaceView &>(this->get_tree_view()), nodetree_);
381}
382
383std::unique_ptr<TreeViewItemDropTarget> NodePanelViewItem::create_drop_target()
384{
385 return std::make_unique<NodePanelDropTarget>(*this, panel_);
386}
387
388NodeTreeInterfaceDragController::NodeTreeInterfaceDragController(NodeTreeInterfaceView &view,
389 bNodeTree &tree)
390 : AbstractViewItemDragController(view), tree_(tree)
391{
392}
393
394std::optional<eWM_DragDataType> NodeTreeInterfaceDragController::get_drag_type() const
395{
397}
398
399void gather_drag_items_recursive(bNodeTreeInterfacePanel &panel,
400 Vector<bNodeTreeInterfaceItem *> &r_items,
401 const bool parent_selected)
402{
403 for (bNodeTreeInterfaceItem *item : panel.items()) {
404 /* If the parent is selected, the children will be dragged implicitly. */
405 if (parent_selected) {
406 continue;
407 }
408
409 bool is_selected = false;
410 switch (item->item_type) {
411 case NodeTreeInterfaceItemType::Panel: {
412 bNodeTreeInterfacePanel *panel = node_interface::get_item_as<bNodeTreeInterfacePanel>(
413 item);
414 is_selected = (panel->flag & NODE_INTERFACE_PANEL_SELECT);
415 gather_drag_items_recursive(*panel, r_items, is_selected);
416 break;
417 }
418 case NodeTreeInterfaceItemType::Socket: {
419 bNodeTreeInterfaceSocket *socket = node_interface::get_item_as<bNodeTreeInterfaceSocket>(
420 item);
421 is_selected = (socket->flag & NODE_INTERFACE_SOCKET_SELECT);
422 break;
423 }
424 }
425
426 if (is_selected) {
427 r_items.append(item);
428 }
429 }
430}
431
432void *NodeTreeInterfaceDragController::create_drag_data() const
433{
434 Vector<bNodeTreeInterfaceItem *> drag_items;
435 gather_drag_items_recursive(tree_.tree_interface.root_panel, drag_items, false);
436
438 __func__);
439 drag_data->tree = &tree_;
440 drag_data->items_count = drag_items.size();
442 "drag items");
443 std::copy(drag_items.begin(), drag_items.end(), drag_data->items);
444 return drag_data;
445}
446
447bNodeTreeInterfaceItemReference *get_drag_node_tree_declaration(const wmDrag &drag)
448{
449 BLI_assert(drag.type == WM_DRAG_NODE_TREE_INTERFACE);
450 return static_cast<bNodeTreeInterfaceItemReference *>(drag.poin);
451}
452
453bool is_dragging_parent_panel(const wmDrag &drag, const bNodeTreeInterfaceItem &drop_target_item)
454{
455 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
456 return false;
457 }
458 bNodeTreeInterfaceItemReference *drag_data = get_drag_node_tree_declaration(drag);
459 if (!drag_data || drag_data->items_count == 0) {
460 return false;
461 }
462
463 for (int i = 0; i < drag_data->items_count; i++) {
464 if (const bNodeTreeInterfacePanel *panel =
465 node_interface::get_item_as<bNodeTreeInterfacePanel>(drag_data->items[i]))
466 {
467 if (panel->contains(drop_target_item)) {
468 return true;
469 }
470 }
471 }
472 return false;
473}
474
475NodeSocketDropTarget::NodeSocketDropTarget(NodeSocketViewItem &item,
476 bNodeTreeInterfaceSocket &socket)
477 : TreeViewItemDropTarget(item, DropBehavior::Reorder), socket_(socket)
478{
479}
480
481bool NodeSocketDropTarget::can_drop(const wmDrag &drag, const char ** /*r_disabled_hint*/) const
482{
483 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
484 return false;
485 }
486 if (is_dragging_parent_panel(drag, socket_.item)) {
487 return false;
488 }
489 return true;
490}
491
492std::string NodeSocketDropTarget::drop_tooltip(const DragInfo &drag_info) const
493{
494 switch (drag_info.drop_location) {
495 case DropLocation::Into:
496 return "";
497 case DropLocation::Before:
498 return TIP_("Insert before socket");
499 case DropLocation::After:
500 return TIP_("Insert after socket");
501 }
502 return "";
503}
504
505bool on_drop_interface_items(bContext *C,
506 const DragInfo &drag_info,
507 bNodeTree &ntree,
508 bNodeTreeInterfaceItem &drop_target_item)
509{
510 bNodeTreeInterfaceItemReference *drag_data = get_drag_node_tree_declaration(drag_info.drag_data);
511 BLI_assert(drag_data != nullptr);
512
513 bNodeTreeInterface &interface = ntree.tree_interface;
514 bNodeTreeInterfaceItem *original_active = interface.active_item();
515
516 bNodeTreeInterfacePanel *parent = nullptr;
517 int position = -1;
518 switch (drag_info.drop_location) {
519 case DropLocation::Into: {
520 /* Insert into target */
521 if (drop_target_item.item_type != NodeTreeInterfaceItemType::Panel) {
522 return false;
523 }
524 parent = node_interface::get_item_as<bNodeTreeInterfacePanel>(&drop_target_item);
525 const bool has_toggle = parent->header_toggle_socket() != nullptr;
526 position = has_toggle ? 1 : 0;
527 break;
528 }
529 case DropLocation::Before:
530 case DropLocation::After: {
531 /* Insert into same panel as the target. */
532 parent = interface.find_item_parent(drop_target_item, true);
533 BLI_assert(parent != nullptr);
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;
536 break;
537 }
538 }
539 if (parent == nullptr || position < 0) {
540 return false;
541 }
542
543 for (int i = 0; i < drag_data->items_count; i++) {
544 bNodeTreeInterfaceItem *drag_item = drag_data->items[i];
545 interface.move_item_to_parent(*drag_item, parent, position);
546 /* Update position as it may shift after move. */
547 position = parent->item_position(*drag_item) + 1;
548 }
549
550 interface.active_item_set(original_active);
551
552 /* General update */
554 ED_undo_push(C, "Insert node group item");
555 return true;
556}
557
558bool NodeSocketDropTarget::on_drop(bContext *C, const DragInfo &drag_info) const
559{
560 bNodeTree &nodetree = this->get_view<NodeTreeInterfaceView>().nodetree();
561 return on_drop_interface_items(C, drag_info, nodetree, socket_.item);
562}
563
564NodePanelDropTarget::NodePanelDropTarget(NodePanelViewItem &item, bNodeTreeInterfacePanel &panel)
565 : TreeViewItemDropTarget(item, DropBehavior::ReorderAndInsert), panel_(panel)
566{
567}
568
569bool NodePanelDropTarget::can_drop(const wmDrag &drag, const char ** /*r_disabled_hint*/) const
570{
571 if (drag.type != WM_DRAG_NODE_TREE_INTERFACE) {
572 return false;
573 }
574 if (is_dragging_parent_panel(drag, panel_.item)) {
575 return false;
576 }
577 return true;
578}
579
580std::string NodePanelDropTarget::drop_tooltip(const DragInfo &drag_info) const
581{
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");
589 }
590 return "";
591}
592
593bool NodePanelDropTarget::on_drop(bContext *C, const DragInfo &drag_info) const
594{
595 bNodeTree &nodetree = get_view<NodeTreeInterfaceView>().nodetree();
596 return on_drop_interface_items(C, drag_info, nodetree, panel_.item);
597}
598} // namespace
599} // namespace nodes
600
602{
603 if (!*ptr) {
604 return;
605 }
606 if (!RNA_struct_is_a(ptr->type, RNA_NodeTreeInterface)) {
607 return;
608 }
609 bNodeTree &nodetree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
610 bNodeTreeInterface &interface = *static_cast<bNodeTreeInterface *>(ptr->data);
611
612 Block *block = layout->block();
613
614 AbstractTreeView *tree_view = block_add_view(
615 *block,
616 "Node Tree Declaration Tree View",
617 std::make_unique<nodes::NodeTreeInterfaceView>(nodetree, interface));
618 tree_view->set_context_menu_title("Node Tree Interface");
619 tree_view->set_default_rows(5);
620 tree_view->allow_multiselect_items();
621
622 TreeViewBuilder::build_tree_view(*C, *tree_view, *layout);
623}
624
625} // namespace ui
626} // namespace blender
#define TIP_(msgid)
#define IFACE_(msgid)
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define ID_IS_EDITABLE(_id)
Definition DNA_ID.h:708
#define C
Definition RandGen.cpp:29
#define NC_NODE
Definition WM_types.hh:407
#define NA_EDITED
Definition WM_types.hh:634
#define SET_FLAG_FROM_TEST(value, test, flag)
#define BLI_assert(a)
virtual bool set_collapsed(bool collapsed)
Definition tree_view.cc:847
void set_default_rows(int default_rows)
Definition tree_view.cc:234
virtual void set_selected(const bool select)
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)
#define position
void * MEM_new_zeroed(size_t len, const char *str)
Definition mallocn.cc:114
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str)
Definition mallocn.cc:119
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)
BMesh Iterators.
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))
Definition ed_undo.cc:357
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
Definition WM_types.hh:1317
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))
Definition ed_undo.cc:103
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
StructRNA * type
Definition RNA_types.hh:63