Blender V5.3
spreadsheet_table.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BKE_viewer_path.hh"
6
7#include "BLI_hash.hh"
8#include "BLI_listbase.hh"
9#include "BLI_string.hh"
10
11#include "DNA_array_utils.hh"
12
13#include "BLO_read_write.hh"
14
16#include "spreadsheet_column.hh"
17#include "spreadsheet_table.hh"
18
20
22{
23 auto *table_id = MEM_new<SpreadsheetTableIDGeometry>(__func__);
24 table_id->base.type = SPREADSHEET_TABLE_ID_TYPE_GEOMETRY;
25 return table_id;
26}
27
30{
31 dst.bundle_path = MEM_new_array<SpreadsheetBundlePathElem>(src.bundle_path_num, __func__);
33 for (const int i : IndexRange(src.bundle_path_num)) {
35 }
36}
37
51
53{
54 switch (eSpreadsheetTableIDType(src_table_id.type)) {
56 const auto &src = *reinterpret_cast<const SpreadsheetTableIDGeometry *>(&src_table_id);
57 auto *new_table_id = spreadsheet_table_id_new_geometry();
59 return &new_table_id->base;
60 }
61 }
62 return nullptr;
63}
64
66{
67 for (const int i : IndexRange(bundle_path.bundle_path_num)) {
68 MEM_SAFE_DELETE(bundle_path.bundle_path[i].identifier);
69 }
70 MEM_SAFE_DELETE(bundle_path.bundle_path);
71 bundle_path.bundle_path_num = 0;
73}
74
76 const Span<nodes::BundleKey> keys,
77 const std::optional<SpreadsheetClosureInputOutput> closure_input_output,
78 SpreadsheetBundleTreeViewPath &r_bundle_path)
79{
80 spreadsheet_bundle_path_clear(r_bundle_path);
81 r_bundle_path.bundle_path = MEM_new_array<SpreadsheetBundlePathElem>(keys.size(), __func__);
82 r_bundle_path.bundle_path_num = keys.size();
83 for (const int i : keys.index_range()) {
84 const StringRef key = keys[i].ustr().ref();
85 r_bundle_path.bundle_path[i].identifier = BLI_strdupn(key.data(), key.size());
86 }
87 r_bundle_path.closure_input_output = closure_input_output.value_or(SPREADSHEET_CLOSURE_NONE);
88}
89
91{
93}
94
96{
97 switch (eSpreadsheetTableIDType(table_id->type)) {
99 auto *table_id_ = reinterpret_cast<SpreadsheetTableIDGeometry *>(table_id);
100 BKE_viewer_path_clear(&table_id_->viewer_path);
101 MEM_SAFE_DELETE(table_id_->instance_ids);
102 free_bundle_path(table_id_->viewer_item_bundle_path);
103 free_bundle_path(table_id_->geometry_bundle_path);
104 break;
105 }
106 }
107}
108
110{
112 MEM_delete(table_id);
113}
114
115static void write_bundle_path(BlendWriter *writer,
116 const SpreadsheetBundleTreeViewPath &bundle_path)
117{
118 writer->write_struct_array(bundle_path.bundle_path_num, bundle_path.bundle_path);
119 for (const int i : IndexRange(bundle_path.bundle_path_num)) {
120 writer->write_string(bundle_path.bundle_path[i].identifier);
121 }
122}
123
132
134{
135 switch (eSpreadsheetTableIDType(table_id->type)) {
137 const auto *table_id_ = reinterpret_cast<const SpreadsheetTableIDGeometry *>(table_id);
138 writer->write_struct(table_id_);
140 break;
141 }
142 }
143}
144
146{
147 BLO_read_array_and_validate_size(reader, &bundle_path.bundle_path, &bundle_path.bundle_path_num);
148 for (const int i : IndexRange(bundle_path.bundle_path_num)) {
149 BLO_read_string(reader, &bundle_path.bundle_path[i].identifier);
150 }
151}
152
154{
155 switch (eSpreadsheetTableIDType(table_id->type)) {
157 auto *table_id_ = reinterpret_cast<SpreadsheetTableIDGeometry *>(table_id);
158 BKE_viewer_path_blend_read_data(reader, &table_id_->viewer_path);
160 reader, &table_id_->instance_ids, &table_id_->instance_ids_num);
161 read_bundle_path(reader, table_id_->viewer_item_bundle_path);
162 read_bundle_path(reader, table_id_->geometry_bundle_path);
163 break;
164 }
165 }
166}
167
169 const bke::id::IDRemapper &mappings)
170{
171 switch (eSpreadsheetTableIDType(table_id.type)) {
173 auto *table_id_ = reinterpret_cast<SpreadsheetTableIDGeometry *>(&table_id);
174 BKE_viewer_path_id_remap(&table_id_->viewer_path, mappings);
175 break;
176 }
177 }
178}
179
181{
182 switch (eSpreadsheetTableIDType(table_id.type)) {
184 auto *table_id_ = reinterpret_cast<SpreadsheetTableIDGeometry *>(&table_id);
185 BKE_viewer_path_foreach_id(data, &table_id_->viewer_path);
186 break;
187 }
188 }
189}
190
197
199{
200 if (a.type != b.type) {
201 return false;
202 }
204 switch (type) {
206 const auto &a_ = *reinterpret_cast<const SpreadsheetTableIDGeometry *>(&a);
207 const auto &b_ = *reinterpret_cast<const SpreadsheetTableIDGeometry *>(&b);
209 &a_.viewer_path, &b_.viewer_path, VIEWER_PATH_EQUAL_FLAG_IGNORE_ITERATION) &&
210 a_.geometry_component_type == b_.geometry_component_type &&
211 a_.attribute_domain == b_.attribute_domain &&
212 a_.object_eval_state == b_.object_eval_state && a_.layer_index == b_.layer_index &&
213 blender::Span(a_.instance_ids, a_.instance_ids_num) ==
214 blender::Span(b_.instance_ids, b_.instance_ids_num) &&
215 bundle_path_match(a_.viewer_item_bundle_path, b_.viewer_item_bundle_path) &&
216 bundle_path_match(a_.geometry_bundle_path, b_.geometry_bundle_path);
217 }
218 }
219 return true;
220}
221
223{
224 SpreadsheetTable *spreadsheet_table = MEM_new<SpreadsheetTable>(__func__);
225 spreadsheet_table->id = table_id;
226 return spreadsheet_table;
227}
228
230{
232 new_table->num_columns = src_table.num_columns;
233 new_table->columns = MEM_new_array<SpreadsheetColumn *>(src_table.num_columns, __func__);
234 for (const int i : IndexRange(src_table.num_columns)) {
235 new_table->columns[i] = spreadsheet_column_copy(src_table.columns[i]);
236 }
237 return new_table;
238}
239
241{
243 for (const int i : IndexRange(table->num_columns)) {
245 }
246 MEM_SAFE_DELETE(table->columns);
247 MEM_delete(table);
248}
249
251{
252 writer->write_struct(table);
253 spreadsheet_table_id_blend_write(writer, table->id);
254 writer->write_pointer_array(table->num_columns, table->columns);
255 for (const int i : IndexRange(table->num_columns)) {
256 spreadsheet_column_blend_write(writer, table->columns[i]);
257 }
258}
259
261{
262 BLO_read_struct(reader, SpreadsheetTableID, &table->id);
263 spreadsheet_table_id_blend_read(reader, table->id);
265 for (const int i : IndexRange(table->num_columns)) {
266 BLO_read_struct(reader, SpreadsheetColumn, &table->columns[i]);
267 spreadsheet_column_blend_read(reader, table->columns[i]);
268 }
269}
270
272{
273 spreadsheet_table_id_remap_id(*table.id, mappings);
274}
275
280
282 const SpreadsheetTableID &table_id)
283{
284 return const_cast<SpreadsheetTable *>(
285 spreadsheet_table_find(const_cast<const SpaceSpreadsheet &>(sspreadsheet), table_id));
286}
287
289 const SpreadsheetTableID &table_id)
290{
291 for (const SpreadsheetTable *table : Span{sspreadsheet.tables, sspreadsheet.num_tables}) {
292 if (spreadsheet_table_id_match(table_id, *table->id)) {
293 return table;
294 }
295 }
296 return nullptr;
297}
298
300{
301 SpreadsheetTable **new_tables = MEM_new_array<SpreadsheetTable *>(sspreadsheet.num_tables + 1,
302 __func__);
303 std::copy_n(sspreadsheet.tables, sspreadsheet.num_tables, new_tables);
304 new_tables[sspreadsheet.num_tables] = table;
305 MEM_SAFE_DELETE(sspreadsheet.tables);
306 sspreadsheet.tables = new_tables;
307 sspreadsheet.num_tables++;
308}
309
311{
312 uint32_t min_last_used = 0;
313 const int max_tables = 50;
314 if (sspreadsheet.num_tables > max_tables) {
315 Vector<uint32_t> last_used_times;
316 for (const SpreadsheetTable *table : Span(sspreadsheet.tables, sspreadsheet.num_tables)) {
317 last_used_times.append(table->last_used);
318 }
319 std::ranges::sort(last_used_times);
320 min_last_used = last_used_times[sspreadsheet.num_tables - max_tables];
321 }
322
324 &sspreadsheet.tables,
325 &sspreadsheet.num_tables,
326 [&](const SpreadsheetTable *table) {
327 if (!(table->flag & SPREADSHEET_TABLE_FLAG_MANUALLY_EDITED)) {
328 /* Remove tables that have never been modified manually. Those can be rebuilt from
329 * scratch if necessary. */
330 return true;
331 }
332 if (table->last_used < min_last_used) {
333 /* The table has not been used for a while and there are too many unused tables. So
334 * garbage collect this table. This does remove user-edited column widths and orders, but
335 * doesn't remove any actual data. */
336 return true;
337 }
339 case SPREADSHEET_TABLE_ID_TYPE_GEOMETRY: {
340 const SpreadsheetTableIDGeometry &table_id =
341 *reinterpret_cast<const SpreadsheetTableIDGeometry *>(table->id);
342 for (ViewerPathElem &elem : table_id.viewer_path.path) {
343 if (elem.type == VIEWER_PATH_ELEM_TYPE_ID) {
344 const IDViewerPathElem &id_elem = reinterpret_cast<const IDViewerPathElem &>(elem);
345 if (!id_elem.id) {
346 /* Remove tables which reference an ID that does not exist anymore. */
347 return true;
348 }
349 }
350 }
351 break;
352 }
353 }
354 return false;
355 },
356 [](SpreadsheetTable **table) { spreadsheet_table_free(*table); });
357}
358
360{
361 /* Might not be reached exactly if there are many columns with the same last used time. */
362 const int max_unavailable_columns_target = 50;
363 int num_unavailable_columns = 0;
364 for (SpreadsheetColumn *column : Span(table.columns, table.num_columns)) {
365 if (!column->is_available()) {
366 num_unavailable_columns++;
367 }
368 }
369 if (num_unavailable_columns <= max_unavailable_columns_target) {
370 /* No need to remove columns. */
371 return;
372 }
373
374 /* Find the threshold time for unavailable columns to remove. */
375 Vector<uint32_t> last_used_times;
376 for (SpreadsheetColumn *column : Span(table.columns, table.num_columns)) {
377 if (!column->is_available()) {
378 last_used_times.append(column->last_used);
379 }
380 }
381 std::ranges::sort(last_used_times);
382 const int min_last_used = last_used_times[max_unavailable_columns_target];
383
385 &table.columns,
386 &table.num_columns,
387 [&](const SpreadsheetColumn *column) {
388 if (column->is_available()) {
389 /* Available columns should never be removed here. */
390 return false;
391 }
392 if (column->last_used > min_last_used) {
393 /* Columns that have been used recently are not removed. */
394 return false;
395 }
396 return true;
397 },
398 [](SpreadsheetColumn **column) { spreadsheet_column_free(*column); });
399}
400
402{
403 const int old_index = Span(sspreadsheet.tables, sspreadsheet.num_tables).first_index(&table);
404 dna::array::move_index(sspreadsheet.tables, sspreadsheet.num_tables, old_index, 0);
405}
406
407} // namespace blender::ed::spreadsheet
#define BLO_read_struct(reader, struct_name, ptr_p)
constexpr Span()=default
constexpr IndexRange()=default
constexpr Span()=default
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
void append(const T &value)
constexpr int64_t size() const
constexpr const char * data() const
void remove_if(T **items, int *items_num, FunctionRef< bool(const T &)> predicate, void(*destruct_item)(T *))
void move_index(T *items, const int items_num, const int from_index, const int to_index)
void spreadsheet_table_move_to_front(SpaceSpreadsheet &sspreadsheet, SpreadsheetTable &table)
void spreadsheet_table_id_free(SpreadsheetTableID *table_id)
static void write_bundle_path(BlendWriter *writer, const SpreadsheetBundleTreeViewPath &bundle_path)
void spreadsheet_table_blend_write(BlendWriter *writer, const SpreadsheetTable *table)
static void free_bundle_path(SpreadsheetBundleTreeViewPath &bundle_path)
void spreadsheet_table_id_blend_write(BlendWriter *writer, const SpreadsheetTableID *table_id)
void spreadsheet_column_blend_write(BlendWriter *writer, const SpreadsheetColumn *column)
void spreadsheet_table_blend_read(BlendDataReader *reader, SpreadsheetTable *table)
static void read_bundle_path(BlendDataReader *reader, SpreadsheetBundleTreeViewPath &bundle_path)
void spreadsheet_table_remove_unused(SpaceSpreadsheet &sspreadsheet)
void spreadsheet_column_blend_read(BlendDataReader *reader, SpreadsheetColumn *column)
void spreadsheet_table_id_free_content(SpreadsheetTableID *table_id)
void spreadsheet_bundle_path_init_from(const Span< nodes::BundleKey > keys, const std::optional< SpreadsheetClosureInputOutput > closure_input_output, SpreadsheetBundleTreeViewPath &r_bundle_path)
SpreadsheetTableID * spreadsheet_table_id_copy(const SpreadsheetTableID &src_table_id)
void spreadsheet_table_id_copy_content_geometry(SpreadsheetTableIDGeometry &dst, const SpreadsheetTableIDGeometry &src)
void spreadsheet_bundle_path_clear(SpreadsheetBundleTreeViewPath &bundle_path)
void spreadsheet_table_id_blend_write_content_geometry(BlendWriter *writer, const SpreadsheetTableIDGeometry *table_id)
void spreadsheet_table_id_blend_read(BlendDataReader *reader, SpreadsheetTableID *table_id)
void spreadsheet_table_remove_unused_columns(SpreadsheetTable &table)
SpreadsheetTableIDGeometry * spreadsheet_table_id_new_geometry()
void spreadsheet_table_id_foreach_id(SpreadsheetTableID &table_id, LibraryForeachIDData *data)
SpreadsheetTable * spreadsheet_table_new(SpreadsheetTableID *table_id)
void spreadsheet_column_free(SpreadsheetColumn *column)
void spreadsheet_table_free(SpreadsheetTable *table)
static void copy_bundle_path(SpreadsheetBundleTreeViewPath &dst, const SpreadsheetBundleTreeViewPath &src)
void spreadsheet_table_foreach_id(SpreadsheetTable &table, LibraryForeachIDData *data)
bool spreadsheet_table_id_match(const SpreadsheetTableID &a, const SpreadsheetTableID &b)
SpreadsheetTable * spreadsheet_table_copy(const SpreadsheetTable &src_table)
void spreadsheet_table_remap_id(SpreadsheetTable &table, const bke::id::IDRemapper &mappings)
static bool bundle_path_match(const SpreadsheetBundleTreeViewPath &a, const SpreadsheetBundleTreeViewPath &b)
SpreadsheetColumn * spreadsheet_column_copy(const SpreadsheetColumn *src_column)
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)
void BKE_viewer_path_id_remap(ViewerPath *viewer_path, const bke::id::IDRemapper &mappings)
void BLO_read_pointer_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size)
void BKE_viewer_path_blend_read_data(BlendDataReader *reader, ViewerPath *viewer_path)
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BKE_viewer_path_foreach_id(LibraryForeachIDData *data, ViewerPath *viewer_path)
unsigned int uint32_t
Definition BKE_text.h:81
BMesh const char void * data
@ VIEWER_PATH_EQUAL_FLAG_IGNORE_ITERATION
void BKE_viewer_path_copy(ViewerPath *dst, const ViewerPath *src)
switch(BMIterType(itype))
void BKE_viewer_path_blend_write(BlendWriter *writer, const ViewerPath *viewer_path)
@ SPREADSHEET_CLOSURE_NONE
bool BKE_viewer_path_equal(const ViewerPath *a, const ViewerPath *b, ViewerPathEqualFlag flag=ViewerPathEqualFlag(0))
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
@ SPREADSHEET_TABLE_ID_TYPE_GEOMETRY
char * BLI_strdup_null(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_MALLOC
void BKE_viewer_path_clear(ViewerPath *viewer_path)
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:6653
void write_pointer_array(int64_t num, const void *data)
void write_string(const char *data)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
SpreadsheetTable ** tables
SpreadsheetClosureInputOutput closure_input_output
SpreadsheetBundlePathElem * bundle_path
SpreadsheetBundleTreeViewPath viewer_item_bundle_path
SpreadsheetBundleTreeViewPath geometry_bundle_path
SpreadsheetColumn ** columns
SpreadsheetTableID * id