Blender V5.3
space_spreadsheet.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 <cstring>
6#include <fmt/format.h>
7
8#include "BLI_listbase.hh"
9#include "BLI_string.hh"
10#include "BLI_string_utf8.hh"
11
12#include "BKE_screen.hh"
13#include "BKE_viewer_path.hh"
14
15#include "ED_screen.hh"
16#include "ED_space_api.hh"
17#include "ED_spreadsheet.hh"
18#include "ED_viewer_path.hh"
19
20#include "DNA_scene_types.h"
21#include "DNA_screen_types.h"
22#include "DNA_space_types.h"
23
24#include "MEM_guardedalloc.h"
25
26#include "UI_interface.hh"
28#include "UI_resources.hh"
29#include "UI_view2d.hh"
30
31#include "BLO_read_write.hh"
32
34
35#include "WM_api.hh"
36#include "WM_types.hh"
37
38#include "BLT_translation.hh"
39
40#include "BLF_api.hh"
41
42#include "spreadsheet_column.hh"
44#include "spreadsheet_intern.hh"
45#include "spreadsheet_layout.hh"
48#include "spreadsheet_table.hh"
49
50#include <sstream>
51
53
54static SpaceLink *spreadsheet_create(const ScrArea * /*area*/, const Scene * /*scene*/)
55{
56 SpaceSpreadsheet *spreadsheet_space = MEM_new<SpaceSpreadsheet>("spreadsheet space");
57 spreadsheet_space->runtime = MEM_new<SpaceSpreadsheet_Runtime>(__func__);
58 spreadsheet_space->spacetype = SPACE_SPREADSHEET;
59
61 spreadsheet_space->filter_flag = SPREADSHEET_FILTER_ENABLE;
62
63 {
64 /* Header. */
65 ARegion *region = BKE_area_region_new();
66 BLI_addtail(&spreadsheet_space->regionbase, region);
69 }
70
71 {
72 /* Footer. */
73 ARegion *region = BKE_area_region_new();
74 BLI_addtail(&spreadsheet_space->regionbase, region);
77 }
78
79 {
80 /* Dataset Region */
81 ARegion *region = BKE_area_region_new();
82 BLI_addtail(&spreadsheet_space->regionbase, region);
83 region->regiontype = RGN_TYPE_TOOLS;
84 region->alignment = RGN_ALIGN_LEFT;
85 }
86
87 {
88 /* Properties region. */
89 ARegion *region = BKE_area_region_new();
90 BLI_addtail(&spreadsheet_space->regionbase, region);
91 region->regiontype = RGN_TYPE_UI;
92 region->alignment = RGN_ALIGN_RIGHT;
93 region->flag = RGN_FLAG_HIDDEN;
94 }
95
96 {
97 /* Main window. */
98 ARegion *region = BKE_area_region_new();
99 BLI_addtail(&spreadsheet_space->regionbase, region);
100 region->regiontype = RGN_TYPE_WINDOW;
101 }
102
103 return reinterpret_cast<SpaceLink *>(spreadsheet_space);
104}
105
107{
108 SpaceSpreadsheet *sspreadsheet = reinterpret_cast<SpaceSpreadsheet *>(sl);
109
110 MEM_delete(sspreadsheet->runtime);
111
112 for (SpreadsheetRowFilter &row_filter : sspreadsheet->row_filters.items_mutable()) {
113 spreadsheet_row_filter_free(&row_filter);
114 }
115 for (const int i : IndexRange(sspreadsheet->num_tables)) {
116 spreadsheet_table_free(sspreadsheet->tables[i]);
117 }
118 MEM_SAFE_DELETE(sspreadsheet->tables);
120}
121
122static void spreadsheet_init(wmWindowManager * /*wm*/, ScrArea * /*area*/) {}
123
125{
126 const SpaceSpreadsheet *sspreadsheet_old = reinterpret_cast<SpaceSpreadsheet *>(sl);
127 SpaceSpreadsheet *sspreadsheet_new = static_cast<SpaceSpreadsheet *>(
128 MEM_dupalloc(sspreadsheet_old));
129 sspreadsheet_new->runtime = MEM_new<SpaceSpreadsheet_Runtime>(__func__,
130 *sspreadsheet_old->runtime);
131
132 sspreadsheet_new->row_filters.clear_no_delete();
133 for (const SpreadsheetRowFilter &src_filter : sspreadsheet_old->row_filters) {
134 SpreadsheetRowFilter *new_filter = spreadsheet_row_filter_copy(&src_filter);
135 BLI_addtail(&sspreadsheet_new->row_filters, new_filter);
136 }
137 sspreadsheet_new->num_tables = sspreadsheet_old->num_tables;
138 sspreadsheet_new->tables = MEM_new_array_zeroed<SpreadsheetTable *>(sspreadsheet_old->num_tables,
139 __func__);
140 for (const int i : IndexRange(sspreadsheet_old->num_tables)) {
141 sspreadsheet_new->tables[i] = spreadsheet_table_copy(*sspreadsheet_old->tables[i]);
142 }
143
145 sspreadsheet_old->geometry_id);
146 return reinterpret_cast<SpaceLink *>(sspreadsheet_new);
147}
148
149static void spreadsheet_keymap(wmKeyConfig *keyconf)
150{
151 /* Entire editor only. */
152 WM_keymap_ensure(keyconf, "Spreadsheet Generic", SPACE_SPREADSHEET, RGN_TYPE_WINDOW);
153}
154
155static void spreadsheet_id_remap(ScrArea * /*area*/,
156 SpaceLink *slink,
157 const bke::id::IDRemapper &mappings)
158{
159 SpaceSpreadsheet *sspreadsheet = reinterpret_cast<SpaceSpreadsheet *>(slink);
160 spreadsheet_table_id_remap_id(sspreadsheet->geometry_id.base, mappings);
161 for (const int i : IndexRange(sspreadsheet->num_tables)) {
162 spreadsheet_table_remap_id(*sspreadsheet->tables[i], mappings);
163 }
164}
165
167{
168 SpaceSpreadsheet *sspreadsheet = reinterpret_cast<SpaceSpreadsheet *>(space_link);
170 for (const int i : IndexRange(sspreadsheet->num_tables)) {
171 spreadsheet_table_foreach_id(*sspreadsheet->tables[i], data);
172 }
173}
174
176{
182 region->v2d.minzoom = region->v2d.maxzoom = 1.0f;
183
184 view2d_region_reinit(&region->v2d, ui::V2D_COMMONVIEW_LIST, region->winx, region->winy);
185
187
188 {
189 wmKeyMap *keymap = WM_keymap_ensure(
190 wm->runtime->defaultconf, "View2D Buttons List", SPACE_EMPTY, RGN_TYPE_WINDOW);
192 }
193 {
194 wmKeyMap *keymap = WM_keymap_ensure(
195 wm->runtime->defaultconf, "Spreadsheet Generic", SPACE_SPREADSHEET, RGN_TYPE_WINDOW);
197 }
198}
199
200ID *get_current_id(const SpaceSpreadsheet *sspreadsheet)
201{
202 if (sspreadsheet->geometry_id.viewer_path.path.is_empty()) {
203 return nullptr;
204 }
205 ViewerPathElem *root_context = static_cast<ViewerPathElem *>(
206 sspreadsheet->geometry_id.viewer_path.path.first_);
207 if (root_context->type != VIEWER_PATH_ELEM_TYPE_ID) {
208 return nullptr;
209 }
210 IDViewerPathElem *id_elem = reinterpret_cast<IDViewerPathElem *>(root_context);
211 return id_elem->id;
212}
213
214static void view_active_object(const bContext *C, SpaceSpreadsheet *sspreadsheet)
215{
218 if (ob == nullptr) {
219 return;
220 }
222 id_elem->id = &ob->id;
223 BLI_addtail(&sspreadsheet->geometry_id.viewer_path.path, id_elem);
225}
226
228{
230
232 Object *active_object = CTX_data_active_object(C);
234 sspreadsheet->geometry_id.viewer_path);
238 if (sspreadsheet->flag & SPREADSHEET_FLAG_PINNED) {
239 if (context_object == nullptr) {
240 /* Object is not available anymore, so clear the pinning. */
241 sspreadsheet->flag &= ~SPREADSHEET_FLAG_PINNED;
242 }
243 else {
244 /* The object is still pinned, do nothing. */
245 break;
246 }
247 }
248 else {
249 if (active_object != context_object) {
250 /* The active object has changed, so view the new active object. */
251 view_active_object(C, sspreadsheet);
252 }
253 else {
254 /* Nothing changed. */
255 break;
256 }
257 }
258 break;
259 }
261 WorkSpace *workspace = CTX_wm_workspace(C);
262 if (sspreadsheet->flag & SPREADSHEET_FLAG_PINNED) {
263 const std::optional<ViewerPathForGeometryNodesViewer> parsed_path =
265 if (parsed_path.has_value()) {
267 /* The pinned path is still valid, do nothing. */
268 break;
269 }
270 /* The pinned path does not exist anymore, clear pinning. */
271 sspreadsheet->flag &= ~SPREADSHEET_FLAG_PINNED;
272 }
273 else {
274 /* Unknown pinned path, clear pinning. */
275 sspreadsheet->flag &= ~SPREADSHEET_FLAG_PINNED;
276 }
277 }
278 /* Now try to update the viewer path from the workspace. */
279 const std::optional<ViewerPathForGeometryNodesViewer> workspace_parsed_path =
281 if (workspace_parsed_path.has_value()) {
283 &workspace->viewer_path,
285 {
286 /* Nothing changed. */
287 break;
288 }
289 /* Update the viewer path from the workspace. */
291 BKE_viewer_path_copy(&sspreadsheet->geometry_id.viewer_path, &workspace->viewer_path);
292 }
293 else {
294 /* No active viewer node, change back to showing evaluated active object. */
296 view_active_object(C, sspreadsheet);
297 }
298
299 break;
300 }
301 }
302}
303
305 const Depsgraph *depsgraph)
306{
307 ID *used_id = get_current_id(sspreadsheet);
308 if (used_id == nullptr) {
309 return nullptr;
310 }
311 const ID_Type id_type = GS(used_id->name);
312 if (id_type != ID_OB) {
313 return nullptr;
314 }
315 Object *object_orig = id_cast<Object *>(used_id);
316 if (!ELEM(object_orig->type,
317 OB_EMPTY,
318 OB_MESH,
320 OB_VOLUME,
322 OB_FONT,
323 OB_CURVES,
325 {
326 return nullptr;
327 }
328
329 Object *object_eval = DEG_get_evaluated(depsgraph, object_orig);
330 if (object_eval == nullptr) {
331 return nullptr;
332 }
333
334 return object_eval;
335}
336
337std::unique_ptr<DataSource> get_data_source(const bContext &C)
338{
339 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(&C);
341
342 Object *object_eval = spreadsheet_get_object_eval(sspreadsheet, depsgraph);
343 if (object_eval) {
344 return data_source_from_geometry(&C, object_eval);
345 }
346 return {};
347}
348
350{
351 return &sspreadsheet.geometry_id.base;
352}
353
355{
356 return const_cast<SpreadsheetTable *>(
357 get_active_table(const_cast<const SpaceSpreadsheet &>(sspreadsheet)));
358}
359
361{
362 const SpreadsheetTableID *active_table_id = get_active_table_id(sspreadsheet);
363 if (!active_table_id) {
364 return nullptr;
365 }
366 return spreadsheet_table_find(sspreadsheet, *active_table_id);
367}
368
369static int get_index_column_width(const int tot_rows)
370{
371 const int fontid = BLF_default();
372 BLF_size(fontid, ui::style_get_dpi()->widget.points * UI_SCALE_FAC);
373 return std::to_string(std::max(0, tot_rows - 1)).size() * BLF_width(fontid, "0", 1) +
374 UI_UNIT_X * 0.75;
375}
376
377static void update_visible_columns(SpreadsheetTable &table, DataSource &data_source)
378{
381 for (SpreadsheetColumn *column : Span{table.columns, table.num_columns}) {
382 if (handled_columns.add(*column->id)) {
383 const bool has_data = data_source.get_column_values(*column->id) != nullptr;
385 new_columns.append(column);
386 }
387 }
388
389 data_source.foreach_default_column_ids(
390 [&](const SpreadsheetColumnID &column_id, const bool is_extra) {
391 if (handled_columns.contains(column_id)) {
392 return;
393 }
394 std::unique_ptr<ColumnValues> values = data_source.get_column_values(column_id);
395 if (!values) {
396 return;
397 }
398 table.column_use_clock++;
400 if (is_extra) {
401 new_columns.insert(0, column);
402 }
403 else {
404 new_columns.append(column);
405 }
406 handled_columns.add(*column->id);
407 });
408
409 if (Span(table.columns, table.num_columns) == new_columns.as_span()) {
410 /* Nothing changed. */
411 return;
412 }
413
414 /* Update last used times of the columns to support garbage collection. */
415 for (SpreadsheetColumn *column : new_columns) {
416 const bool clock_was_reset = table.column_use_clock < column->last_used;
417 if (clock_was_reset || column->is_available()) {
418 column->last_used = table.column_use_clock;
419 }
420 }
421
422 /* Update the stored column pointers. */
423 MEM_SAFE_DELETE(table.columns);
424 table.columns = MEM_new_array_zeroed<SpreadsheetColumn *>(new_columns.size(), __func__);
425 table.num_columns = new_columns.size();
426 std::copy_n(new_columns.begin(), new_columns.size(), table.columns);
427
428 /* Remove columns that have not been used for a while when there are too many. */
430}
431
432static void spreadsheet_main_region_draw(const bContext *C, ARegion *region)
433{
436
437 std::unique_ptr<DataSource> data_source = get_data_source(*C);
438 if (!data_source) {
439 data_source = std::make_unique<DataSource>();
440 }
441
442 const SpreadsheetTableID *active_table_id = get_active_table_id(*sspreadsheet);
443 SpreadsheetTable *table = spreadsheet_table_find(*sspreadsheet, *active_table_id);
444 if (!table) {
445 spreadsheet_table_remove_unused(*sspreadsheet);
446 table = spreadsheet_table_new(spreadsheet_table_id_copy(*active_table_id));
447 spreadsheet_table_add(*sspreadsheet, table);
448 }
449 if (table) {
450 /* Move to the front of the tables list to make it cheaper to find the table in future. */
451 spreadsheet_table_move_to_front(*sspreadsheet, *table);
452 }
453
454 /* Update the last used time on the table. */
455 if (table->last_used < sspreadsheet->table_use_clock || sspreadsheet->table_use_clock == 0) {
456 sspreadsheet->table_use_clock++;
457 /* Handle clock overflow by just resetting all clocks. */
458 if (sspreadsheet->table_use_clock == 0) {
459 for (SpreadsheetTable *table : Span(sspreadsheet->tables, sspreadsheet->num_tables)) {
460 table->last_used = sspreadsheet->table_use_clock;
461 }
462 }
463 table->last_used = sspreadsheet->table_use_clock;
464 }
465
466 update_visible_columns(*table, *data_source);
467
468 SpreadsheetLayout spreadsheet_layout;
469 ResourceScope scope;
470
471 const int tot_rows = data_source->tot_rows();
472 spreadsheet_layout.index_column_width = get_index_column_width(tot_rows);
473
474 int x = spreadsheet_layout.index_column_width;
475
476 for (SpreadsheetColumn *column : Span{table->columns, table->num_columns}) {
477 std::unique_ptr<ColumnValues> values_ptr = data_source->get_column_values(*column->id);
478 if (!values_ptr) {
479 continue;
480 }
481 const ColumnValues *values = scope.add(std::move(values_ptr));
482 const eSpreadsheetColumnValueType column_type = values->type();
483
484 if (column->width <= 0.0f ||
485 !ELEM(column_type, column->data_type, SPREADSHEET_VALUE_TYPE_UNKNOWN))
486 {
487 column->width = values->fit_column_width_px(100) / SPREADSHEET_WIDTH_UNIT;
488 }
489 const int width_in_pixels = column->width * SPREADSHEET_WIDTH_UNIT;
490 spreadsheet_layout.columns.append({values, width_in_pixels});
491
492 column->runtime->left_x = x;
493 x += width_in_pixels;
494 column->runtime->right_x = x;
495
496 spreadsheet_column_assign_runtime_data(column, column_type, values->name());
497 }
498
499 spreadsheet_layout.row_indices = spreadsheet_filter_rows(
500 *sspreadsheet, spreadsheet_layout, *data_source, scope);
501
502 sspreadsheet->runtime->tot_columns = spreadsheet_layout.columns.size();
503 sspreadsheet->runtime->tot_rows = tot_rows;
504 sspreadsheet->runtime->visible_rows = spreadsheet_layout.row_indices.size();
505
506 std::unique_ptr<SpreadsheetDrawer> drawer = spreadsheet_drawer_from_layout(spreadsheet_layout);
507 draw_spreadsheet_in_region(C, region, *drawer);
508
509 sspreadsheet->runtime->top_row_height = drawer->top_row_height;
510 sspreadsheet->runtime->left_column_width = drawer->left_column_width;
511
512 rcti mask;
514 mask.xmin += sspreadsheet->runtime->left_column_width;
515 mask.ymax -= sspreadsheet->runtime->top_row_height;
517
518 /* Tag other regions for redraw, because the main region updates data for them. */
520 ED_region_tag_redraw(footer);
522 ED_region_tag_redraw(sidebar);
523}
524
526{
527 ARegion *region = params->region;
528 const wmNotifier *wmn = params->notifier;
529 SpaceSpreadsheet *sspreadsheet = params->area->spacedata.first_as<SpaceSpreadsheet>();
530
531 switch (wmn->category) {
532 case NC_SCENE: {
533 switch (wmn->data) {
534 case ND_MODE:
535 case ND_FRAME:
536 case ND_OB_ACTIVE: {
537 ED_region_tag_redraw(region);
538 break;
539 }
540 }
541 break;
542 }
543 case NC_ID: {
544 if (wmn->action == NA_RENAME) {
545 ED_region_tag_redraw(region);
546 }
547 break;
548 }
549 case NC_OBJECT: {
550 ED_region_tag_redraw(region);
551 break;
552 }
553 case NC_SPACE: {
554 if (wmn->data == ND_SPACE_SPREADSHEET) {
555 ED_region_tag_redraw(region);
556 }
557 break;
558 }
559 case NC_TEXTURE:
560 case NC_GEOM: {
561 ED_region_tag_redraw(region);
562 break;
563 }
564 case NC_GPENCIL: {
565 ED_region_tag_redraw(region);
566 break;
567 }
568 case NC_VIEWER_PATH: {
570 {
571 ED_region_tag_redraw(region);
572 }
573 break;
574 }
575 }
576}
577
579{
580 ED_region_header_init(region);
581}
582
584{
586 ED_region_header(C, region);
587}
588
589static void spreadsheet_header_region_free(ARegion * /*region*/) {}
590
592{
593 ARegion *region = params->region;
594 const wmNotifier *wmn = params->notifier;
595 SpaceSpreadsheet *sspreadsheet = params->area->spacedata.first_as<SpaceSpreadsheet>();
596
597 switch (wmn->category) {
598 case NC_SCENE: {
599 switch (wmn->data) {
600 case ND_MODE:
601 case ND_OB_ACTIVE: {
602 ED_region_tag_redraw(region);
603 break;
604 }
605 }
606 break;
607 }
608 case NC_OBJECT: {
609 ED_region_tag_redraw(region);
610 break;
611 }
612 case NC_SPACE: {
613 if (wmn->data == ND_SPACE_SPREADSHEET) {
614 ED_region_tag_redraw(region);
615 }
616 break;
617 }
618 case NC_GEOM: {
619 ED_region_tag_redraw(region);
620 break;
621 }
622 case NC_GPENCIL: {
623 ED_region_tag_redraw(region);
624 break;
625 }
626 case NC_VIEWER_PATH: {
628 {
629 ED_region_tag_redraw(region);
630 }
631 break;
632 }
633 }
634}
635
637{
638 ED_region_header_init(region);
639}
640
642{
644 SpaceSpreadsheet_Runtime *runtime = sspreadsheet->runtime;
645 std::stringstream ss;
646 ss << IFACE_("Rows:") << " ";
647 if (runtime->visible_rows != runtime->tot_rows) {
648 char visible_rows_str[BLI_STR_FORMAT_INT32_GROUPED_SIZE];
649 BLI_str_format_int_grouped(visible_rows_str, runtime->visible_rows);
650 ss << visible_rows_str << " / ";
651 }
652 char tot_rows_str[BLI_STR_FORMAT_INT32_GROUPED_SIZE];
653 BLI_str_format_int_grouped(tot_rows_str, runtime->tot_rows);
654 ss << tot_rows_str << " | " << IFACE_("Columns:") << " " << runtime->tot_columns;
655 std::string stats_str = ss.str();
656
658
659 ui::Block *block = block_begin(C, region, __func__, ui::EmbossType::Emboss);
660 const uiStyle *style = ui::style_get_dpi();
661 ui::Layout &layout = ui::block_layout(block,
665 region->winy - (region->winy - UI_UNIT_Y) / 2.0f,
666 region->winx,
667 1,
668 0,
669 style);
670 layout.separator_spacer();
672 layout.label(stats_str, ICON_NONE);
674 block_align_end(block);
675 block_end(C, block);
676 block_draw(C, block);
677}
678
679static void spreadsheet_footer_region_free(ARegion * /*region*/) {}
680
682
684{
685 ARegion *region = params->region;
686 const wmNotifier *wmn = params->notifier;
687
688 switch (wmn->category) {
689 case NC_SCENE: {
690 switch (wmn->data) {
691 case ND_FRAME:
692 ED_region_tag_redraw(region);
693 break;
694 }
695 break;
696 }
697 case NC_TEXTURE:
698 ED_region_tag_redraw(region);
699 break;
700 }
701
703}
704
706{
708 ED_region_panels(C, region);
709}
710
712{
713 ui::panel_category_active_set_default(region, "Filters");
714 ED_region_panels_init(wm, region);
715
716 wmKeyMap *keymap = WM_keymap_ensure(
717 wm->runtime->defaultconf, "Spreadsheet Generic", SPACE_SPREADSHEET, RGN_TYPE_WINDOW);
719}
720
721static void spreadsheet_right_region_free(ARegion * /*region*/) {}
722
724
726{
727 SpaceSpreadsheet *sspreadsheet = reinterpret_cast<SpaceSpreadsheet *>(sl);
728
729 sspreadsheet->runtime = MEM_new<SpaceSpreadsheet_Runtime>(__func__);
731 for (SpreadsheetRowFilter &row_filter : sspreadsheet->row_filters) {
732 BLO_read_string(reader, &row_filter.value_string);
733 }
734
736 reader, &sspreadsheet->tables, &sspreadsheet->num_tables);
737 for (const int i : IndexRange(sspreadsheet->num_tables)) {
738 BLO_read_struct(reader, SpreadsheetTable, &sspreadsheet->tables[i]);
739 spreadsheet_table_blend_read(reader, sspreadsheet->tables[i]);
740 }
741
742 spreadsheet_table_id_blend_read(reader, &sspreadsheet->geometry_id.base);
743}
744
746{
748 sl, [](BlendStructWriter<SpaceSpreadsheet> &struct_writer) {
749 struct_writer.shallow_data.runtime = nullptr;
750 });
751 SpaceSpreadsheet *sspreadsheet = reinterpret_cast<SpaceSpreadsheet *>(sl);
752
753 for (SpreadsheetRowFilter &row_filter : sspreadsheet->row_filters) {
754 writer->write_struct(&row_filter);
755 writer->write_string(row_filter.value_string);
756 }
757
758 writer->write_pointer_array(sspreadsheet->num_tables, sspreadsheet->tables);
759 for (const int i : IndexRange(sspreadsheet->num_tables)) {
760 spreadsheet_table_blend_write(writer, sspreadsheet->tables[i]);
761 }
762
763 spreadsheet_table_id_blend_write_content_geometry(writer, &sspreadsheet->geometry_id);
764}
765
766static void spreadsheet_cursor(wmWindow *win, ScrArea *area, ARegion *region)
767{
768 SpaceSpreadsheet &sspreadsheet = *area->spacedata.first_as<SpaceSpreadsheet>();
769
770 const int2 cursor_re{win->runtime->eventstate->xy[0] - region->winrct.xmin,
771 win->runtime->eventstate->xy[1] - region->winrct.ymin};
772 if (find_hovered_column_header_edge(sspreadsheet, *region, cursor_re)) {
774 return;
775 }
776 if (find_hovered_column_header(sspreadsheet, *region, cursor_re)) {
778 return;
779 }
781}
782
784{
785 std::unique_ptr<SpaceType> st = std::make_unique<SpaceType>();
786 ARegionType *art;
787
788 st->spaceid = SPACE_SPREADSHEET;
789 STRNCPY_UTF8(st->name, "Spreadsheet");
790 st->struct_size = sizeof(SpaceSpreadsheet);
791
792 st->create = spreadsheet_create;
793 st->free = spreadsheet_free;
794 st->init = spreadsheet_init;
795 st->duplicate = spreadsheet_duplicate;
796 st->operatortypes = spreadsheet_operatortypes;
797 st->keymap = spreadsheet_keymap;
798 st->id_remap = spreadsheet_id_remap;
799 st->foreach_id = spreadsheet_foreach_id;
800 st->blend_read_data = spreadsheet_blend_read_data;
801 st->blend_read_after_liblink = nullptr;
802 st->blend_write = spreadsheet_blend_write;
803
804 /* regions: main window */
805 art = MEM_new_zeroed<ARegionType>("spacetype spreadsheet region");
809
814 art->event_cursor = true;
815 BLI_addhead(&st->regiontypes, art);
816
817 /* regions: header */
818 art = MEM_new_zeroed<ARegionType>("spacetype spreadsheet header region");
820 art->prefsizey = HEADERY;
821 art->keymapflag = 0;
824
829 BLI_addhead(&st->regiontypes, art);
830
831 /* regions: footer */
832 art = MEM_new_zeroed<ARegionType>("spacetype spreadsheet footer region");
834 art->prefsizey = HEADERY;
835 art->keymapflag = 0;
838
843 BLI_addhead(&st->regiontypes, art);
844
845 /* regions: right panel buttons */
846 art = MEM_new_zeroed<ARegionType>("spacetype spreadsheet right region");
847 art->regionid = RGN_TYPE_UI;
852
858 BLI_addhead(&st->regiontypes, art);
859
861
862 /* regions: channels */
863 art = MEM_new_zeroed<ARegionType>("spreadsheet dataset region");
865 art->prefsizex = 150 + V2D_SCROLL_WIDTH;
872 BLI_addhead(&st->regiontypes, art);
873
874 BKE_spacetype_register(std::move(st));
875}
876
877} // namespace blender::ed::spreadsheet
#define BLI_STR_FORMAT_INT32_GROUPED_SIZE
Definition BLI_string.hh:28
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define IFACE_(msgid)
#define HEADERY
#define SPREADSHEET_WIDTH_UNIT
#define UI_SCALE_FAC
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_UNIT_Y
#define UI_SIDEBAR_PANEL_WIDTH
#define UI_HEADER_OFFSET
#define UI_UNIT_X
#define V2D_SCROLL_WIDTH
Definition UI_view2d.hh:79
#define NC_ID
Definition WM_types.hh:408
#define NC_GEOM
Definition WM_types.hh:406
#define ND_OB_ACTIVE
Definition WM_types.hh:459
#define NC_VIEWER_PATH
Definition WM_types.hh:419
#define ND_MODE
Definition WM_types.hh:464
#define NC_SCENE
Definition WM_types.hh:391
#define ND_FRAME
Definition WM_types.hh:453
#define NC_GPENCIL
Definition WM_types.hh:412
#define NC_TEXTURE
Definition WM_types.hh:394
#define NA_RENAME
Definition WM_types.hh:638
#define ND_SPACE_SPREADSHEET
Definition WM_types.hh:584
#define NC_OBJECT
Definition WM_types.hh:392
#define NC_SPACE
Definition WM_types.hh:405
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
constexpr IndexRange()=default
T * add(std::unique_ptr< T > resource)
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
constexpr Span()=default
int64_t size() const
void append(const T &value)
void insert(const int64_t insert_index, const T &value)
Span< T > as_span() const
eSpreadsheetColumnValueType type() const
float fit_column_width_px(const std::optional< int64_t > &max_sample_size=std::nullopt) const
virtual void foreach_default_column_ids(FunctionRef< void(const SpreadsheetColumnID &, bool is_extra)>) const
virtual std::unique_ptr< ColumnValues > get_column_values(const SpreadsheetColumnID &) const
SpreadsheetColumn * spreadsheet_column_new(SpreadsheetColumnID *column_id)
static void spreadsheet_header_region_free(ARegion *)
static void spreadsheet_init(wmWindowManager *, ScrArea *)
static void spreadsheet_foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
static void spreadsheet_free(SpaceLink *sl)
const SpreadsheetTableID * get_active_table_id(const SpaceSpreadsheet &sspreadsheet)
void spreadsheet_table_move_to_front(SpaceSpreadsheet &sspreadsheet, SpreadsheetTable &table)
static void spreadsheet_header_region_init(wmWindowManager *, ARegion *region)
void spreadsheet_table_blend_write(BlendWriter *writer, const SpreadsheetTable *table)
IndexMask spreadsheet_filter_rows(const SpaceSpreadsheet &sspreadsheet, const SpreadsheetLayout &spreadsheet_layout, const DataSource &data_source, ResourceScope &scope)
void draw_spreadsheet_in_region(const bContext *C, ARegion *region, const SpreadsheetDrawer &drawer)
void spreadsheet_table_blend_read(BlendDataReader *reader, SpreadsheetTable *table)
SpreadsheetRowFilter * spreadsheet_row_filter_copy(const SpreadsheetRowFilter *src_row_filter)
static void spreadsheet_footer_region_free(ARegion *)
static void spreadsheet_right_region_free(ARegion *)
static SpaceLink * spreadsheet_create(const ScrArea *, const Scene *)
static void spreadsheet_sidebar_init(wmWindowManager *wm, ARegion *region)
static void spreadsheet_keymap(wmKeyConfig *keyconf)
static void update_visible_columns(SpreadsheetTable &table, DataSource &data_source)
void spreadsheet_table_remove_unused(SpaceSpreadsheet &sspreadsheet)
void spreadsheet_table_id_free_content(SpreadsheetTableID *table_id)
std::unique_ptr< DataSource > data_source_from_geometry(const bContext *C, Object *object_eval)
static SpaceLink * spreadsheet_duplicate(SpaceLink *sl)
SpreadsheetTableID * spreadsheet_table_id_copy(const SpreadsheetTableID &src_table_id)
void spreadsheet_table_id_copy_content_geometry(SpreadsheetTableIDGeometry &dst, const SpreadsheetTableIDGeometry &src)
static void spreadsheet_main_region_draw(const bContext *C, ARegion *region)
void spreadsheet_table_id_blend_write_content_geometry(BlendWriter *writer, const SpreadsheetTableIDGeometry *table_id)
std::unique_ptr< DataSource > get_data_source(const bContext &C)
static void spreadsheet_main_region_init(wmWindowManager *wm, ARegion *region)
void spreadsheet_table_id_blend_read(BlendDataReader *reader, SpreadsheetTableID *table_id)
void spreadsheet_table_remove_unused_columns(SpreadsheetTable &table)
void spreadsheet_table_id_foreach_id(SpreadsheetTableID &table_id, LibraryForeachIDData *data)
static void spreadsheet_footer_region_draw(const bContext *C, ARegion *region)
Object * spreadsheet_get_object_eval(const SpaceSpreadsheet *sspreadsheet, const Depsgraph *depsgraph)
SpreadsheetTable * spreadsheet_table_new(SpreadsheetTableID *table_id)
static void spreadsheet_id_remap(ScrArea *, SpaceLink *slink, const bke::id::IDRemapper &mappings)
ID * get_current_id(const SpaceSpreadsheet *sspreadsheet)
static void spreadsheet_footer_region_init(wmWindowManager *, ARegion *region)
SpreadsheetColumn * find_hovered_column_header(SpaceSpreadsheet &sspreadsheet, ARegion &region, const int2 &cursor_re)
static void spreadsheet_footer_region_listener(const wmRegionListenerParams *)
std::unique_ptr< SpreadsheetDrawer > spreadsheet_drawer_from_layout(const SpreadsheetLayout &spreadsheet_layout)
static void view_active_object(const bContext *C, SpaceSpreadsheet *sspreadsheet)
static void spreadsheet_dataset_region_listener(const wmRegionListenerParams *params)
void spreadsheet_table_free(SpreadsheetTable *table)
static void spreadsheet_blend_read_data(BlendDataReader *reader, SpaceLink *sl)
static void spreadsheet_header_region_draw(const bContext *C, ARegion *region)
static int get_index_column_width(const int tot_rows)
void spreadsheet_row_filter_free(SpreadsheetRowFilter *row_filter)
static void spreadsheet_blend_write(BlendWriter *writer, SpaceLink *sl)
static void spreadsheet_update_context(const bContext *C)
void spreadsheet_table_foreach_id(SpreadsheetTable &table, LibraryForeachIDData *data)
SpreadsheetColumn * find_hovered_column_header_edge(SpaceSpreadsheet &sspreadsheet, ARegion &region, const int2 &cursor_re)
void spreadsheet_column_assign_runtime_data(SpreadsheetColumn *column, const eSpreadsheetColumnValueType data_type, const StringRefNull display_name)
void spreadsheet_data_set_region_panels_register(ARegionType &region_type)
SpreadsheetTable * get_active_table(SpaceSpreadsheet &sspreadsheet)
static void spreadsheet_header_region_listener(const wmRegionListenerParams *params)
static void spreadsheet_cursor(wmWindow *win, ScrArea *area, ARegion *region)
SpreadsheetColumnID * spreadsheet_column_id_copy(const SpreadsheetColumnID *src_column_id)
SpreadsheetTable * spreadsheet_table_copy(const SpreadsheetTable &src_table)
void spreadsheet_table_remap_id(SpreadsheetTable &table, const bke::id::IDRemapper &mappings)
static void spreadsheet_dataset_region_draw(const bContext *C, ARegion *region)
void register_row_filter_panels(ARegionType &region_type)
void spreadsheet_table_id_remap_id(SpreadsheetTableID &table_id, const bke::id::IDRemapper &mappings)
SpreadsheetTable * spreadsheet_table_find(SpaceSpreadsheet &sspreadsheet, const SpreadsheetTableID &table_id)
void spreadsheet_table_add(SpaceSpreadsheet &sspreadsheet, SpreadsheetTable *table)
static void spreadsheet_main_region_listener(const wmRegionListenerParams *params)
static void spreadsheet_right_region_listener(const wmRegionListenerParams *)
Object * parse_object_only(const ViewerPath &viewer_path)
std::optional< ViewerPathForGeometryNodesViewer > parse_geometry_nodes_viewer(const ViewerPath &viewer_path)
bool exists_geometry_nodes_viewer(const ViewerPathForGeometryNodesViewer &parsed_viewer_path)
void frame_buffer_clear(int colorid)
void view2d_mask_from_win(const View2D *v2d, rcti *r_mask)
Definition view2d.cc:111
const uiStyle * style_get_dpi()
void panel_category_active_set_default(ARegion *region, const char *idname)
int2 block_layout_resolve(Block *block)
@ V2D_COMMONVIEW_LIST
Definition UI_view2d.hh:60
Layout & block_layout(Block *block, LayoutDirection direction, LayoutType type, int x, int y, int size, int em, int padding, const uiStyle *style)
UserDef U
Definition blender.cc:58
ScrArea * CTX_wm_area(const bContext *C)
@ SPREADSHEET_FILTER_ENABLE
float BLF_width(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2)
Definition blf.cc:835
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
WorkSpace * CTX_wm_workspace(const bContext *C)
@ REGION_DRAW_LOCK_ALL
void BLO_read_pointer_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
eSpaceSpreadsheet_ObjectEvalState
@ SPREADSHEET_OBJECT_EVAL_STATE_VIEWER_NODE
@ SPREADSHEET_OBJECT_EVAL_STATE_ORIGINAL
@ SPREADSHEET_OBJECT_EVAL_STATE_EVALUATED
IDViewerPathElem * BKE_viewer_path_elem_new_id()
@ SPREADSHEET_FLAG_PINNED
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
void BLF_size(int fontid, float size)
Definition blf.cc:445
void ED_region_draw_overflow_indication(const ScrArea *area, const ARegion *region, const rcti *mask=nullptr)
Definition area.cc:3726
VecBase< int32_t, 2 > int2
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
int BLF_default()
@ VIEWER_PATH_EQUAL_FLAG_CONSIDER_UI_NAME
void BKE_viewer_path_copy(ViewerPath *dst, const ViewerPath *src)
void ED_region_panels(const bContext *C, ARegion *region)
Definition area.cc:3999
wmKeyMap * WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
Definition wm_keymap.cc:935
wmEventHandler_Keymap * WM_event_add_keymap_handler(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
ARegion * BKE_area_region_new()
Definition screen.cc:522
@ ED_KEYMAP_UI
Definition ED_screen.hh:852
@ ED_KEYMAP_HEADER
Definition ED_screen.hh:858
@ ED_KEYMAP_VIEW2D
Definition ED_screen.hh:855
@ ED_KEYMAP_FRAMES
Definition ED_screen.hh:857
bool BKE_viewer_path_equal(const ViewerPath *a, const ViewerPath *b, ViewerPathEqualFlag flag=ViewerPathEqualFlag(0))
size_t BLI_str_format_int_grouped(char dst[BLI_STR_FORMAT_INT32_GROUPED_SIZE], int num) ATTR_NONNULL(1)
@ SPREADSHEET_COLUMN_FLAG_UNAVAILABLE
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
Definition screen.cc:1024
@ V2D_SCROLL_VERTICAL_HIDE
@ V2D_SCROLL_HORIZONTAL_HIDE
@ SPREADSHEET_TABLE_ID_TYPE_GEOMETRY
@ WM_CURSOR_HAND
Definition wm_cursors.hh:24
@ WM_CURSOR_DEFAULT
Definition wm_cursors.hh:17
@ WM_CURSOR_X_MOVE
Definition wm_cursors.hh:41
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void BKE_spacetype_register(std::unique_ptr< SpaceType > st)
Definition screen.cc:379
ID_Type GS(const char *name)
Definition DNA_ID.h:410
void ED_region_header_init(ARegion *region)
Definition area.cc:4406
void WM_cursor_set(wmWindow *win, int curs)
SpaceSpreadsheet * CTX_wm_space_spreadsheet(const bContext *C)
void ED_region_panels_layout(const bContext *C, ARegion *region)
Definition area.cc:3835
@ RGN_FLAG_INDICATE_OVERFLOW
void BKE_viewer_path_clear(ViewerPath *viewer_path)
@ SPREADSHEET_VALUE_TYPE_UNKNOWN
void ED_region_header(const bContext *C, ARegion *region)
Definition area.cc:4391
Object * CTX_data_active_object(const bContext *C)
void ED_region_panels_draw(const bContext *C, ARegion *region)
Definition area.cc:3916
void ED_region_panels_init(wmWindowManager *wm, ARegion *region)
Definition area.cc:4006
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:6653
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void ED_area_tag_redraw(ScrArea *area)
Definition area.cc:784
void(*) cursor(wmWindow *win, ScrArea *area, ARegion *region)
ARegionTypeFlag flag
void(*) free(ARegion *)
void(*) draw(const bContext *C, ARegion *region)
void(*) listener(const wmRegionListenerParams *params)
void(*) layout(const bContext *C, ARegion *region)
void(*) init(wmWindowManager *wm, ARegion *region)
bke::ARegionRuntime * runtime
eRegion_Alignment alignment
eRegion_Type regiontype
void write_pointer_array(int64_t num, const void *data)
void write_string(const char *data)
void write_struct_cast(const void *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
char name[258]
Definition DNA_ID.h:433
ListBaseT< SpaceLink > spacedata
ListBaseT< ARegion > regionbase
ed::spreadsheet::SpaceSpreadsheet_Runtime * runtime
SpreadsheetTableIDGeometry geometry_id
SpreadsheetTable ** tables
ListBaseT< struct SpreadsheetRowFilter > row_filters
SpreadsheetColumnID * id
SpreadsheetColumn ** columns
eView2D_KeepTot keeptot
eView2D_KeepZoom keepzoom
eView2D_Scroll scroll
eView2D_Align align
ListBaseT< ViewerPathElem > path
ListBaseT< wmEventHandler > handlers
void alignment_set(LayoutAlign alignment)
void label(StringRef name, int icon)
unsigned int action
Definition WM_types.hh:371
unsigned int category
Definition WM_types.hh:371
unsigned int data
Definition WM_types.hh:371
bke::WindowRuntime * runtime