Blender V5.3
interface_template_grease_pencil_layer_tree.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 "BLI_listbase.hh"
10
11#include "BKE_context.hh"
12#include "BKE_grease_pencil.hh"
13
14#include "BLT_translation.hh"
15
16#include "DEG_depsgraph.hh"
17
18#include "UI_interface.hh"
20#include "UI_tree_view.hh"
21
22#include "RNA_access.hh"
23#include "RNA_prototypes.hh"
24
25#include "ED_grease_pencil.hh"
26#include "ED_undo.hh"
27
28#include "WM_api.hh"
29#include "WM_message.hh"
30
31#include <fmt/format.h>
32
33namespace blender::ui {
34namespace greasepencil {
35
36using namespace blender::bke::greasepencil;
37
39 public:
40 explicit LayerTreeView(GreasePencil &grease_pencil) : grease_pencil_(grease_pencil) {}
41
42 void build_tree() override;
43
44 private:
45 void build_tree_node_recursive(TreeViewOrItem &parent, TreeNode &node);
46 GreasePencil &grease_pencil_;
47};
48
50 TreeNode &drop_tree_node_;
51
52 public:
54 : TreeViewItemDropTarget(item, behavior), drop_tree_node_(drop_tree_node)
55 {
56 }
57
58 bool can_drop(const wmDrag &drag, const char ** /*r_disabled_hint*/) const override
59 {
61 return false;
62 }
63
64 wmDragGreasePencilLayer *active_drag_node = static_cast<wmDragGreasePencilLayer *>(drag.poin);
65 if (active_drag_node->node->wrap().is_layer()) {
66 return true;
67 }
68
69 LayerGroup &group = active_drag_node->node->wrap().as_group();
70 if (drop_tree_node_.is_child_of(group)) {
71 /* Don't drop group node into its child node. */
72 return false;
73 }
74 return true;
75 }
76
77 std::string drop_tooltip(const DragInfo &drag_info) const override
78 {
79 const wmDragGreasePencilLayer *drag_grease_pencil =
80 static_cast<const wmDragGreasePencilLayer *>(drag_info.drag_data.poin);
81 TreeNode &drag_node = drag_grease_pencil->node->wrap();
82
83 const StringRef drag_name = drag_node.name();
84 const StringRef drop_name = drop_tree_node_.name();
85 const StringRef node_type = drag_node.is_layer() ? "layer" : "group";
86
87 switch (drag_info.drop_location) {
89 return fmt::format(
90 fmt::runtime(TIP_("Move {} {} into {}")), node_type, drag_name, drop_name);
92 return fmt::format(
93 fmt::runtime(TIP_("Move {} {} above {}")), node_type, drag_name, drop_name);
95 return fmt::format(
96 fmt::runtime(TIP_("Move {} {} below {}")), node_type, drag_name, drop_name);
97 default:
99 break;
100 }
101
102 return "";
103 }
104
105 bool on_drop(bContext *C, const DragInfo &drag_info) const override
106 {
107 const wmDragGreasePencilLayer *drag_grease_pencil =
108 static_cast<const wmDragGreasePencilLayer *>(drag_info.drag_data.poin);
109 GreasePencil &grease_pencil = *drag_grease_pencil->grease_pencil;
110 TreeNode &drag_node = drag_grease_pencil->node->wrap();
111
112 if (!drop_tree_node_.parent_group()) {
113 /* Root node is not added to the tree view, so there should never be a drop target for this.
114 */
116 return false;
117 }
118
119 if (&drop_tree_node_ == &drag_node) {
120 return false;
121 }
122
123 switch (drag_info.drop_location) {
124 case DropLocation::Into: {
125 BLI_assert_msg(drop_tree_node_.is_group(),
126 "Inserting should not be possible for layers, only for groups, because "
127 "only groups use DropBehavior::Reorder_and_Insert");
128 LayerGroup &drop_group = drop_tree_node_.as_group();
129 grease_pencil.move_node_into(drag_node, drop_group);
130 break;
131 }
133 /* Draw order is inverted, so inserting before (above) means inserting the node after. */
134 grease_pencil.move_node_after(drag_node, drop_tree_node_);
135 break;
136 }
137 case DropLocation::After: {
138 /* Draw order is inverted, so inserting after (below) means inserting the node before. */
139 grease_pencil.move_node_before(drag_node, drop_tree_node_);
140 break;
141 }
142 default: {
144 return false;
145 }
146 }
147
148 if (drag_node.is_layer()) {
150 CTX_wm_message_bus(C), &grease_pencil.id, &grease_pencil, GreasePencilv3Layers, active);
153 }
154 else if (drag_node.is_group()) {
156 &grease_pencil.id,
158 GreasePencilv3LayerGroup,
159 active);
162 }
163
164 ED_undo_push(C, "Reorder Layers");
165
168 return true;
169 }
170};
171
173 GreasePencil &grease_pencil_;
174 TreeNode &dragged_node_;
175
176 public:
181 grease_pencil_(grease_pencil),
182 dragged_node_(node.wrap())
183 {
184 }
185
186 std::optional<eWM_DragDataType> get_drag_type() const override
187 {
188 if (dragged_node_.wrap().is_layer()) {
190 }
192 }
193
194 void *create_drag_data() const override
195 {
197 drag_data->node = &dragged_node_;
198 drag_data->grease_pencil = &grease_pencil_;
199 return drag_data;
200 }
201
202 void on_drag_start(bContext & /*C*/, AbstractViewItem & /*item*/) override
203 {
204 grease_pencil_.set_active_node(&dragged_node_);
205 }
206};
207
209 public:
211 : grease_pencil_(grease_pencil), layer_(layer)
212 {
213 this->label_ = layer.name();
214 }
215
216 void build_row(Layout &row) override
217 {
218 build_layer_name(row);
219
220 Layout &sub = row.row(true);
221 sub.use_property_decorate_set(false);
222
223 build_layer_buttons(sub);
224 }
225
226 bool supports_collapsing() const override
227 {
228 /* This is a bit redundant since `LayerViewItem` can't have children.
229 * But being explicit might catch errors. */
230 return false;
231 }
232
233 std::optional<bool> should_be_active() const override
234 {
235 if (this->grease_pencil_.has_active_layer()) {
236 return reinterpret_cast<GreasePencilLayer *>(&layer_) ==
237 reinterpret_cast<GreasePencilLayer *>(this->grease_pencil_.get_active_layer());
238 }
239 return {};
240 }
241
242 void on_activate(bContext &C) override
243 {
245 &grease_pencil_.id, RNA_GreasePencilv3Layers, nullptr);
247 &grease_pencil_.id, RNA_GreasePencilLayer, &layer_);
248
249 PropertyRNA *prop = RNA_struct_find_property(&layers_ptr, "active");
250
251 if (grease_pencil_.has_active_group()) {
253 &grease_pencil_.id,
254 &grease_pencil_,
255 GreasePencilv3LayerGroup,
256 active);
257 }
258
259 RNA_property_pointer_set(&layers_ptr, prop, value_ptr, nullptr);
260 RNA_property_update(&C, &layers_ptr, prop);
261
262 ED_undo_push(&C, "Active Grease Pencil Layer");
263 }
264
265 bool supports_renaming() const override
266 {
267 return true;
268 }
269
270 bool rename(const bContext &C, StringRefNull new_name) override
271 {
273 &grease_pencil_.id, RNA_GreasePencilLayer, &layer_);
274 PropertyRNA *prop = RNA_struct_find_property(&layer_ptr, "name");
275
276 RNA_property_string_set(&layer_ptr, prop, new_name.c_str());
277 RNA_property_update(&const_cast<bContext &>(C), &layer_ptr, prop);
278
279 ED_undo_push(&const_cast<bContext &>(C), "Rename Grease Pencil Layer");
280 return true;
281 }
282
284 {
285 return layer_.name();
286 }
287
288 void delete_item(bContext *C) override
289 {
290 grease_pencil_.remove_layer(layer_);
291 DEG_id_tag_update(&grease_pencil_.id, ID_RECALC_GEOMETRY);
293 ED_undo_push(C, "Delete Grease Pencil Layer");
294 }
295
296 std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const override
297 {
298 return std::make_unique<LayerViewItemDragController>(
299 static_cast<LayerTreeView &>(get_tree_view()), grease_pencil_, layer_.base);
300 }
301
302 std::unique_ptr<TreeViewItemDropTarget> create_drop_target() override
303 {
304 return std::make_unique<LayerNodeDropTarget>(*this, layer_.as_node(), DropBehavior::Reorder);
305 }
306
307 private:
308 GreasePencil &grease_pencil_;
309 Layer &layer_;
310
311 void build_layer_name(Layout &row)
312 {
313 Button *but = uiItemL_ex(
314 &row, layer_.name().c_str(), ICON_OUTLINER_DATA_GP_LAYER, false, false);
315
316 if (ID_IS_LINKED(&grease_pencil_)) {
318 }
319 else if (!layer_.is_editable()) {
320 button_disable(but, "Layer is locked or not visible");
321 }
322 }
323
324 void build_layer_buttons(Layout &row)
325 {
327 &grease_pencil_.id, RNA_GreasePencilLayer, &layer_);
328
329 Layout *sub = &row.row(true);
330 sub->active_set(layer_.parent_group().use_masks());
331 sub->prop(&layer_ptr, "use_masks", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
332
333 sub = &row.row(true);
334 sub->active_set(layer_.parent_group().use_onion_skinning());
335 sub->prop(&layer_ptr, "use_onion_skinning", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
336
337 sub = &row.row(true);
338 sub->active_set(layer_.parent_group().is_visible());
339 sub->prop(&layer_ptr, "hide", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
340
341 sub = &row.row(true);
342 sub->active_set(!layer_.parent_group().is_locked());
343 sub->prop(&layer_ptr, "lock", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
344 }
345};
346
348 public:
350 : grease_pencil_(grease_pencil), group_(group)
351 {
352 this->label_ = group_.name();
353 }
354
355 std::optional<bool> should_be_collapsed() const override
356 {
357 const bool is_collapsed = !group_.is_expanded();
358 return is_collapsed;
359 }
360
361 bool set_collapsed(const bool collapsed) override
362 {
363 if (!AbstractTreeViewItem::set_collapsed(collapsed)) {
364 return false;
365 }
366 group_.set_expanded(!collapsed);
367 return true;
368 }
369
370 void on_collapse_change(bContext &C, const bool is_collapsed) override
371 {
372 const bool is_expanded = !is_collapsed;
373
374 /* Let RNA handle the property change. This makes sure all the notifiers and DEG
375 * update calls are properly called. */
377 &grease_pencil_.id, RNA_GreasePencilLayerGroup, &group_);
378 PropertyRNA *prop = RNA_struct_find_property(&group_ptr, "is_expanded");
379
380 RNA_property_boolean_set(&group_ptr, prop, is_expanded);
381 RNA_property_update(&C, &group_ptr, prop);
382 }
383
384 void build_row(Layout &row) override
385 {
386 build_layer_group_name(row);
387
388 Layout &sub = row.row(true);
389 sub.use_property_decorate_set(false);
390
391 build_layer_group_buttons(sub);
392 }
393
394 std::optional<bool> should_be_active() const override
395 {
396 if (this->grease_pencil_.has_active_group()) {
397 return &group_ == this->grease_pencil_.get_active_group();
398 }
399 return {};
400 }
401
402 void build_context_menu(bContext &C, Layout &layout) const override
403 {
404 MenuType *mt = WM_menutype_find("GREASE_PENCIL_MT_group_context_menu", true);
405 if (!mt) {
406 return;
407 }
408 menutype_draw(&C, mt, &layout);
409 }
410
411 void on_activate(bContext &C) override
412 {
413 PointerRNA grease_pencil_ptr = RNA_pointer_create_discrete(
414 &grease_pencil_.id, RNA_GreasePencilv3LayerGroup, nullptr);
416 &grease_pencil_.id, RNA_GreasePencilLayerGroup, &group_);
417
418 PropertyRNA *prop = RNA_struct_find_property(&grease_pencil_ptr, "active");
419
420 if (grease_pencil_.has_active_layer()) {
422 &grease_pencil_.id,
423 &grease_pencil_,
424 GreasePencilv3Layers,
425 active);
426 }
427
428 RNA_property_pointer_set(&grease_pencil_ptr, prop, value_ptr, nullptr);
429 RNA_property_update(&C, &grease_pencil_ptr, prop);
430
431 ED_undo_push(&C, "Active Grease Pencil Group");
432 }
433
434 bool supports_renaming() const override
435 {
436 return true;
437 }
438
439 bool rename(const bContext &C, StringRefNull new_name) override
440 {
442 &grease_pencil_.id, RNA_GreasePencilLayerGroup, &group_);
443 PropertyRNA *prop = RNA_struct_find_property(&group_ptr, "name");
444
445 RNA_property_string_set(&group_ptr, prop, new_name.c_str());
446 RNA_property_update(&const_cast<bContext &>(C), &group_ptr, prop);
447
448 ED_undo_push(&const_cast<bContext &>(C), "Rename Grease Pencil Layer Group");
449 return true;
450 }
451
453 {
454 return group_.name();
455 }
456
457 void delete_item(bContext *C) override
458 {
459 grease_pencil_.remove_group(group_);
460 DEG_id_tag_update(&grease_pencil_.id, ID_RECALC_GEOMETRY);
462 ED_undo_push(C, "Delete Grease Pencil Group");
463 }
464
465 std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const override
466 {
467 return std::make_unique<LayerViewItemDragController>(
468 static_cast<LayerTreeView &>(get_tree_view()), grease_pencil_, group_.base);
469 }
470
471 std::unique_ptr<TreeViewItemDropTarget> create_drop_target() override
472 {
473 return std::make_unique<LayerNodeDropTarget>(
474 *this, group_.as_node(), DropBehavior::ReorderAndInsert);
475 }
476
477 private:
478 GreasePencil &grease_pencil_;
479 LayerGroup &group_;
480
481 void build_layer_group_name(Layout &row)
482 {
483 short icon = ICON_GREASEPENCIL_LAYER_GROUP;
484 if (group_.color_tag != LAYERGROUP_COLOR_NONE) {
485 icon = ICON_LAYERGROUP_COLOR_01 + int(group_.color_tag);
486 }
487
488 Button *but = uiItemL_ex(&row, group_.name(), icon, false, false);
489 if (ID_IS_LINKED(&grease_pencil_)) {
491 }
492 else if (!group_.is_editable()) {
493 button_disable(but, "Layer Group is locked or not visible");
494 }
495 }
496
497 void build_layer_group_buttons(Layout &row)
498 {
499 PointerRNA group_ptr = RNA_pointer_create_discrete(
500 &grease_pencil_.id, RNA_GreasePencilLayerGroup, &group_);
501
502 Layout *sub = &row.row(true);
503 if (group_.as_node().parent_group()) {
504 sub->active_set(group_.as_node().parent_group()->use_masks());
505 }
506 sub->prop(&group_ptr, "use_masks", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
507
508 sub = &row.row(true);
509 if (group_.as_node().parent_group()) {
510 sub->active_set(group_.as_node().parent_group()->use_onion_skinning());
511 }
512 sub->prop(&group_ptr, "use_onion_skinning", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
513
514 sub = &row.row(true);
515 if (group_.as_node().parent_group()) {
516 sub->active_set(group_.as_node().parent_group()->is_visible());
517 }
518 sub->prop(&group_ptr, "hide", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
519
520 sub = &row.row(true);
521 if (group_.as_node().parent_group()) {
522 sub->active_set(!group_.as_node().parent_group()->is_locked());
523 }
524 sub->prop(&group_ptr, "lock", ITEM_R_ICON_ONLY, std::nullopt, ICON_NONE);
525 }
526};
527
528void LayerTreeView::build_tree_node_recursive(TreeViewOrItem &parent, TreeNode &node)
529{
530 using namespace blender::bke::greasepencil;
531 if (node.is_layer()) {
532 parent.add_tree_item<LayerViewItem>(this->grease_pencil_, node.as_layer());
533 }
534 else if (node.is_group()) {
535 LayerGroupViewItem &group_item = parent.add_tree_item<LayerGroupViewItem>(this->grease_pencil_,
536 node.as_group());
537 for (GreasePencilLayerTreeNode &node_ : node.as_group().children.items_reversed()) {
538 build_tree_node_recursive(group_item, node_.wrap());
539 }
540 }
541}
542
544{
545 using namespace blender::bke::greasepencil;
547 this->grease_pencil_.root_group_ptr->children.items_reversed())
548 {
549 this->build_tree_node_recursive(*this, node.wrap());
550 }
551}
552} // namespace greasepencil
553
555{
557
558 if (grease_pencil == nullptr) {
559 return;
560 }
561
562 Block *block = layout->block();
563
564 AbstractTreeView *tree_view = block_add_view(
565 *block,
566 "Grease Pencil Layer Tree View",
567 std::make_unique<greasepencil::LayerTreeView>(*grease_pencil));
568 tree_view->set_context_menu_title("Grease Pencil Layer");
569 tree_view->set_default_rows(6);
570
571 TreeViewBuilder::build_tree_view(*C, *tree_view, *layout);
572}
573
574} // namespace blender::ui
Low-level operations for grease pencil.
#define TIP_(msgid)
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define C
Definition RandGen.cpp:29
#define ND_DRAW
Definition WM_types.hh:502
#define NA_EDITED
Definition WM_types.hh:634
#define NC_GPENCIL
Definition WM_types.hh:412
#define NC_OBJECT
Definition WM_types.hh:392
#define BLI_assert_unreachable()
#define ELEM(...)
#define BLI_assert_msg(a, msg)
constexpr const char * c_str() const
const LayerGroup & parent_group() const
Abstract base class for defining a customizable tree-view item.
AbstractTreeView & get_tree_view() const
Definition tree_view.cc:775
virtual bool set_collapsed(bool collapsed)
Definition tree_view.cc:847
void set_default_rows(int default_rows)
Definition tree_view.cc:234
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)
TreeViewItemDropTarget(AbstractTreeViewItem &view_item, DropBehavior behavior=DropBehavior::Insert)
Definition tree_view.cc:557
std::unique_ptr< AbstractViewItemDragController > create_drag_controller() const override
void on_collapse_change(bContext &C, const bool is_collapsed) override
bool rename(const bContext &C, StringRefNull new_name) override
LayerGroupViewItem(GreasePencil &grease_pencil, LayerGroup &group)
void build_context_menu(bContext &C, Layout &layout) const override
std::unique_ptr< TreeViewItemDropTarget > create_drop_target() override
std::string drop_tooltip(const DragInfo &drag_info) const override
bool can_drop(const wmDrag &drag, const char **) const override
LayerNodeDropTarget(AbstractTreeViewItem &item, TreeNode &drop_tree_node, DropBehavior behavior)
bool on_drop(bContext *C, const DragInfo &drag_info) const override
LayerViewItemDragController(LayerTreeView &tree_view, GreasePencil &grease_pencil, GreasePencilLayerTreeNode &node)
bool rename(const bContext &C, StringRefNull new_name) override
std::unique_ptr< AbstractViewItemDragController > create_drag_controller() const override
std::unique_ptr< TreeViewItemDropTarget > create_drop_target() override
#define layer
GreasePencil * from_context(bContext &C)
BLI_INLINE Texture * wrap(MTLTexture *texture)
AbstractGridView * block_add_view(Block &block, StringRef idname, std::unique_ptr< AbstractGridView > grid_view)
void button_disable(Button *but, const char *disabled_hint)
void button_flag_enable(Button *but, int64_t flag)
TreeViewItemContainer TreeViewOrItem
Button * uiItemL_ex(Layout *layout, StringRef name, int icon, bool highlight, bool redalert)
void menutype_draw(bContext *C, MenuType *mt, Layout *layout)
void template_grease_pencil_layer_tree(Layout *layout, bContext *C)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void RNA_property_update(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
void RNA_property_pointer_set(PointerRNA *ptr, PropertyRNA *prop, PointerRNA ptr_value, ReportList *reports)
MenuType * WM_menutype_find(const StringRef idname, bool quiet)
@ WM_DRAG_GREASE_PENCIL_LAYER
Definition WM_types.hh:1315
@ WM_DRAG_GREASE_PENCIL_GROUP
Definition WM_types.hh:1316
void RNA_property_string_set(PointerRNA *ptr, PropertyRNA *prop, const char *value)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void DEG_id_tag_update(ID *id, unsigned int flags)
void ED_undo_push(bContext *C, const char *str, UndoEncodeHints hints=UndoEncodeHints(0))
Definition ed_undo.cc:103
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmMsgBus * CTX_wm_message_bus(const bContext *C)
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
void RNA_property_boolean_set(PointerRNA *ptr, PropertyRNA *prop, bool value)
const wmDrag & drag_data
const DropLocation drop_location
void use_property_decorate_set(bool is_decorate)
Layout & row(bool align)
GreasePencilLayerTreeNode * node
Definition WM_types.hh:1375
eWM_DragDataType type
Definition WM_types.hh:1424
#define WM_msg_publish_rna_prop(mbus, id_, data_, type_, prop_)