Blender V5.3
spreadsheet_dataset_draw.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
5#include <fmt/format.h>
6
7#include "BLI_listbase.hh"
8#include "BLI_string.hh"
9
10#include "DNA_curves_types.h"
11#include "DNA_mesh_types.h"
13#include "DNA_space_types.h"
15
16#include "BKE_context.hh"
17#include "BKE_curves.hh"
18#include "BKE_grease_pencil.hh"
19#include "BKE_instances.hh"
20#include "BKE_lib_id.hh"
21#include "BKE_volume.hh"
22
23#include "RNA_access.hh"
24#include "RNA_prototypes.hh"
25
27#include "UI_tree_view.hh"
28
29#include "WM_api.hh"
30#include "WM_types.hh"
31
32#include "BLT_translation.hh"
33
34#include "ED_outliner.hh"
35#include "ED_spreadsheet.hh"
36
37#include "NOD_eval_log.hh"
40
43#include "spreadsheet_intern.hh"
44#include "spreadsheet_table.hh"
45
47
50
53 std::optional<int> layer_index;
54 std::optional<bke::AttrDomain> domain;
55};
56
61
63 std::variant<GeometryDomainDataId, GeometryBundleItemId> id;
64
66 std::optional<int> layer_index,
67 std::optional<bke::AttrDomain> domain)
68 : id(GeometryDomainDataId{component_type, layer_index, domain})
69 {
70 }
71
73 SpreadsheetClosureInputOutput closure_in_out)
74 : id(GeometryBundleItemId{std::move(bundle_keys), closure_in_out})
75 {
76 }
77};
78
80{
81 /* Using the tree row button instead of a separate right aligned button gives padding
82 * to the right side of the number, which it didn't have with the button. */
83 button_hint_drawstr_set(reinterpret_cast<ui::Button *>(view_item.view_item_button()),
84 str.c_str());
85}
86
87static void draw_count(ui::AbstractTreeViewItem &view_item, const int count)
88{
90 BLI_str_format_decimal_unit(element_count, count);
91 draw_row_suffix(view_item, element_count);
92}
93
95{
96 switch (domain) {
98 return IFACE_("Vertex");
100 return IFACE_("Edge");
102 return IFACE_("Face");
104 return IFACE_("Face Corner");
105 default:
107 return "";
108 }
109}
110
112{
113 switch (domain) {
115 return IFACE_("Control Point");
117 return IFACE_("Spline");
118 default:
120 return "";
121 }
122}
123
125{
126 switch (domain) {
128 return ICON_VERTEXSEL;
130 return ICON_EDGESEL;
132 return ICON_FACESEL;
134 return ICON_FACE_CORNER;
135 default:
137 return ICON_NONE;
138 }
139}
140
142{
143 switch (domain) {
145 return ICON_CURVE_BEZCIRCLE;
147 return ICON_CURVE_PATH;
148 default:
150 return ICON_NONE;
151 }
152}
153
155 public:
157
158 void get_parent_instance_ids(Vector<SpreadsheetInstanceID> &r_instance_ids) const;
159
160 void on_activate(bContext &C) override;
161
162 std::optional<bool> should_be_active() const override;
163};
164
166 public:
168 {
169 label_ = geometry.name().is_empty() ? IFACE_("(Geometry)") : geometry.name();
170 }
171
172 void build_row(ui::Layout &row) override
173 {
174 row.label(label_, ICON_GEOMETRY_SET);
175 }
176};
177
179 private:
180 const bke::InstanceReference &reference_;
181 int reference_index_;
182 int user_count_;
183
184 public:
186 : reference_(instances.references()[reference_index]), reference_index_(reference_index)
187 {
188 label_ = std::to_string(reference_index);
189 user_count_ = instances.reference_user_counts()[reference_index];
190 }
191
192 void build_row(ui::Layout &row) override
193 {
194 const int icon = get_instance_reference_icon(reference_);
195 StringRefNull name = reference_.name();
196 if (name.is_empty()) {
197 name = IFACE_("(Geometry)");
198 }
199 row.label(name, icon);
200 draw_count(*this, user_count_);
201 }
202
203 int reference_index() const
204 {
205 return reference_index_;
206 }
207};
208
210 private:
211 ResourceScope scope_;
212 bke::GeometrySet root_geometry_set_;
213 SpaceSpreadsheet &sspreadsheet_;
214 bScreen &screen_;
215
217
218 public:
220 : root_geometry_set_(std::move(geometry_set)),
221 sspreadsheet_(*CTX_wm_space_spreadsheet(&C)),
222 screen_(*CTX_wm_screen(&C))
223 {
224 }
225
226 void build_tree() override
227 {
228 auto &root_item = this->add_tree_item<RootGeometryViewItem>(root_geometry_set_);
229 root_item.uncollapse_by_default();
230 if (const bke::Instances *instances = root_geometry_set_.get_instances()) {
231 this->build_tree_for_instances(root_item, *instances);
232 }
233 }
234
236 {
237 const Span<bke::InstanceReference> references = instances.references();
238 for (const int reference_i : references.index_range()) {
239 auto &reference_item = parent.add_tree_item<InstanceReferenceViewItem>(instances,
240 reference_i);
241 const bke::InstanceReference &reference = references[reference_i];
242 bke::GeometrySet &reference_geometry = scope_.construct<bke::GeometrySet>();
243 reference.to_geometry_set(reference_geometry);
244 if (const bke::Instances *child_instances = reference_geometry.get_instances()) {
245 this->build_tree_for_instances(reference_item, *child_instances);
246 }
247 }
248 }
249};
250
252 public:
254
255 void on_activate(bContext &C) override;
256
257 std::optional<bool> should_be_active() const override;
258
260 virtual std::optional<GeometryDataIdentifier> get_geometry_data_id() const
261 {
262 return std::nullopt;
263 }
264};
265
267 private:
268 bool has_mesh_;
269
270 public:
271 MeshViewItem(const bool has_mesh) : has_mesh_(has_mesh)
272 {
273 label_ = IFACE_("Mesh");
274 }
275
276 void build_row(ui::Layout &row) override
277 {
278 if (!has_mesh_) {
279 row.active_set(false);
280 }
281 row.label(label_, ICON_MESH_DATA);
282 }
283};
284
286 private:
287 const Mesh *mesh_;
288 bke::AttrDomain domain_;
289
290 public:
291 MeshDomainViewItem(const Mesh *mesh, const bke::AttrDomain domain) : mesh_(mesh), domain_(domain)
292 {
294 }
295
296 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
297 {
298 return GeometryDataIdentifier{bke::GeometryComponent::Type::Mesh, std::nullopt, domain_};
299 }
300
301 void build_row(ui::Layout &row) override
302 {
303 const BIFIconID icon = mesh_domain_to_icon(domain_);
304 row.label(label_, icon);
305
306 const int count = mesh_ ? mesh_->attributes().domain_size(domain_) : 0;
307 draw_count(*this, count);
308 }
309};
310
312 private:
313 bool has_curves_;
314
315 public:
316 CurvesViewItem(const bool has_curves) : has_curves_(has_curves)
317 {
318 label_ = IFACE_("Curve");
319 }
320
321 void build_row(ui::Layout &row) override
322 {
323 if (!has_curves_) {
324 row.active_set(false);
325 }
326 row.label(label_, ICON_CURVE_DATA);
327 }
328};
329
331 private:
332 const Curves *curves_;
333 bke::AttrDomain domain_;
334
335 public:
337 : curves_(curves), domain_(domain)
338 {
340 }
341
342 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
343 {
344 return GeometryDataIdentifier{bke::GeometryComponent::Type::Curve, std::nullopt, domain_};
345 }
346
347 void build_row(ui::Layout &row) override
348 {
349 const BIFIconID icon = curves_domain_to_icon(domain_);
350 row.label(label_, icon);
351
352 const int count = curves_ ? curves_->geometry.wrap().attributes().domain_size(domain_) : 0;
353 draw_count(*this, count);
354 }
355};
356
358 bool has_grease_pencil_;
359
360 public:
361 GreasePencilViewItem(const bool has_grease_pencil) : has_grease_pencil_(has_grease_pencil)
362 {
363 label_ = IFACE_("Grease Pencil");
364 }
365
366 void build_row(ui::Layout &row) override
367 {
368 if (!has_grease_pencil_) {
369 row.active_set(false);
370 }
371 row.label(label_, ICON_OUTLINER_DATA_GREASEPENCIL);
372 }
373};
374
376 private:
377 const GreasePencil *grease_pencil_;
378
379 public:
381 {
382 label_ = IFACE_("Layer");
383 }
384
385 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
386 {
389 }
390
391 void build_row(ui::Layout &row) override
392 {
393 const int count = grease_pencil_ ? grease_pencil_->layers().size() : 0;
394 row.label(label_, ICON_OUTLINER_DATA_GP_LAYER);
395 draw_count(*this, count);
396 }
397};
398
400 private:
401 const bke::greasepencil::Layer &layer_;
402
403 public:
405 : layer_(grease_pencil.layer(layer_index))
406 {
407 label_ = std::to_string(layer_index);
408 }
409
410 void build_row(ui::Layout &row) override
411 {
412 StringRefNull name = layer_.name();
413 if (name.is_empty()) {
414 name = IFACE_("(Layer)");
415 }
416 row.label(name, ICON_CURVE_DATA);
417 }
418};
419
421 private:
422 const GreasePencil &grease_pencil_;
423 int layer_index_;
424 bke::AttrDomain domain_;
425
426 public:
428 const int layer_index,
429 const bke::AttrDomain domain)
430 : grease_pencil_(grease_pencil), layer_index_(layer_index), domain_(domain)
431 {
433 }
434
435 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
436 {
438 bke::GeometryComponent::Type::GreasePencil, layer_index_, domain_};
439 }
440
441 void build_row(ui::Layout &row) override
442 {
443 const BIFIconID icon = curves_domain_to_icon(domain_);
444 row.label(label_, icon);
445
446 const bke::greasepencil::Drawing *drawing = grease_pencil_.get_eval_drawing(
447 grease_pencil_.layer(layer_index_));
448 const int count = drawing ? drawing->strokes().attributes().domain_size(domain_) : 0;
449 draw_count(*this, count);
450 }
451};
452
454 private:
455 bool has_pointcloud_;
456
457 public:
458 PointCloudViewItem(const bool has_pointcloud) : has_pointcloud_(has_pointcloud)
459 {
460 label_ = IFACE_("Point Cloud");
461 }
462
463 void build_row(ui::Layout &row) override
464 {
465 if (!has_pointcloud_) {
466 row.active_set(false);
467 }
468 row.label(label_, ICON_POINTCLOUD_DATA);
469 }
470};
471
473 private:
474 const PointCloud *pointcloud_;
475
476 public:
478 {
479 label_ = IFACE_("Point");
480 }
481
482 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
483 {
486 }
487
488 void build_row(ui::Layout &row) override
489 {
490 row.label(label_, ICON_POINTCLOUD_POINT);
491 const int count = pointcloud_ ? pointcloud_->totpoint : 0;
492 draw_count(*this, count);
493 }
494};
495
497 private:
498 const Volume *volume_;
499
500 public:
501 VolumeGridsViewItem(const Volume *volume) : volume_(volume)
502 {
503 label_ = IFACE_("Volume Grids");
504 }
505
506 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
507 {
509 bke::GeometryComponent::Type::Volume, std::nullopt, std::nullopt};
510 }
511
512 void build_row(ui::Layout &row) override
513 {
514 if (!volume_) {
515 row.active_set(false);
516 }
517 row.label(label_, ICON_VOLUME_DATA);
518 if (volume_) {
519 draw_count(*this, BKE_volume_num_grids(volume_));
520 }
521 }
522};
523
525 private:
526 const bke::Instances *instances_;
527
528 public:
529 InstancesViewItem(const bke::Instances *instances) : instances_(instances)
530 {
531 label_ = IFACE_("Instances");
532 }
533
534 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
535 {
538 }
539
540 void build_row(ui::Layout &row) override
541 {
542 if (!instances_) {
543 row.active_set(false);
544 }
545 row.label(label_, ICON_EMPTY_AXIS);
546 if (instances_) {
547 draw_count(*this, instances_->instances_num());
548 }
549 }
550};
551
553 private:
554 bool has_bundle_items_;
555
556 public:
557 GeometryBundleViewItem(bool has_bundle_items) : has_bundle_items_(has_bundle_items)
558 {
559 label_ = IFACE_("Bundle");
560 }
561
562 void build_row(ui::Layout &row) override
563 {
564 if (!has_bundle_items_) {
565 row.active_set(false);
566 }
567 row.label(label_, ICON_NONE);
568 }
569
570 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
571 {
573 }
574};
575
577 private:
578 nodes::BundleKey key_;
579
580 public:
582 {
583 label_ = key_.ustr().ref();
584 }
585
586 void build_row(ui::Layout &row) override
587 {
588 row.label(label_, ICON_NONE);
589 }
590
591 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
592 {
594 keys.append(key_);
595 this->foreach_parent([&](const AbstractTreeViewItem &parent) {
596 if (const auto *bundle_item = dynamic_cast<const GeometryBundleItemViewItem *>(&parent)) {
597 keys.append(bundle_item->key_);
598 }
599 });
600 std::reverse(keys.begin(), keys.end());
601 return GeometryDataIdentifier(std::move(keys), SPREADSHEET_CLOSURE_NONE);
602 }
603};
604
606 private:
608
609 public:
611 {
612 label_ = in_out_ == SPREADSHEET_CLOSURE_INPUT ? IFACE_("Inputs") : IFACE_("Outputs");
613 }
614
615 void build_row(ui::Layout &row) override
616 {
617 row.label(label_, ICON_NONE);
618 }
619
620 std::optional<GeometryDataIdentifier> get_geometry_data_id() const override
621 {
622 std::optional<GeometryDataIdentifier> data_id =
623 dynamic_cast<const GeometryBundleItemViewItem &>(*parent_).get_geometry_data_id();
624 BLI_assert(data_id);
625 GeometryBundleItemId &bundle_item_id = std::get<GeometryBundleItemId>(data_id->id);
626 bundle_item_id.closure_in_out = in_out_;
627 return data_id;
628 }
629};
630
632 private:
633 bke::GeometrySet geometry_set_;
634 SpaceSpreadsheet &sspreadsheet_;
635 bScreen &screen_;
636
637 friend class DataSetViewItem;
638
639 public:
641 : geometry_set_(std::move(geometry_set)),
642 sspreadsheet_(*CTX_wm_space_spreadsheet(&C)),
643 screen_(*CTX_wm_screen(&C))
644 {
645 }
646
647 void build_tree() override
648 {
649 this->build_tree_for_geometry(geometry_set_, *this);
650 }
651
653 {
654 const Mesh *mesh = geometry.get_mesh();
655 this->build_tree_for_mesh(mesh, parent);
656
657 const Curves *curves = geometry.get_curves();
658 this->build_tree_for_curves(curves, parent);
659
660 const GreasePencil *grease_pencil = geometry.get_grease_pencil();
662
663 const PointCloud *pointcloud = geometry.get_pointcloud();
665
666 const Volume *volume = geometry.get_volume();
667 this->build_tree_for_volume(volume, parent);
668
669 const bke::Instances *instances = geometry.get_instances();
670 this->build_tree_for_instances(instances, parent);
671
672 const nodes::Bundle *bundle = geometry.bundle();
673 this->build_tree_for_bundle(bundle, parent);
674 }
675
677 {
678 auto &mesh_item = parent.add_tree_item<MeshViewItem>(mesh != nullptr);
679 mesh_item.uncollapse_by_default();
680 if (!mesh) {
681 return;
682 }
683
684 mesh_item.add_tree_item<MeshDomainViewItem>(mesh, bke::AttrDomain::Point);
688 }
689
691 {
692 auto &curves_item = parent.add_tree_item<CurvesViewItem>(curves != nullptr);
693 curves_item.uncollapse_by_default();
694 if (!curves) {
695 return;
696 }
697
698 curves_item.add_tree_item<CurvesDomainViewItem>(curves, bke::AttrDomain::Point);
700 }
701
704 {
705 auto &grease_pencil_item = parent.add_tree_item<GreasePencilViewItem>(grease_pencil !=
706 nullptr);
707 grease_pencil_item.uncollapse_by_default();
708 if (!grease_pencil) {
709 return;
710 }
711
712 auto &layers_item = grease_pencil_item.add_tree_item<GreasePencilLayersViewItem>(
715 for (const int layer_i : layers.index_range()) {
716 auto &layer_item = layers_item.add_tree_item<GreasePencilLayerViewItem>(*grease_pencil,
717 layer_i);
722 }
723 }
724
726 {
727 auto &pointcloud_item = parent.add_tree_item<PointCloudViewItem>(pointcloud != nullptr);
728 pointcloud_item.uncollapse_by_default();
729 if (!pointcloud) {
730 return;
731 }
732
733 pointcloud_item.add_tree_item<PointsViewItem>(pointcloud);
734 }
735
737 {
738 parent.add_tree_item<VolumeGridsViewItem>(volume);
739 }
740
742 {
743 parent.add_tree_item<InstancesViewItem>(instances);
744 }
745
747 {
748 const bool has_bundle_items = bundle && !bundle->is_empty();
749 auto &bundle_view_item = parent.add_tree_item<GeometryBundleViewItem>(has_bundle_items);
750 if (!has_bundle_items) {
751 return;
752 }
753 this->build_bundle_children(*bundle, bundle_view_item);
754 }
755
757 {
758 for (const auto &item : bundle.items()) {
759 auto &child_item = parent.add_tree_item<GeometryBundleItemViewItem>(item.key);
760 const auto *stored_value = std::get_if<nodes::BundleItemSocketValue>(&item.value.value);
761 if (!stored_value) {
762 continue;
763 }
764 this->build_socket_value(stored_value->value, child_item);
765 }
766 }
767
769 {
770 const nodes::ClosureSignature &signature = closure.signature();
771 if (!signature.inputs.is_empty()) {
773 }
774 if (!signature.outputs.is_empty()) {
776 }
777 }
778
780 {
781 if (!value.is_single()) {
782 return;
783 }
784 const GPointer single_value = value.get();
785 if (single_value.is_type<nodes::BundlePtr>()) {
786 const nodes::BundlePtr &bundle_ptr = *single_value.get<nodes::BundlePtr>();
787 if (bundle_ptr) {
788 this->build_bundle_children(*bundle_ptr, parent);
789 }
790 }
791 if (single_value.is_type<nodes::ClosurePtr>()) {
792 const nodes::ClosurePtr &closure_ptr = *single_value.get<nodes::ClosurePtr>();
793 if (closure_ptr) {
794 this->build_closure_children(*closure_ptr, parent);
795 }
796 }
797 }
798};
799
801{
802 return static_cast<GeometryDataSetTreeView &>(this->get_tree_view());
803}
804
809
811 Vector<SpreadsheetInstanceID> &r_instance_ids) const
812{
813 if (const auto *reference_item = dynamic_cast<const InstanceReferenceViewItem *>(this)) {
814 r_instance_ids.append({reference_item->reference_index()});
815 }
816 this->foreach_parent([&](const ui::AbstractTreeViewItem &item) {
817 if (const auto *reference_item = dynamic_cast<const InstanceReferenceViewItem *>(&item)) {
818 r_instance_ids.append({reference_item->reference_index()});
819 }
820 });
821 std::reverse(r_instance_ids.begin(), r_instance_ids.end());
822}
823
825{
826 GeometryInstancesTreeView &tree_view = this->get_tree();
827 SpaceSpreadsheet &sspreadsheet = tree_view.sspreadsheet_;
828
830 this->get_parent_instance_ids(instance_ids);
831 if (sspreadsheet.geometry_id.instance_ids_num != instance_ids.size()) {
832 return false;
833 }
834 for (const int i : instance_ids.index_range()) {
835 const SpreadsheetInstanceID &a = sspreadsheet.geometry_id.instance_ids[i];
836 const SpreadsheetInstanceID &b = instance_ids[i];
837 if (a.reference_index != b.reference_index) {
838 return false;
839 }
840 }
841 return true;
842}
843
845{
847 this->get_parent_instance_ids(instance_ids);
848
850
851 MEM_SAFE_DELETE(sspreadsheet.geometry_id.instance_ids);
852 sspreadsheet.geometry_id.instance_ids = MEM_new_array<SpreadsheetInstanceID>(instance_ids.size(),
853 __func__);
854 sspreadsheet.geometry_id.instance_ids_num = instance_ids.size();
856 instance_ids.data(), instance_ids.size(), sspreadsheet.geometry_id.instance_ids);
857
859}
860
862{
863 std::optional<GeometryDataIdentifier> data_id = this->get_geometry_data_id();
864 if (!data_id) {
865 this->foreach_item_recursive([&](const ui::AbstractTreeViewItem &item) {
866 if (data_id) {
867 return;
868 }
869 if (const auto *data_set_view_item = dynamic_cast<const DataSetViewItem *>(&item)) {
870 data_id = data_set_view_item->get_geometry_data_id();
871 }
872 });
873 if (!data_id) {
874 return;
875 }
876 }
877
878 bScreen &screen = *CTX_wm_screen(&C);
880 PointerRNA ptr = RNA_pointer_create_discrete(&screen.id, RNA_SpaceSpreadsheet, &sspreadsheet);
881
882 if (const auto *domain_data_id = std::get_if<GeometryDomainDataId>(&data_id->id)) {
885 sspreadsheet.geometry_id.geometry_component_type = uint8_t(domain_data_id->component_type);
886 if (domain_data_id->domain) {
887 sspreadsheet.geometry_id.attribute_domain = uint8_t(*domain_data_id->domain);
888 }
889 if (domain_data_id->layer_index) {
890 sspreadsheet.geometry_id.layer_index = *domain_data_id->layer_index;
891 }
892
893 /* These updates also make sure that the attribute domain is set properly based on the
894 * component type. */
895 RNA_property_update(&C, &ptr, RNA_struct_find_property(&ptr, "attribute_domain"));
896 RNA_property_update(&C, &ptr, RNA_struct_find_property(&ptr, "geometry_component_type"));
897 }
898 else if (const auto *bundle_item_id = std::get_if<GeometryBundleItemId>(&data_id->id)) {
900 Vector<nodes::BundleKey> keys = bundle_item_id->keys.as_span();
902 keys, bundle_item_id->closure_in_out, sspreadsheet.geometry_id.geometry_bundle_path);
903 RNA_property_update(&C, &ptr, RNA_struct_find_property(&ptr, "geometry_component_type"));
904 }
905}
906
907std::optional<bool> DataSetViewItem::should_be_active() const
908{
909 GeometryDataSetTreeView &tree_view = this->get_tree();
910 SpaceSpreadsheet &sspreadsheet = tree_view.sspreadsheet_;
911
912 const std::optional<GeometryDataIdentifier> data_id = this->get_geometry_data_id();
913 if (!data_id) {
914 return false;
915 }
916 if (const auto *domain_data_id = std::get_if<GeometryDomainDataId>(&data_id->id)) {
918 return false;
919 }
921 domain_data_id->component_type)
922 {
923 return false;
924 }
925 if (domain_data_id->domain) {
926 if (bke::AttrDomain(sspreadsheet.geometry_id.attribute_domain) != domain_data_id->domain) {
927 return false;
928 }
929 }
930 if (domain_data_id->layer_index) {
931 if (sspreadsheet.geometry_id.layer_index != *domain_data_id->layer_index) {
932 return false;
933 }
934 }
935 return true;
936 }
937 if (const auto *bundle_item_id = std::get_if<GeometryBundleItemId>(&data_id->id)) {
939 return false;
940 }
942 bundle_item_id->closure_in_out)
943 {
944 return false;
945 }
947 bundle_item_id->keys.size())
948 {
949 return false;
950 }
951 for (const int i : IndexRange(bundle_item_id->keys.size())) {
953 bundle_item_id->keys[i].ustr())
954 {
955 return false;
956 }
957 }
958 return true;
959 }
960 return false;
961}
962
964 private:
965 int viewer_path_index_;
966
967 public:
968 ViewerPathTreeViewItem(int viewer_path_index) : viewer_path_index_(viewer_path_index) {}
969
970 void on_activate(bContext &C) override;
971 std::optional<bool> should_be_active() const override;
972};
973
975 const IDViewerPathElem &id_elem_;
976
977 public:
978 IDViewerPathItem(const int viewer_path_index, const IDViewerPathElem &id_elem)
979 : ViewerPathTreeViewItem(viewer_path_index), id_elem_(id_elem)
980 {
981 label_ = id_elem.id ? id_elem.id->name + 2 : IFACE_("No Data-Block");
982 }
983
984 void build_row(ui::Layout &row) override
985 {
986 if (id_elem_.id) {
987 const int icon = ED_outliner_icon_from_id(*id_elem_.id);
988 row.label(BKE_id_name(*id_elem_.id), icon);
989 }
990 else {
991 row.label(IFACE_("No Data-Block"), ICON_BLANK1);
992 }
993 }
994};
995
997 const ModifierViewerPathElem &modifier_elem_;
998
999 public:
1000 ModifierViewerPathItem(const int viewer_path_index, const ModifierViewerPathElem &modifier_elem)
1001 : ViewerPathTreeViewItem(viewer_path_index), modifier_elem_(modifier_elem)
1002 {
1003 label_ = modifier_elem.base.ui_name;
1004 }
1005
1006 void build_row(ui::Layout &row) override
1007 {
1008 row.label(modifier_elem_.base.ui_name, ICON_MODIFIER);
1009 }
1010};
1011
1013 const GroupNodeViewerPathElem &group_node_elem_;
1014
1015 public:
1016 GroupNodeViewerPathItem(const int viewer_path_index,
1017 const GroupNodeViewerPathElem &group_node_elem)
1018 : ViewerPathTreeViewItem(viewer_path_index), group_node_elem_(group_node_elem)
1019 {
1020 label_ = group_node_elem.base.ui_name;
1021 }
1022
1023 void build_row(ui::Layout &row) override
1024 {
1025 row.label(group_node_elem_.base.ui_name, ICON_NODE);
1026 }
1027};
1028
1030 const ViewerNodeViewerPathElem &viewer_node_elem_;
1031
1032 public:
1033 ViewerNodeViewerPathItem(const int viewer_path_index,
1034 const ViewerNodeViewerPathElem &viewer_node_elem)
1035 : ViewerPathTreeViewItem(viewer_path_index), viewer_node_elem_(viewer_node_elem)
1036 {
1037 label_ = viewer_node_elem.base.ui_name;
1038 }
1039
1040 void build_row(ui::Layout &row) override
1041 {
1042 row.label(viewer_node_elem_.base.ui_name, ICON_RESTRICT_VIEW_OFF);
1043 }
1044};
1045
1047
1048 public:
1049 SimulationViewerPathPathItem(const int viewer_path_index,
1050 const SimulationZoneViewerPathElem & /*simulation_zone_elem*/)
1051 : ViewerPathTreeViewItem(viewer_path_index)
1052 {
1053 label_ = IFACE_("Simulation");
1054 }
1055
1056 void build_row(ui::Layout &row) override
1057 {
1058 row.label(label_, ICON_BLANK1);
1059 }
1060};
1061
1063 private:
1064 const RepeatZoneViewerPathElem &repeat_zone_;
1065
1066 public:
1067 RepeatViewerPathItem(const int viewer_path_index, const RepeatZoneViewerPathElem &repeat_zone)
1068 : ViewerPathTreeViewItem(viewer_path_index), repeat_zone_(repeat_zone)
1069 {
1070 label_ = IFACE_("Repeat");
1071 }
1072
1073 void build_row(ui::Layout &row) override
1074 {
1075 row.label(label_, ICON_BLANK1);
1076 draw_row_suffix(*this, std::to_string(repeat_zone_.iteration));
1077 }
1078};
1079
1081 private:
1082 const ForeachGeometryElementZoneViewerPathElem &foreach_geo_elem_zone_;
1083
1084 public:
1086 const int viewer_path_index,
1087 const ForeachGeometryElementZoneViewerPathElem &foreach_geo_elem_zone)
1088 : ViewerPathTreeViewItem(viewer_path_index), foreach_geo_elem_zone_(foreach_geo_elem_zone)
1089 {
1090 label_ = IFACE_("For Each Element");
1091 }
1092
1093 void build_row(ui::Layout &row) override
1094 {
1095 row.label(label_, ICON_BLANK1);
1096 draw_row_suffix(*this, std::to_string(foreach_geo_elem_zone_.index));
1097 }
1098};
1099
1101 public:
1102 EvaluteClosureViewerPathItem(const int viewer_path_index,
1103 const EvaluateClosureNodeViewerPathElem & /*evalute_closure_elem*/)
1104 : ViewerPathTreeViewItem(viewer_path_index)
1105 {
1106 label_ = IFACE_("Evaluate Closure");
1107 }
1108
1109 void build_row(ui::Layout &row) override
1110 {
1111 row.label(label_, ICON_BLANK1);
1112 }
1113};
1114
1116 private:
1117 SpaceSpreadsheet &sspreadsheet_;
1118 bScreen &screen_;
1119
1120 friend ViewerPathTreeViewItem;
1121
1122 public:
1124 : sspreadsheet_(*CTX_wm_space_spreadsheet(&C)), screen_(*CTX_wm_screen(&C))
1125 {
1126 /* This tree view contains only a flat list of items without. */
1127 is_flat_ = true;
1128 }
1129
1130 void build_tree() override
1131 {
1132 const ViewerPath &viewer_path = sspreadsheet_.geometry_id.viewer_path;
1133
1134 for (const auto [index, elem] : viewer_path.path.enumerate()) {
1135 if (&elem == viewer_path.path.first_) {
1136 /* The root item is drawn above the tree view already. */
1137 continue;
1138 }
1139 this->add_viewer_path_elem(index, elem);
1140 }
1141 }
1142
1143 void add_viewer_path_elem(const int index, const ViewerPathElem &elem)
1144 {
1145 switch (ViewerPathElemType(elem.type)) {
1148 reinterpret_cast<const IDViewerPathElem &>(elem));
1149 break;
1150 }
1153 index, reinterpret_cast<const ModifierViewerPathElem &>(elem));
1154 break;
1155 }
1158 index, reinterpret_cast<const GroupNodeViewerPathElem &>(elem));
1159 break;
1160 }
1163 index, reinterpret_cast<const ViewerNodeViewerPathElem &>(elem));
1164 break;
1165 }
1168 index, reinterpret_cast<const SimulationZoneViewerPathElem &>(elem));
1169 break;
1170 }
1173 index, reinterpret_cast<const RepeatZoneViewerPathElem &>(elem));
1174 break;
1175 }
1178 index, reinterpret_cast<const ForeachGeometryElementZoneViewerPathElem &>(elem));
1179 break;
1180 }
1183 index, reinterpret_cast<const EvaluateClosureNodeViewerPathElem &>(elem));
1184 break;
1185 }
1186 }
1187 }
1188};
1189
1191{
1192 SpaceSpreadsheet &sspreadsheet = *CTX_wm_space_spreadsheet(&C);
1193 sspreadsheet.active_viewer_path_index = viewer_path_index_;
1195}
1196
1198{
1199 /* Can use SpaceSpreadsheet.active_viewer_path_index once selection is used. */
1200 return false;
1201}
1202
1204 public:
1206 {
1208 this->foreach_parent([&](const ui::AbstractTreeViewItem &parent) {
1209 items.append(dynamic_cast<const ViewerDataTreeItem *>(&parent));
1210 });
1211 items.as_mutable_span().reverse();
1212 items.append(this);
1213 return items;
1214 }
1215
1216 void on_activate(bContext &C) override;
1217 std::optional<bool> should_be_active() const override;
1218};
1219
1224
1225 friend bool operator==(const ViewerDataPath &a, const ViewerDataPath &b) = default;
1226
1227 ViewerDataPath() = default;
1229 : viewer_item(table_id.viewer_item_identifier)
1230 {
1231 for (const auto &elem : Span(table_id.viewer_item_bundle_path.bundle_path,
1233 {
1234 const std::optional<nodes::BundleKey> key = nodes::BundleKey::from_str(elem.identifier);
1235 if (!key) {
1236 continue;
1237 }
1238 this->bundles.append(*key);
1239 }
1240 this->closure_input_output = SpreadsheetClosureInputOutput(
1241 table_id.viewer_item_bundle_path.closure_input_output);
1242 }
1243
1244 explicit ViewerDataPath(const Span<const ViewerDataTreeItem *> tree_items);
1245
1252};
1253
1255 private:
1257
1258 friend ViewerDataPath;
1259
1260 public:
1262 {
1263 label_ = std::to_string(item.identifier);
1264 }
1265
1266 void build_row(ui::Layout &row) override
1267 {
1268 row.label(item_.name, ICON_NONE);
1269 }
1270};
1271
1273 friend ViewerDataPath;
1274
1275 public:
1277 {
1278 label_ = key.ustr().ref();
1279 }
1280
1281 void build_row(ui::Layout &row) override
1282 {
1283 row.label(label_, ICON_NONE);
1284 }
1285};
1286
1288 private:
1290
1291 friend ViewerDataPath;
1292
1293 public:
1295 {
1296 label_ = in_out_ == SPREADSHEET_CLOSURE_INPUT ? IFACE_("Inputs") : IFACE_("Outputs");
1297 }
1298
1299 void build_row(ui::Layout &row) override
1300 {
1301 row.label(label_, ICON_NONE);
1302 }
1303};
1304
1306{
1307 for (const ViewerDataTreeItem *item : tree_items) {
1308 if (const auto *viewer_node_item = dynamic_cast<const ViewerNodeItem *>(item)) {
1309 this->viewer_item = viewer_node_item->item_.identifier;
1310 }
1311 else if (const auto *bundle_item = dynamic_cast<const BundleViewerTreeItem *>(item)) {
1312 if (const std::optional<nodes::BundleKey> key = nodes::BundleKey::from_str(
1313 bundle_item->label_))
1314 {
1315 this->bundles.append(*key);
1316 }
1317 }
1318 else if (const auto *bundle_item = dynamic_cast<const ClosureInOutViewerTreeItem *>(item)) {
1319 this->closure_input_output = bundle_item->in_out_;
1320 }
1321 }
1322}
1323
1325 private:
1326 SpaceSpreadsheet &sspreadsheet_;
1327
1328 friend ViewerDataTreeItem;
1329
1330 public:
1332
1333 void build_tree() override
1334 {
1336 if (!log) {
1337 return;
1338 }
1339 for (const nodes::eval_log::ViewerNodeLog::Item &item : log->items) {
1340 const bke::SocketValueVariant &value = item.value;
1341 auto &child_item = this->add_tree_item<ViewerNodeItem>(item);
1342 this->build_value(child_item, value);
1343 }
1344 }
1345
1347 {
1348 if (!value.is_single()) {
1349 return;
1350 }
1351 const GPointer single_value = value.get();
1352 if (single_value.is_type<nodes::BundlePtr>()) {
1353 const nodes::BundlePtr &bundle_ptr = *single_value.get<nodes::BundlePtr>();
1354 if (bundle_ptr) {
1355 this->build_bundle_children(parent, *bundle_ptr);
1356 }
1357 }
1358 if (single_value.is_type<nodes::ClosurePtr>()) {
1359 const nodes::ClosurePtr &closure_ptr = *single_value.get<nodes::ClosurePtr>();
1360 if (closure_ptr) {
1361 this->build_closure_children(parent, closure_ptr);
1362 }
1363 }
1364 }
1365
1367 {
1368 for (const auto &item : bundle.items()) {
1369 auto &child_item = parent.add_tree_item<BundleViewerTreeItem>(item.key);
1370 const auto *stored_value = std::get_if<nodes::BundleItemSocketValue>(&item.value.value);
1371 if (!stored_value) {
1372 continue;
1373 }
1374 this->build_value(child_item, stored_value->value);
1375 }
1376 }
1377
1379 {
1380 const nodes::ClosureSignature &signature = closure->signature();
1381 if (!signature.inputs.is_empty()) {
1383 }
1384 if (!signature.outputs.is_empty()) {
1386 }
1387 }
1388};
1389
1391{
1392 const auto &tree = static_cast<const ViewerDataTreeView &>(this->get_tree_view());
1393 SpaceSpreadsheet &sspreadsheet = tree.sspreadsheet_;
1394 SpreadsheetTableIDGeometry &table_id = sspreadsheet.geometry_id;
1395 ViewerDataPath(this->items_path()).store(table_id);
1397}
1398
1399std::optional<bool> ViewerDataTreeItem::should_be_active() const
1400{
1401 const auto &tree = static_cast<const ViewerDataTreeView &>(this->get_tree_view());
1402 const SpaceSpreadsheet &sspreadsheet = tree.sspreadsheet_;
1403 const SpreadsheetTableIDGeometry &table_id = sspreadsheet.geometry_id;
1404 return ViewerDataPath(table_id) == ViewerDataPath(this->items_path());
1405}
1406
1408{
1409 layout.label(IFACE_("No Active Context"), ICON_NONE);
1410}
1411
1413{
1414 if (viewer_path.path.is_empty()) {
1415 return false;
1416 }
1417 const ViewerPathElem &last_elem = *viewer_path.path.last();
1419}
1420
1421static void draw_viewer_path_panel(const bContext &C, ui::Layout &layout)
1422{
1423 ui::Block *block = layout.block();
1424 ui::AbstractTreeView *tree_view = block_add_view(
1425 *block, "Viewer Path", std::make_unique<ViewerPathTreeView>(C));
1426 tree_view->set_context_menu_title("Viewer Path");
1427 ui::TreeViewBuilder::build_tree_view(C, *tree_view, layout, true);
1428}
1429
1430static void draw_viewer_data_panel(const bContext &C, ui::Layout &layout)
1431{
1432 ui::Block *block = layout.block();
1433 ui::AbstractTreeView *tree_view = block_add_view(
1434 *block, "Viewer Data", std::make_unique<ViewerDataTreeView>(C));
1435 tree_view->set_context_menu_title("Viewer Data");
1436 ui::TreeViewBuilder::build_tree_view(C, *tree_view, layout, false);
1437}
1438
1440{
1441 bScreen &screen = *CTX_wm_screen(&C);
1443
1445 ID *root_id = get_current_id(sspreadsheet);
1446 if (!root_id) {
1448 return;
1449 }
1450 if (GS(root_id->name) != ID_OB) {
1452 return;
1453 }
1454
1455 PointerRNA sspreadsheet_ptr = RNA_pointer_create_discrete(
1456 &screen.id, RNA_SpaceSpreadsheet, sspreadsheet);
1457
1458 layout.prop(&sspreadsheet_ptr, "object_eval_state", UI_ITEM_NONE, "", ICON_NONE);
1459
1462 {
1463 if (ui::Layout *panel = layout.panel(&C, "viewer path", true, IFACE_("Viewer Path"))) {
1464 draw_viewer_path_panel(C, *panel);
1465 }
1466 if (ui::Layout *panel = layout.panel(&C, "viewer data", true, IFACE_("Viewer Data"))) {
1467 draw_viewer_data_panel(C, *panel);
1468 }
1469 }
1470}
1471
1472static void draw_context_panel(const bContext &C, ui::Layout &layout)
1473{
1474 SpaceSpreadsheet &sspreadsheet = *CTX_wm_space_spreadsheet(&C);
1475
1476 ui::PanelLayout context_panel = layout.panel(&C, "context", false);
1477 context_panel.header->emboss_set(ui::EmbossType::None);
1478 if (ID *root_id = get_current_id(&sspreadsheet)) {
1479 std::string label = BKE_id_name(*root_id);
1480 if (!context_panel.body) {
1481 switch (sspreadsheet.geometry_id.object_eval_state) {
1483 label += " (Evaluated)";
1484 break;
1486 label += " (Original)";
1487 break;
1489 label += " (Viewer)";
1490 break;
1491 }
1492 }
1493 context_panel.header->label(label, ICON_OBJECT_DATA);
1494 }
1495 else {
1496 context_panel.header->label(IFACE_("Context"), ICON_NONE);
1497 }
1498 context_panel.header->op("spreadsheet.toggle_pin",
1499 "",
1500 sspreadsheet.flag & SPREADSHEET_FLAG_PINNED ? ICON_PINNED :
1501 ICON_UNPINNED);
1502 if (context_panel.body) {
1503 draw_context_panel_content(C, *context_panel.body);
1504 }
1505}
1506
1508{
1510
1511 ui::Layout &layout = *panel->layout;
1512 ui::Block *block = layout.block();
1513 ui::block_layout_set_current(block, &layout);
1514
1515 draw_context_panel(*C, layout);
1516
1518 if (!object) {
1519 return;
1520 }
1521
1522 if (const std::optional<bke::GeometrySet> root_geometry = root_geometry_set_get(sspreadsheet,
1523 object))
1524 {
1525 if (ui::Layout *panel = layout.panel(C, "instance tree", false, IFACE_("Geometry"))) {
1526 ui::AbstractTreeView *tree_view = block_add_view(
1527 *block,
1528 "Instances Tree View",
1529 std::make_unique<GeometryInstancesTreeView>(*root_geometry, *C));
1530 tree_view->set_context_menu_title("Instance");
1531 ui::TreeViewBuilder::build_tree_view(*C, *tree_view, *panel, false);
1532 }
1533 if (ui::Layout *panel = layout.panel(C, "geometry_domain_tree_view", false, IFACE_("Domain")))
1534 {
1536 *root_geometry,
1537 {sspreadsheet->geometry_id.instance_ids, sspreadsheet->geometry_id.instance_ids_num});
1538 ui::AbstractTreeView *tree_view = block_add_view(
1539 *block,
1540 "Data Set Tree View",
1541 std::make_unique<GeometryDataSetTreeView>(std::move(instance_geometry), *C));
1542 tree_view->set_context_menu_title("Domain");
1543 ui::TreeViewBuilder::build_tree_view(*C, *tree_view, *panel, false);
1544 }
1545 }
1546}
1547
1548} // namespace blender::ed::spreadsheet
Low-level operations for curves.
Low-level operations for grease pencil.
Volume data-block.
#define BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE
Definition BLI_string.hh:37
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define ND_SPACE_SPREADSHEET
Definition WM_types.hh:584
#define NC_SPACE
Definition WM_types.hh:405
#define BLI_assert_unreachable()
const void * get() const
constexpr IndexRange()=default
constexpr Span()=default
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
StringRefNull ref() const
int64_t size() const
void append(const T &value)
IndexRange index_range() const
MutableSpan< T > as_mutable_span()
Span< T > as_span() const
int domain_size(const AttrDomain domain) const
AttributeAccessor attributes() const
Span< InstanceReference > references() const
Definition instances.cc:290
Span< int > reference_user_counts() const
Definition instances.cc:503
const bke::CurvesGeometry & strokes() const
constexpr bool is_empty() const
ClosureInOutViewerTreeItem(const SpreadsheetClosureInputOutput in_out)
CurvesDomainViewItem(const Curves *curves, const bke::AttrDomain domain)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
virtual std::optional< GeometryDataIdentifier > get_geometry_data_id() const
std::optional< bool > should_be_active() const override
EvaluteClosureViewerPathItem(const int viewer_path_index, const EvaluateClosureNodeViewerPathElem &)
ForeachElementViewerPathItem(const int viewer_path_index, const ForeachGeometryElementZoneViewerPathElem &foreach_geo_elem_zone)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
GeometryBundleClosureInOutViewItem(const SpreadsheetClosureInputOutput in_out)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
void build_tree_for_pointcloud(const PointCloud *pointcloud, ui::TreeViewItemContainer &parent)
void build_tree_for_grease_pencil(const GreasePencil *grease_pencil, ui::TreeViewItemContainer &parent)
void build_closure_children(const nodes::Closure &closure, ui::TreeViewItemContainer &parent)
void build_tree_for_bundle(const nodes::Bundle *bundle, ui::TreeViewItemContainer &parent)
void build_bundle_children(const nodes::Bundle &bundle, ui::TreeViewItemContainer &parent)
GeometryDataSetTreeView(bke::GeometrySet geometry_set, const bContext &C)
void build_tree_for_instances(const bke::Instances *instances, ui::TreeViewItemContainer &parent)
void build_tree_for_curves(const Curves *curves, ui::TreeViewItemContainer &parent)
void build_socket_value(const bke::SocketValueVariant &value, ui::TreeViewItemContainer &parent)
void build_tree_for_volume(const Volume *volume, ui::TreeViewItemContainer &parent)
void build_tree_for_mesh(const Mesh *mesh, ui::TreeViewItemContainer &parent)
void build_tree_for_geometry(const bke::GeometrySet &geometry, ui::TreeViewItemContainer &parent)
GeometryInstancesTreeView(bke::GeometrySet geometry_set, const bContext &C)
void build_tree_for_instances(ui::TreeViewItemContainer &parent, const bke::Instances &instances)
GreasePencilLayerCurvesDomainViewItem(const GreasePencil &grease_pencil, const int layer_index, const bke::AttrDomain domain)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
GreasePencilLayerViewItem(const GreasePencil &grease_pencil, const int layer_index)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
GroupNodeViewerPathItem(const int viewer_path_index, const GroupNodeViewerPathElem &group_node_elem)
IDViewerPathItem(const int viewer_path_index, const IDViewerPathElem &id_elem)
InstanceReferenceViewItem(const bke::Instances &instances, const int reference_index)
void get_parent_instance_ids(Vector< SpreadsheetInstanceID > &r_instance_ids) const
std::optional< bool > should_be_active() const override
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
MeshDomainViewItem(const Mesh *mesh, const bke::AttrDomain domain)
ModifierViewerPathItem(const int viewer_path_index, const ModifierViewerPathElem &modifier_elem)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
RepeatViewerPathItem(const int viewer_path_index, const RepeatZoneViewerPathElem &repeat_zone)
SimulationViewerPathPathItem(const int viewer_path_index, const SimulationZoneViewerPathElem &)
std::optional< bool > should_be_active() const override
Vector< const ViewerDataTreeItem * > items_path() const
void build_closure_children(ui::AbstractTreeViewItem &parent, const nodes::ClosurePtr &closure)
void build_bundle_children(ui::AbstractTreeViewItem &parent, const nodes::Bundle &bundle)
void build_value(ui::AbstractTreeViewItem &parent, const bke::SocketValueVariant &value)
ViewerNodeItem(const nodes::eval_log::ViewerNodeLog::Item &item)
ViewerNodeViewerPathItem(const int viewer_path_index, const ViewerNodeViewerPathElem &viewer_node_elem)
std::optional< bool > should_be_active() const override
void add_viewer_path_elem(const int index, const ViewerPathElem &elem)
std::optional< GeometryDataIdentifier > get_geometry_data_id() const override
static std::optional< BundleKey > from_str(StringRef key)
BundleItemMap::ItemIterator items() const
CustomIDVectorSet< Item, ItemKeyGetter > inputs
CustomIDVectorSet< Item, ItemKeyGetter > outputs
const ClosureSignature & signature() const
Abstract base class for defining a customizable tree-view item.
AbstractTreeView & get_tree_view() const
Definition tree_view.cc:775
ui::ButtonViewItem * view_item_button() const
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)
ItemT & add_tree_item(Args &&...args)
void foreach_item_recursive(ItemIterFn iter_fn, IterOptions options=IterOptions::None) const
Definition tree_view.cc:67
void foreach_parent(ItemIterFn iter_fn) const
Definition tree_view.cc:87
#define str(s)
#define layer
#define log
static StringRefNull mesh_domain_to_label(const bke::AttrDomain domain)
static void draw_count(ui::AbstractTreeViewItem &view_item, const int count)
void spreadsheet_data_set_panel_draw(const bContext *C, Panel *panel)
static void draw_context_panel_without_context(ui::Layout &layout)
static StringRefNull curves_domain_to_label(const bke::AttrDomain domain)
bke::GeometrySet get_geometry_set_for_instance_ids(const bke::GeometrySet &root_geometry, const Span< SpreadsheetInstanceID > instance_ids)
static void draw_viewer_path_panel(const bContext &C, ui::Layout &layout)
static void draw_context_panel(const bContext &C, ui::Layout &layout)
static void draw_row_suffix(ui::AbstractTreeViewItem &view_item, const StringRefNull str)
int get_instance_reference_icon(const bke::InstanceReference &reference)
void spreadsheet_bundle_path_init_from(const Span< nodes::BundleKey > keys, const std::optional< SpreadsheetClosureInputOutput > closure_input_output, SpreadsheetBundleTreeViewPath &r_bundle_path)
void spreadsheet_bundle_path_clear(SpreadsheetBundleTreeViewPath &bundle_path)
const nodes::eval_log::ViewerNodeLog * viewer_node_log_lookup(const SpaceSpreadsheet &sspreadsheet)
static void draw_viewer_data_panel(const bContext &C, ui::Layout &layout)
Object * spreadsheet_get_object_eval(const SpaceSpreadsheet *sspreadsheet, const Depsgraph *depsgraph)
ID * get_current_id(const SpaceSpreadsheet *sspreadsheet)
static void draw_context_panel_content(const bContext &C, ui::Layout &layout)
static bool viewer_path_ends_with_viewer_node(const ViewerPath &viewer_path)
std::optional< bke::GeometrySet > root_geometry_set_get(const SpaceSpreadsheet *sspreadsheet, Object *object_eval)
static BIFIconID curves_domain_to_icon(const bke::AttrDomain domain)
static BIFIconID mesh_domain_to_icon(const bke::AttrDomain domain)
ImplicitSharingPtr< Closure > ClosurePtr
ImplicitSharingPtr< Bundle > BundlePtr
void block_layout_set_current(Block *block, Layout *layout)
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BLI_str_format_decimal_unit(char dst[BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void RNA_property_update(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
int BKE_volume_num_grids(const Volume *volume)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
@ SPREADSHEET_OBJECT_EVAL_STATE_VIEWER_NODE
@ SPREADSHEET_OBJECT_EVAL_STATE_ORIGINAL
@ SPREADSHEET_OBJECT_EVAL_STATE_EVALUATED
@ SPREADSHEET_FLAG_PINNED
const char * BKE_id_name(const ID &id)
@ SPREADSHEET_GEOMETRY_ITEM_TYPE_DOMAIN
@ SPREADSHEET_GEOMETRY_ITEM_TYPE_BUNDLE
unsigned char uint8_t
Definition BKE_text.h:79
@ VIEWER_PATH_ELEM_TYPE_REPEAT_ZONE
@ VIEWER_PATH_ELEM_TYPE_SIMULATION_ZONE
@ VIEWER_PATH_ELEM_TYPE_GROUP_NODE
@ VIEWER_PATH_ELEM_TYPE_VIEWER_NODE
@ VIEWER_PATH_ELEM_TYPE_EVALUATE_CLOSURE
@ VIEWER_PATH_ELEM_TYPE_FOREACH_GEOMETRY_ELEMENT_ZONE
int ED_outliner_icon_from_id(const ID &id)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
SpreadsheetClosureInputOutput
@ SPREADSHEET_CLOSURE_OUTPUT
@ SPREADSHEET_CLOSURE_NONE
@ SPREADSHEET_CLOSURE_INPUT
int BIFIconID
Definition ED_asset.hh:30
ID_Type GS(const char *name)
Definition DNA_ID.h:410
bScreen * CTX_wm_screen(const bContext *C)
SpaceSpreadsheet * CTX_wm_space_spreadsheet(const bContext *C)
void initialized_copy_n(const T *src, int64_t n, T *dst)
char name[258]
Definition DNA_ID.h:433
ui::Layout * layout
SpreadsheetTableIDGeometry geometry_id
SpreadsheetClosureInputOutput closure_input_output
SpreadsheetBundlePathElem * bundle_path
SpreadsheetGeometryItemType geometry_item_type
SpreadsheetBundleTreeViewPath viewer_item_bundle_path
SpreadsheetBundleTreeViewPath geometry_bundle_path
const Instances * get_instances() const
std::variant< GeometryDomainDataId, GeometryBundleItemId > id
GeometryDataIdentifier(bke::GeometryComponent::Type component_type, std::optional< int > layer_index, std::optional< bke::AttrDomain > domain)
GeometryDataIdentifier(Vector< nodes::BundleKey > bundle_keys, SpreadsheetClosureInputOutput closure_in_out)
ViewerDataPath(const SpreadsheetTableIDGeometry &table_id)
friend bool operator==(const ViewerDataPath &a, const ViewerDataPath &b)=default
void store(SpreadsheetTableIDGeometry &table_id)
void label(StringRef name, int icon)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
PanelLayout panel(const bContext *C, StringRef idname, bool default_closed)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void active_set(bool active)
void emboss_set(EmbossType emboss)