Blender V5.3
workspace.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdio>
10#include <cstdlib>
11#include <cstring>
12
13#include "DNA_listBase.h"
14
15#include "BLI_listbase.hh"
16#include "BLI_string.hh"
17#include "BLI_string_utils.hh"
18#include "BLI_utildefines.hh"
19
20#include "BLT_translation.hh"
21
22#include "BKE_asset.hh"
23#include "BKE_global.hh"
24#include "BKE_idprop.hh"
25#include "BKE_idtype.hh"
26#include "BKE_lib_id.hh"
27#include "BKE_lib_query.hh"
28#include "BKE_main.hh"
29#include "BKE_screen.hh"
30#include "BKE_viewer_path.hh"
31#include "BKE_workspace.hh"
32
33#include "DNA_scene_types.h"
34#include "DNA_screen_types.h"
36#include "DNA_workspace_types.h"
37
38#include "MEM_guardedalloc.h"
39
40#include "BLO_read_write.hh"
41
42namespace blender {
43
44/* -------------------------------------------------------------------- */
45
46static void workspace_init_data(ID *id)
47{
48 WorkSpace *workspace = id_cast<WorkSpace *>(id);
49
50 workspace->runtime = MEM_new<bke::WorkSpaceRuntime>(__func__);
51
53}
54
55static void workspace_free_data(ID *id)
56{
57 WorkSpace *workspace = id_cast<WorkSpace *>(id);
58
60
61 workspace->owner_ids.free_no_destruct();
62 workspace->layouts.free_no_destruct();
63
64 while (!workspace->tools.is_empty()) {
65 BKE_workspace_tool_remove(workspace, workspace->tools.first());
66 }
67
69 MEM_delete(workspace->runtime);
70
72}
73
75 Main *bmain, std::optional<Library *> owner_library, ID *id_dst, const ID *id_src, int flag)
76{
77 /* Workspaces should always be local data currently. */
78 BLI_assert(!owner_library || owner_library == nullptr);
79 UNUSED_VARS_NDEBUG(owner_library);
80
81 WorkSpace *workspace_dst = id_cast<WorkSpace *>(id_dst);
82 const WorkSpace *workspace_src = id_cast<const WorkSpace *>(id_src);
83
84 workspace_dst->runtime = MEM_new<bke::WorkSpaceRuntime>(__func__);
86
87 workspace_dst->flags = workspace_src->flags;
88 workspace_dst->pin_scene = workspace_src->pin_scene;
89 workspace_dst->sequencer_scene = workspace_src->sequencer_scene;
90 workspace_dst->object_mode = workspace_src->object_mode;
91 workspace_dst->order = workspace_src->order;
92 BLI_duplicatelist(&workspace_dst->owner_ids, &workspace_src->owner_ids);
93
94 /* TODO(@ideasman42): tools */
95 workspace_dst->tools.clear_no_delete();
96
97 workspace_dst->hook_layout_relations.clear_no_delete();
98
99 /* WARNING! This is effectively duplicating other IDs (bScreen ones) inside the copying callback
100 * of a workspace.
101 *
102 * This is similar to what is already done with ShapeKeys.
103 */
104 workspace_dst->layouts.clear_no_delete();
105 for (WorkSpaceLayout &layout_src : workspace_src->layouts) {
106 if (flag & LIB_ID_COPY_SCREEN) {
107 BKE_workspace_layout_add_from_layout(bmain, *workspace_dst, layout_src, flag);
108 }
109 else {
110 /* Copying of screens should only be disabled in some `NO_MAIN` cases. */
112 BKE_workspace_layout_add(bmain, *workspace_dst, *layout_src.screen, layout_src.name);
113 }
114 }
115}
116
130
131static void workspace_blend_write(BlendWriter *writer, ID *id, const void *id_address)
132{
133 WorkSpace *workspace = id_cast<WorkSpace *>(id);
134
135 writer->write_id_struct(id_address, workspace);
136 BKE_id_blend_write(writer, &workspace->id);
137 writer->write_struct_list(&workspace->layouts);
138 writer->write_struct_list(&workspace->hook_layout_relations);
139 writer->write_struct_list(&workspace->owner_ids);
140 writer->write_struct_list(&workspace->tools);
141 for (bToolRef &tref : workspace->tools) {
142 if (tref.properties) {
143 IDP_BlendWrite(writer, tref.properties);
144 }
145 }
146
147 BKE_viewer_path_blend_write(writer, &workspace->viewer_path);
148}
149
151{
152 WorkSpace *workspace = id_cast<WorkSpace *>(id);
153
154 BLO_read_struct_list(reader, WorkSpaceLayout, &workspace->layouts);
156 BLO_read_struct_list(reader, wmOwnerID, &workspace->owner_ids);
157 BLO_read_struct_list(reader, bToolRef, &workspace->tools);
158
159 for (WorkSpaceDataRelation &relation : workspace->hook_layout_relations) {
160 /* Parent pointer does not belong to workspace data and is therefore restored in lib_link step
161 * of window manager. */
162 /* FIXME: Should not use that untyped #BLO_read_raw_address call, especially since it's
163 * reference-counting the matching data in readfile code. Problem currently is that there is no
164 * type info available for this void pointer (_should_ be pointing to a #WorkSpaceLayout ?), so
165 * #BLO_read_struct_no_us cannot be used here. */
166 BLO_read_raw_address(reader, &relation.value);
167 }
168
169 for (bToolRef &tref : workspace->tools) {
170 tref.runtime = nullptr;
171 BLO_read_struct(reader, IDProperty, &tref.properties);
172 IDP_BlendDataRead(reader, &tref.properties);
173 }
174
175 workspace->runtime = MEM_new<bke::WorkSpaceRuntime>(__func__);
176
177 /* Do not keep the scene reference when appending a workspace. Setting a scene for a workspace is
178 * a convenience feature, but the workspace should never truly depend on scene data. */
179 if (ID_IS_LINKED(workspace)) {
180 workspace->pin_scene = nullptr;
181 }
182
183 id_us_ensure_real(&workspace->id);
184
185 BKE_viewer_path_blend_read_data(reader, &workspace->viewer_path);
186}
187
189{
190 WorkSpace *workspace = reinterpret_cast<WorkSpace *>(id);
191 Main *bmain = BLO_read_lib_get_main(reader);
192
193 /* Restore proper 'parent' pointers to relevant data, and clean up unused/invalid entries. */
194 for (WorkSpaceDataRelation &relation : workspace->hook_layout_relations.items_mutable()) {
195 relation.parent = nullptr;
196 for (wmWindowManager &wm : bmain->wm) {
197 for (wmWindow &win : wm.windows) {
198 if (win.winid == relation.parentid) {
199 relation.parent = win.workspace_hook;
200 }
201 }
202 }
203 if (relation.parent == nullptr) {
204 BLI_freelinkN(&workspace->hook_layout_relations, &relation);
205 }
206 }
207
208 for (WorkSpaceLayout &layout : workspace->layouts.items_mutable()) {
209 if (layout.screen) {
210 if (ID_IS_LINKED(id)) {
211 layout.screen->winid = 0;
212 if (layout.screen->temp) {
213 /* delete temp layouts when appending */
214 BKE_workspace_layout_remove(bmain, workspace, &layout);
215 }
216 }
217 }
218 else {
219 /* If we're reading a layout without screen stored, it's useless and we shouldn't keep it
220 * around. */
221 BKE_workspace_layout_remove(bmain, workspace, &layout);
222 }
223 }
224}
225
227 .id_code = WorkSpace::id_type,
228 .id_filter = FILTER_ID_WS,
229 .dependencies_id_types = FILTER_ID_SCE,
230 .main_listbase_index = INDEX_ID_WS,
231 .struct_size = sizeof(WorkSpace),
232 .name = "WorkSpace",
233 .name_plural = N_("workspaces"),
234 .translation_context = BLT_I18NCONTEXT_ID_WORKSPACE,
237 .asset_type_info = nullptr,
238
239 .init_data = workspace_init_data,
240 .copy_data = workspace_copy_data,
241 .free_data = workspace_free_data,
242 .make_local = nullptr,
243 .foreach_id = workspace_foreach_id,
244 .foreach_cache = nullptr,
245 .foreach_path = nullptr,
246 .foreach_working_space_color = nullptr,
247 .foreach_asset_weak_reference = nullptr,
248 .owner_pointer_get = nullptr,
249
250 .blend_write = workspace_blend_write,
251 .blend_read_data = workspace_blend_read_data,
252 .blend_read_after_liblink = workspace_blend_read_after_liblink,
253
254 .blend_read_undo_preserve = nullptr,
255
256 .lib_override_apply_post = nullptr,
257};
258
259/* -------------------------------------------------------------------- */
262
264 WorkSpaceLayout *layout,
265 const char *new_name)
266{
267 STRNCPY(layout->name, new_name);
268 BLI_uniquename(&workspace->layouts,
269 layout,
270 "Layout",
271 '.',
273 sizeof(layout->name));
274}
275
282 const bScreen *screen)
283{
284 return static_cast<WorkSpaceLayout *>(
285 BLI_findptr(&workspace->layouts, screen, offsetof(WorkSpaceLayout, screen)));
286}
287
288static void workspace_relation_add(ListBaseT<WorkSpaceDataRelation> *relation_list,
289 void *parent,
290 const int parentid,
291 void *data)
292{
293 WorkSpaceDataRelation *relation = MEM_new<WorkSpaceDataRelation>(__func__);
294 relation->parent = parent;
295 relation->parentid = parentid;
296 relation->value = data;
297 /* add to head, if we switch back to it soon we find it faster. */
298 BLI_addhead(relation_list, relation);
299}
300static void workspace_relation_remove(ListBaseT<WorkSpaceDataRelation> *relation_list,
301 WorkSpaceDataRelation *relation)
302{
303 BLI_remlink(relation_list, relation);
304 MEM_delete(relation);
305}
306
307static void workspace_relation_ensure_updated(ListBaseT<WorkSpaceDataRelation> *relation_list,
308 void *parent,
309 const int parentid,
310 void *data)
311{
313 relation_list, &parentid, sizeof(parentid), offsetof(WorkSpaceDataRelation, parentid)));
314 if (relation != nullptr) {
315 relation->parent = parent;
316 relation->value = data;
317 /* reinsert at the head of the list, so that more commonly used relations are found faster. */
318 BLI_remlink(relation_list, relation);
319 BLI_addhead(relation_list, relation);
320 }
321 else {
322 /* no matching relation found, add new one */
323 workspace_relation_add(relation_list, parent, parentid, data);
324 }
325}
326
328 const ListBaseT<WorkSpaceDataRelation> *relation_list, const void *parent)
329{
330 WorkSpaceDataRelation *relation = static_cast<WorkSpaceDataRelation *>(
331 BLI_findptr(relation_list, parent, offsetof(WorkSpaceDataRelation, parent)));
332 if (relation != nullptr) {
333 return relation->value;
334 }
335
336 return nullptr;
337}
338
345#ifndef NDEBUG
347#else
349#endif
350 (const Main *bmain, bScreen *screen)
351{
352 for (WorkSpace *workspace = bmain->workspaces.first(); workspace;
353 workspace = static_cast<WorkSpace *>(workspace->id.next))
354 {
355 if (workspace_layout_find_exec(workspace, screen)) {
356 return true;
357 }
358 }
359
360 return false;
361}
362
364
365/* -------------------------------------------------------------------- */
368
369WorkSpace *BKE_workspace_add(Main *bmain, const char *name)
370{
371 WorkSpace *new_workspace = BKE_id_new<WorkSpace>(bmain, name);
372 id_us_ensure_real(&new_workspace->id);
373 return new_workspace;
374}
375
376void BKE_workspace_remove(Main *bmain, WorkSpace *workspace)
377{
378 for (WorkSpaceLayout *layout = workspace->layouts.first(), *layout_next; layout;
379 layout = layout_next)
380 {
381 layout_next = layout->next;
382 BKE_workspace_layout_remove(bmain, workspace, layout);
383 }
384 BKE_id_free(bmain, workspace);
385}
386
388{
389 WorkSpaceInstanceHook *hook = MEM_new<WorkSpaceInstanceHook>(__func__);
390
391 /* set an active screen-layout for each possible window/workspace combination */
392 for (WorkSpace *workspace = bmain->workspaces.first(); workspace;
393 workspace = static_cast<WorkSpace *>(workspace->id.next))
394 {
395 BKE_workspace_active_layout_set(hook, winid, workspace, workspace->layouts.first());
396 }
397
398 return hook;
399}
401{
402 /* workspaces should never be freed before wm (during which we call this function).
403 * However, when running in background mode, loading a blend file may allocate windows (that need
404 * to be freed) without creating workspaces. This happens in BlendfileLoadingBaseTest. */
405 BLI_assert(!bmain->workspaces.is_empty() || G.background);
406
407 /* Free relations for this hook */
408 for (WorkSpace *workspace = bmain->workspaces.first(); workspace;
409 workspace = static_cast<WorkSpace *>(workspace->id.next))
410 {
411 for (WorkSpaceDataRelation *relation = workspace->hook_layout_relations.first(),
412 *relation_next;
413 relation;
414 relation = relation_next)
415 {
416 relation_next = relation->next;
417 if (relation->parent == hook) {
418 workspace_relation_remove(&workspace->hook_layout_relations, relation);
419 }
420 }
421 }
422
423 MEM_delete(hook);
424}
425
427 WorkSpace &workspace,
428 bScreen &screen,
429 const char *name)
430{
431 WorkSpaceLayout *layout = MEM_new<WorkSpaceLayout>(__func__);
432
433 BLI_assert(!bmain || !workspaces_is_screen_used(bmain, &screen));
434#ifdef NDEBUG
435 UNUSED_VARS(bmain);
436#endif
437 layout->screen = &screen;
438 id_us_plus(&layout->screen->id);
439 workspace_layout_name_set(&workspace, layout, name);
440 BLI_addtail(&workspace.layouts, layout);
441
442 return layout;
443}
444
446 WorkSpace &workspace_dst,
447 const WorkSpaceLayout &layout_src,
448 const int id_copy_flags)
449{
450 bScreen *screen_src = BKE_workspace_layout_screen_get(&layout_src);
451 const char *name = BKE_workspace_layout_name_get(&layout_src);
452
453 /* In case the current layout's screen is a 'full screen' one, find the 'full' area, and its
454 * 'restore screen' as source, instead of the temporary full-screen one. */
455 if (BKE_screen_is_fullscreen_area(screen_src)) {
456 for (ScrArea &area_old : screen_src->areabase) {
457 /* The original layout/screen will also have one area->full set, but it will point to the
458 * same source screen. This can be ignored. */
459 if (area_old.full && area_old.full != screen_src) {
460 screen_src = area_old.full;
461 break;
462 }
463 }
464 }
465
466 bScreen *screen_dst = id_cast<bScreen *>(
467 BKE_id_copy_ex(bmain, &screen_src->id, nullptr, id_copy_flags));
468
469 return BKE_workspace_layout_add(bmain, workspace_dst, *screen_dst, name);
470}
471
473{
474 /* Screen should usually be set, but we call this from file reading to get rid of invalid
475 * layouts. */
476 if (layout->screen) {
477 id_us_min(&layout->screen->id);
478 BKE_id_free(bmain, layout->screen);
479 }
480 BLI_freelinkN(&workspace->layouts, layout);
481}
482
483void BKE_workspace_relations_free(ListBaseT<WorkSpaceDataRelation> *relation_list)
484{
485 for (WorkSpaceDataRelation *relation = relation_list->first(), *relation_next; relation;
486 relation = relation_next)
487 {
488 relation_next = relation->next;
489 workspace_relation_remove(relation_list, relation);
490 }
491}
492
494
495/* -------------------------------------------------------------------- */
498
500{
501 WorkSpaceLayout *layout = workspace_layout_find_exec(workspace, screen);
502 if (layout) {
503 return layout;
504 }
505
506 printf(
507 "%s: Couldn't find layout in this workspace: '%s' screen: '%s'. "
508 "This should not happen!\n",
509 __func__,
510 workspace->id.name + 2,
511 screen->id.name + 2);
512
513 return nullptr;
514}
515
517 const bScreen *screen,
518 WorkSpace **r_workspace)
519{
520 if (r_workspace) {
521 *r_workspace = nullptr;
522 }
523
524 for (WorkSpace *workspace = bmain->workspaces.first(); workspace;
525 workspace = static_cast<WorkSpace *>(workspace->id.next))
526 {
527 WorkSpaceLayout *layout = workspace_layout_find_exec(workspace, screen);
528 if (layout) {
529 if (r_workspace) {
530 *r_workspace = workspace;
531 }
532
533 return layout;
534 }
535 }
536
537 return nullptr;
538}
539
541 WorkSpaceLayout *start,
542 bool (*callback)(const WorkSpaceLayout *layout,
543 void *arg),
544 void *arg,
545 const bool iter_backward)
546{
547 WorkSpaceLayout *iter_layout;
548
549 if (iter_backward) {
550 LISTBASE_CIRCULAR_BACKWARD_BEGIN (WorkSpaceLayout *, &workspace->layouts, iter_layout, start) {
551 if (!callback(iter_layout, arg)) {
552 return iter_layout;
553 }
554 }
555 LISTBASE_CIRCULAR_BACKWARD_END(WorkSpaceLayout *, &workspace->layouts, iter_layout, start);
556 }
557 else {
558 LISTBASE_CIRCULAR_FORWARD_BEGIN (WorkSpaceLayout *, &workspace->layouts, iter_layout, start) {
559 if (!callback(iter_layout, arg)) {
560 return iter_layout;
561 }
562 }
563 LISTBASE_CIRCULAR_FORWARD_END(WorkSpaceLayout *, &workspace->layouts, iter_layout, start);
564 }
565
566 return nullptr;
567}
568
570{
571 if (tref->runtime) {
572 MEM_delete(tref->runtime);
573 }
574 if (tref->properties) {
576 }
577 BLI_remlink(&workspace->tools, tref);
578 MEM_delete(tref);
579}
580
582 const int space_type,
583 const int mode,
584 const char *idname_prefix_skip,
585 const char *replace_table[][2],
586 int replace_table_num)
587{
588 const size_t idname_prefix_len = idname_prefix_skip ? strlen(idname_prefix_skip) : 0;
589 const size_t idname_suffix_maxncpy = sizeof(bToolRef::idname) - idname_prefix_len;
590
591 for (bToolRef &tref : workspace->tools) {
592 if (!(tref.space_type == space_type && tref.mode == mode)) {
593 continue;
594 }
595 char *idname_suffix = tref.idname;
596 if (idname_prefix_skip) {
597 if (!STRPREFIX(idname_suffix, idname_prefix_skip)) {
598 continue;
599 }
600 idname_suffix += idname_prefix_len;
601 }
603 idname_suffix, idname_suffix_maxncpy, replace_table, replace_table_num);
604 }
605}
606
607bool BKE_workspace_owner_id_check(const WorkSpace *workspace, const char *owner_id)
608{
609 if ((*owner_id == '\0') || ((workspace->flags & WORKSPACE_USE_FILTER_BY_ORIGIN) == 0)) {
610 return true;
611 }
612
613 /* We could use hash lookup, for now this list is highly likely under < ~16 items. */
614 return BLI_findstring(&workspace->owner_ids, owner_id, offsetof(wmOwnerID, name)) != nullptr;
615}
616
618{
619 BKE_main_id_tag_listbase(&bmain->workspaces.cast<ID>(), tag, false);
620 wmWindowManager *wm = bmain->wm.first();
621 for (wmWindow &win : wm->windows) {
623 workspace->id.tag |= tag;
624 }
625}
626
628
629/* -------------------------------------------------------------------- */
632
638{
639 /* DO NOT check for `hook->active == workspace` here. Caller code is supposed to do it if
640 * that optimization is possible and needed.
641 * This code can be called from places where we might have this equality, but still want to
642 * ensure/update the active layout below.
643 * Known case where this is buggy and will crash later due to nullptr active layout: reading
644 * a blend file, when the new read workspace ID happens to have the exact same memory address
645 * as when it was saved in the blend file (extremely unlikely, but possible). */
646
647 hook->active = workspace;
648 if (workspace) {
649 WorkSpaceLayout *layout = static_cast<WorkSpaceLayout *>(
651 if (layout) {
652 hook->act_layout = layout;
653 }
654 }
655}
656
661
663 const WorkSpace *workspace)
664{
665 /* If the workspace is active, the active layout can be returned, no need for a lookup. */
666 if (hook->active == workspace) {
667 return hook->act_layout;
668 }
669
670 /* Inactive workspace */
671 return static_cast<WorkSpaceLayout *>(
673}
674
676 const int winid,
677 WorkSpace *workspace,
678 WorkSpaceLayout *layout)
679{
680 hook->act_layout = layout;
681 workspace_relation_ensure_updated(&workspace->hook_layout_relations, hook, winid, layout);
682}
683
689 const int winid,
690 WorkSpace *workspace,
691 bScreen *screen)
692{
693 /* we need to find the WorkspaceLayout that wraps this screen */
694 WorkSpaceLayout *layout = BKE_workspace_layout_find(hook->active, screen);
695 BKE_workspace_active_layout_set(hook, winid, workspace, layout);
696}
697
699{
700 return layout->name;
701}
703 WorkSpaceLayout *layout,
704 const char *new_name)
705{
706 workspace_layout_name_set(workspace, layout, new_name);
707}
708
710{
711 return layout->screen;
712}
713
715
716/* -------------------------------------------------------------------- */
719
721{
722 workspace->runtime->status.clear_and_shrink();
723}
724
726
727} // namespace blender
#define IDP_BlendDataRead(reader, prop)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define LISTBASE_CIRCULAR_BACKWARD_END(type, lb, lb_iter, lb_init)
#define LISTBASE_CIRCULAR_FORWARD_BEGIN(type, lb, lb_iter, lb_init)
#define LISTBASE_CIRCULAR_BACKWARD_BEGIN(type, lb, lb_iter, lb_init)
#define LISTBASE_CIRCULAR_FORWARD_END(type, lb, lb_iter, lb_init)
#define BLO_read_raw_address(reader, ptr_p)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_WORKSPACE
#define FILTER_ID_WS
Definition DNA_ID.h:1228
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define FILTER_ID_SCE
Definition DNA_ID.h:1219
These structs are the foundation for all linked lists in the library system.
Read Blender memory allocation and freeing.
#define UNUSED_FUNCTION(x)
#define STRPREFIX(a, b)
#define UNUSED_VARS(...)
#define UNUSED_VARS_NDEBUG(...)
#define offsetof(t, d)
BMesh Iterators.
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_workspace_layout_name_set(WorkSpace *workspace, WorkSpaceLayout *layout, const char *new_name) ATTR_NONNULL()
Definition workspace.cc:702
@ WORKSPACE_USE_FILTER_BY_ORIGIN
void BKE_workspace_active_set(WorkSpaceInstanceHook *hook, WorkSpace *workspace) SETTER_ATTRS
Definition workspace.cc:637
char * STRNCPY(char(&dst)[N], const char *src)
static void workspace_blend_read_after_liblink(BlendLibReader *reader, ID *id)
Definition workspace.cc:188
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
static void workspace_init_data(ID *id)
Definition workspace.cc:46
void id_us_plus(ID *id)
Definition lib_id.cc:433
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:834
bool BKE_workspace_owner_id_check(const WorkSpace *workspace, const char *owner_id) ATTR_NONNULL()
Definition workspace.cc:607
static void workspace_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition workspace.cc:131
void BKE_viewer_path_blend_read_data(BlendDataReader *reader, ViewerPath *viewer_path)
WorkSpaceLayout * BKE_workspace_layout_add(Main *bmain, WorkSpace &workspace, bScreen &screen, const char *name)
Definition workspace.cc:426
void BKE_workspace_active_screen_set(WorkSpaceInstanceHook *hook, int winid, WorkSpace *workspace, bScreen *screen) SETTER_ATTRS
Definition workspace.cc:688
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1696
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
static void * workspace_relation_get_data_matching_parent(const ListBaseT< WorkSpaceDataRelation > *relation_list, const void *parent)
Definition workspace.cc:327
void BKE_workspace_id_tag_all_visible(Main *bmain, int tag) ATTR_NONNULL()
Definition workspace.cc:617
static void workspace_copy_data(Main *bmain, std::optional< Library * > owner_library, ID *id_dst, const ID *id_src, int flag)
Definition workspace.cc:74
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:684
static void workspace_relation_ensure_updated(ListBaseT< WorkSpaceDataRelation > *relation_list, void *parent, const int parentid, void *data)
Definition workspace.cc:307
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
@ LIB_ID_COPY_SCREEN
@ LIB_ID_CREATE_NO_MAIN
WorkSpace * BKE_workspace_active_get(WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:633
Global G
Definition blender.cc:57
static void workspace_blend_read_data(BlendDataReader *reader, ID *id)
Definition workspace.cc:150
void BKE_viewer_path_foreach_id(LibraryForeachIDData *data, ViewerPath *viewer_path)
void BKE_workspace_instance_hook_free(const Main *bmain, WorkSpaceInstanceHook *hook)
Definition workspace.cc:400
WorkSpaceLayout * BKE_workspace_layout_add_from_layout(Main *bmain, WorkSpace &workspace_dst, const WorkSpaceLayout &layout_src, const int id_copy_flags)
Definition workspace.cc:445
WorkSpaceLayout * BKE_workspace_active_layout_for_workspace_get(const WorkSpaceInstanceHook *hook, const WorkSpace *workspace) GETTER_ATTRS
Definition workspace.cc:662
static WorkSpaceLayout * workspace_layout_find_exec(const WorkSpace *workspace, const bScreen *screen)
Definition workspace.cc:281
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
BMesh const char void * data
WorkSpace * BKE_workspace_add(Main *bmain, const char *name)
Definition workspace.cc:369
void BKE_workspace_active_layout_set(WorkSpaceInstanceHook *hook, int winid, WorkSpace *workspace, WorkSpaceLayout *layout) SETTER_ATTRS
Activate a layout.
Definition workspace.cc:675
WorkSpaceLayout * BKE_workspace_layout_find_global(const Main *bmain, const bScreen *screen, WorkSpace **r_workspace) ATTR_NONNULL(1
Definition workspace.cc:516
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
WorkSpaceLayout WorkSpaceLayout * BKE_workspace_layout_iter_circular(const WorkSpace *workspace, WorkSpaceLayout *start, bool(*callback)(const WorkSpaceLayout *layout, void *arg), void *arg, bool iter_backward)
Definition workspace.cc:540
static void workspace_relation_remove(ListBaseT< WorkSpaceDataRelation > *relation_list, WorkSpaceDataRelation *relation)
Definition workspace.cc:300
void BKE_asset_library_reference_init_default(AssetLibraryReference *library_ref)
Definition asset.cc:153
void BKE_id_free(Main *bmain, void *idv)
void BKE_viewer_path_blend_write(BlendWriter *writer, const ViewerPath *viewer_path)
static void workspace_free_data(ID *id)
Definition workspace.cc:55
void BKE_workspace_relations_free(ListBaseT< WorkSpaceDataRelation > *relation_list)
Definition workspace.cc:483
Main * BLO_read_lib_get_main(BlendLibReader *reader)
Definition readfile.cc:6853
WorkSpaceInstanceHook * BKE_workspace_instance_hook_create(const Main *bmain, int winid)
Definition workspace.cc:387
void id_us_ensure_real(ID *id)
Definition lib_id.cc:388
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void BKE_workspace_status_clear(WorkSpace *workspace)
Definition workspace.cc:720
IDTypeInfo IDType_ID_WS
Definition workspace.cc:226
@ INDEX_ID_WS
Definition DNA_ID.h:1355
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1403
static void workspace_relation_add(ListBaseT< WorkSpaceDataRelation > *relation_list, void *parent, const int parentid, void *data)
Definition workspace.cc:288
static void workspace_layout_name_set(WorkSpace *workspace, WorkSpaceLayout *layout, const char *new_name)
Definition workspace.cc:263
void * BLI_listbase_bytes_find(const ListBase *listbase, const void *bytes, size_t bytes_size, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
Definition listbase.cc:737
bScreen * BKE_workspace_layout_screen_get(const WorkSpaceLayout *layout) GETTER_ATTRS
Definition workspace.cc:709
void BKE_workspace_remove(Main *bmain, WorkSpace *workspace)
Definition workspace.cc:376
void void BKE_workspace_tool_id_replace_table(WorkSpace *workspace, const int space_type, const int mode, const char *idname_prefix_skip, const char *replace_table[][2], int replace_table_num) ATTR_NONNULL(1
Definition workspace.cc:581
void BKE_workspace_layout_remove(Main *bmain, WorkSpace *workspace, WorkSpaceLayout *layout) ATTR_NONNULL()
Definition workspace.cc:472
void BKE_main_id_tag_listbase(ListBaseT< ID > *lb, int tag, bool value)
Definition lib_id.cc:1291
bool BKE_screen_is_fullscreen_area(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:1293
WorkSpaceLayout * BKE_workspace_active_layout_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:657
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
Definition lib_id.cc:851
@ IDWALK_CB_DIRECT_WEAK_LINK
void BKE_workspace_tool_remove(WorkSpace *workspace, bToolRef *tref) ATTR_NONNULL(1
Definition workspace.cc:569
static void workspace_foreach_id(ID *id, LibraryForeachIDData *data)
Definition workspace.cc:117
void BKE_viewer_path_clear(ViewerPath *viewer_path)
static bool workspaces_is_screen_used(const Main *bmain, bScreen *screen)
Definition workspace.cc:350
void id_us_min(ID *id)
Definition lib_id.cc:441
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
const char * BKE_workspace_layout_name_get(const WorkSpaceLayout *layout) GETTER_ATTRS
Definition workspace.cc:698
WorkSpaceLayout * BKE_workspace_layout_find(const WorkSpace *workspace, const bScreen *screen) ATTR_NONNULL() ATTR_WARN_UNUSED_RESULT
Definition workspace.cc:499
bool BLI_string_replace_table_exact(char *string, size_t string_maxncpy, const char *replace_table[][2], int replace_table_len)
@ IDTYPE_FLAGS_NO_MEMFILE_UNDO
Definition BKE_idtype.hh:59
@ IDTYPE_FLAGS_NO_ANIMDATA
Definition BKE_idtype.hh:52
@ IDTYPE_FLAGS_ONLY_APPEND
Definition BKE_idtype.hh:44
@ IDTYPE_FLAGS_NEVER_UNUSED
Definition BKE_idtype.hh:73
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_list(const ListBaseT< T > *list, BlendStructWriterTypedFn< T > fn=nullptr)
char name[258]
Definition DNA_ID.h:433
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< WorkSpace > workspaces
Definition BKE_main.hh:423
struct WorkSpaceLayout * act_layout
bke::WorkSpaceRuntime * runtime
ListBaseT< WorkSpaceLayout > layouts
ListBaseT< struct WorkSpaceDataRelation > hook_layout_relations
AssetLibraryReference asset_library_ref
struct Scene * sequencer_scene
ListBaseT< wmOwnerID > owner_ids
ListBaseT< bToolRef > tools
ListBaseT< struct ScrArea > areabase
bToolRef_Runtime * runtime
Vector< WorkSpaceStatusItem > status
struct WorkSpaceInstanceHook * workspace_hook
#define N_(msgid)