Blender V5.3
screen.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9/* Allow using deprecated functionality for .blend file I/O. */
10#define DNA_DEPRECATED_ALLOW
11
12#ifdef WIN32
13# include "BLI_winstuff.hh"
14#endif
15
16#include <fmt/format.h>
17
18#include <cmath>
19#include <cstdio>
20#include <cstring>
21
22#include "MEM_guardedalloc.h"
23
24#include "DNA_scene_types.h"
25#include "DNA_screen_types.h"
26#include "DNA_space_types.h"
27#include "DNA_userdef_types.h"
28#include "DNA_view3d_types.h"
29
30#include "BLI_listbase.hh"
31#include "BLI_math_matrix_c.hh"
33#include "BLI_math_vector_c.hh"
34#include "BLI_rect.hh"
35#include "BLI_string.hh"
36#include "BLI_string_utf8.hh"
37#include "BLI_utildefines.hh"
38
39#include "BLT_translation.hh"
40
41#include "BKE_idprop.hh"
42#include "BKE_idtype.hh"
43#include "BKE_lib_id.hh"
44#include "BKE_lib_query.hh"
45#include "BKE_preview_image.hh"
46#include "BKE_screen.hh"
47
48#include "BLO_read_write.hh"
49
50/* TODO(@JulianEisel): For asset shelf region reading/writing. Region read/write should be done via
51 * a #ARegionType callback. */
53
54#ifdef WITH_PYTHON
55# include "BPY_extern.hh"
56#endif
57
58#include "WM_types.hh"
59
60#include "CLG_log.h"
61
62namespace blender {
63
64static CLG_LogRef LOG_BLEND_DOVERSION = {"blend.doversion"};
65
66/* -------------------------------------------------------------------- */
69
70static void screen_init_data(ID *id)
71{
72 bScreen *screen = id_cast<bScreen *>(id);
73
74 screen->do_draw = true;
75 screen->do_refresh = true;
77}
78
79static void screen_free_data(ID *id)
80{
81 bScreen *screen = id_cast<bScreen *>(id);
82
83 /* No animation-data here. */
84
85 for (ARegion &region : screen->regionbase) {
86 BKE_area_region_free(nullptr, &region);
87 }
88
89 screen->regionbase.free_no_destruct();
90
92
93 BKE_previewimg_id_free(&screen->id);
94
95 /* Region and timer are freed by the window manager. */
96 /* Cannot use MEM_SAFE_DELETE, as #wmTooltipState type is only defined in `WM_types.hh`, which is
97 * currently not included here. */
98 if (screen->tool_tip) {
99 MEM_delete_void(static_cast<void *>(screen->tool_tip));
100 screen->tool_tip = nullptr;
101 }
102}
103
104static void screen_copy_data(Main * /*bmain*/,
105 std::optional<Library *> owner_library,
106 ID *id_dst,
107 const ID *id_src,
108 int flag)
109{
110 /* Workspaces should always be local data currently. */
111 BLI_assert(!owner_library || owner_library == nullptr);
112 UNUSED_VARS_NDEBUG(owner_library);
113
114 bScreen *screen_dst = id_cast<bScreen *>(id_dst);
115 const bScreen *screen_src = id_cast<const bScreen *>(id_src);
116
117 screen_dst->do_draw = true;
118 screen_dst->do_refresh = true;
120
121 screen_dst->state = SCREENNORMAL;
122
123 screen_dst->flag = screen_src->flag;
124
125 BLI_duplicatelist(&screen_dst->vertbase, &screen_src->vertbase);
126 BLI_duplicatelist(&screen_dst->edgebase, &screen_src->edgebase);
127 BLI_duplicatelist(&screen_dst->areabase, &screen_src->areabase);
128 screen_dst->regionbase.clear_no_delete();
129
130 {
131 ScrVert *sv_dst = screen_dst->vertbase.first();
132 ScrVert *sv_src = screen_src->vertbase.first();
133 for (; sv_dst && sv_src; sv_dst = sv_dst->next, sv_src = sv_src->next) {
134 sv_src->newv = sv_dst;
135 }
136 }
137
138 for (ScrEdge &se_dst : screen_dst->edgebase) {
139 se_dst.v1 = se_dst.v1->newv;
140 se_dst.v2 = se_dst.v2->newv;
141 }
142
143 {
144 ScrArea *area_dst = screen_dst->areabase.first();
145 ScrArea *area_src = screen_src->areabase.first();
146 for (; area_dst && area_src; area_dst = area_dst->next, area_src = area_src->next) {
147 area_dst->v1 = area_dst->v1->newv;
148 area_dst->v2 = area_dst->v2->newv;
149 area_dst->v3 = area_dst->v3->newv;
150 area_dst->v4 = area_dst->v4->newv;
151
152 area_dst->spacedata.clear_no_delete();
153 area_dst->regionbase.clear_no_delete();
154 area_dst->actionzones.clear_no_delete();
155 area_dst->handlers.clear_no_delete();
156
157 BKE_area_copy(area_dst, area_src);
158 }
159 }
160
161 /* Cleanup: reset temp data. */
162 for (ScrVert &sv_src : screen_src->vertbase) {
163 sv_src.newv = nullptr;
164 }
165
166 screen_dst->active_region = nullptr;
167 screen_dst->animtimer = nullptr;
168 screen_dst->context = nullptr;
169 screen_dst->tool_tip = nullptr;
170
171 if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
172 BKE_previewimg_id_copy(&screen_dst->id, &screen_src->id);
173 }
174 else {
175 screen_dst->preview = nullptr;
176 }
177}
178
180{
182
183 for (SpaceLink &sl : area->spacedata) {
184 SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
185
186 if (space_type && space_type->foreach_id) {
187 space_type->foreach_id(&sl, data);
188 }
189 }
190}
191
193{
194 bScreen *screen = reinterpret_cast<bScreen *>(id);
196
199 }
200
201 if (flag & IDWALK_INCLUDE_UI) {
202 for (ScrArea &area : screen->areabase) {
205 }
206 }
207}
208
209static void screen_blend_write(BlendWriter *writer, ID *id, const void *id_address)
210{
211 bScreen *screen = id_cast<bScreen *>(id);
212
213 /* write LibData */
214 /* in 2.50+ files, the file identifier for screens is patched, forward compatibility */
215 writer->write_id_struct(
216 ID_SCRN, id_address, screen, [](BlendStructWriter<bScreen> &struct_writer) {
217 bScreen &shallow_screen = struct_writer.shallow_data;
218 shallow_screen.do_draw = 0;
219 shallow_screen.do_refresh = 0;
220 shallow_screen.do_draw_gesture = 0;
221 shallow_screen.do_draw_paintcursor = 0;
222 shallow_screen.do_draw_drag = 0;
223 shallow_screen.skip_handling = 0;
224 shallow_screen.scrubbing = 0;
225 shallow_screen.active_region = nullptr;
226 shallow_screen.animtimer = nullptr;
227 shallow_screen.context = nullptr;
228 shallow_screen.tool_tip = nullptr;
229 });
230 BKE_id_blend_write(writer, &screen->id);
231
232 BKE_previewimg_blend_write(writer, screen->preview);
233
234 /* direct data */
236}
237
239{
240 bool success = true;
241
242 screen->regionbase.first_ = screen->regionbase.last_ = nullptr;
243 screen->context = nullptr;
244 screen->active_region = nullptr;
245 screen->animtimer = nullptr; /* saved in rare cases */
246 screen->tool_tip = nullptr;
247 screen->scrubbing = false;
248
249 BLO_read_struct(reader, PreviewImage, &screen->preview);
250 BKE_previewimg_blend_read(reader, screen->preview);
251
253 printf("Error reading Screen %s... removing it.\n", screen->id.name + 2);
254 success = false;
255 }
256
257 return success;
258}
259
260/* NOTE: file read without screens option G_FILE_NO_UI;
261 * check lib pointers in call below */
263{
264 bScreen *screen = reinterpret_cast<bScreen *>(id);
265
266 for (ScrArea &area : screen->areabase) {
267 BKE_screen_area_blend_read_after_liblink(reader, &screen->id, &area);
268 }
269}
270
272 .id_code = bScreen::id_type,
273 .id_filter = FILTER_ID_SCR,
274 /* NOTE: Can actually link to any ID type through UI (e.g. Outliner Editor).
275 * This is handled separately though. */
276 .dependencies_id_types = FILTER_ID_SCE,
277 .main_listbase_index = INDEX_ID_SCR,
278 .struct_size = sizeof(bScreen),
279 .name = "Screen",
280 .name_plural = N_("screens"),
281 .translation_context = BLT_I18NCONTEXT_ID_SCREEN,
283 .asset_type_info = nullptr,
284
285 .init_data = screen_init_data,
286 .copy_data = screen_copy_data,
287 .free_data = screen_free_data,
288 .make_local = nullptr,
289 .foreach_id = screen_foreach_id,
290 .foreach_cache = nullptr,
291 .foreach_path = nullptr,
292 .foreach_working_space_color = nullptr,
293 .foreach_asset_weak_reference = nullptr,
294 .owner_pointer_get = nullptr,
295
296 .blend_write = screen_blend_write,
297 /* Cannot be used yet, because #direct_link_screen has a return value. */
298 .blend_read_data = nullptr,
299 .blend_read_after_liblink = screen_blend_read_after_liblink,
300
301 .blend_read_undo_preserve = nullptr,
302
303 .lib_override_apply_post = nullptr,
304};
305
307
308/* -------------------------------------------------------------------- */
311
314{
315 static Vector<std::unique_ptr<SpaceType>> space_types;
316 return space_types;
317}
318
319/* not SpaceType itself */
321{
322 for (ARegionType &art : this->regiontypes) {
323#ifdef WITH_PYTHON
325#endif
326 art.drawcalls.free_no_destruct();
327
328 for (PanelType &pt : art.paneltypes) {
329 if (pt.rna_ext.free) {
330 pt.rna_ext.free(pt.rna_ext.data);
331 }
332
333 pt.children.free_no_destruct();
334 }
335
336 for (HeaderType &ht : art.headertypes) {
337 if (ht.rna_ext.free) {
338 ht.rna_ext.free(ht.rna_ext.data);
339 }
340 }
341
342 art.paneltypes.free_no_destruct();
343 art.headertypes.free_no_destruct();
344 }
345
346 this->regiontypes.free_no_destruct();
347}
348
350{
351 get_space_types().clear_and_shrink();
352}
353
355{
356 for (std::unique_ptr<SpaceType> &st : get_space_types()) {
357 if (st->spaceid == spaceid) {
358 return st.get();
359 }
360 }
361 return nullptr;
362}
363
365{
366 for (ARegionType &art : st->regiontypes) {
367 if (art.regionid == regionid) {
368 return &art;
369 }
370 }
371 return nullptr;
372}
373
378
379void BKE_spacetype_register(std::unique_ptr<SpaceType> st)
380{
381 BLI_assert(st->struct_size >= int(sizeof(SpaceLink)));
382
383 /* sanity check */
384 SpaceType *stype = BKE_spacetype_from_id(st->spaceid);
385 if (stype) {
386 printf("error: redefinition of spacetype %s\n", stype->name);
387 return;
388 }
389
390 get_space_types().append(std::move(st));
391}
392
393bool BKE_spacetype_exists(int spaceid)
394{
395 return BKE_spacetype_from_id(spaceid) != nullptr;
396}
397
399{
400 if (BKE_regiontype_uses_category_tabs(region_type)) {
401 return true;
402 }
403
404 return bool(region_type->flag & ARegionTypeFlag::UsePanelCategories);
405}
406
408{
409 /* Some region types always support category tabs. */
410 if (ELEM(region_type->regionid, RGN_TYPE_UI)) {
411 return true;
412 }
413
414 return bool(region_type->flag & ARegionTypeFlag::UsePanelCategoryTabs);
415}
416
418{
419 return bool(region_type->flag & ARegionTypeFlag::UsePanelCategoriesSearch);
420}
421
427
429
430/* -------------------------------------------------------------------- */
433
434void BKE_spacedata_freelist(ListBaseT<SpaceLink> *lb)
435{
436 for (SpaceLink &sl : *lb) {
437 SpaceType *st = BKE_spacetype_from_id(sl.spacetype);
438
439 /* free regions for pushed spaces */
440 for (ARegion &region : sl.regionbase) {
441 BKE_area_region_free(st, &region);
442 }
443
444 sl.regionbase.free_no_destruct();
445
446 if (st && st->free) {
447 st->free(&sl);
448 }
449 }
450
451 lb->free_no_destruct();
452}
453
454static void panel_list_copy(ListBaseT<Panel> *newlb, const ListBaseT<Panel> *lb)
455{
456 newlb->clear_no_delete();
457
458 for (const Panel &old_panel : *lb) {
459 Panel *new_panel = BKE_panel_new(old_panel.type);
460 Panel_Runtime *new_runtime = new_panel->runtime;
461 *new_panel = old_panel;
462 new_panel->runtime = new_runtime;
463 new_panel->activedata = nullptr;
464 new_panel->drawname = nullptr;
465
466 new_panel->layout_panel_states.clear_no_delete();
467 new_panel->layout_panel_states_clock = old_panel.layout_panel_states_clock;
468 for (LayoutPanelState &src_state : old_panel.layout_panel_states) {
469 LayoutPanelState *new_state = MEM_new<LayoutPanelState>(__func__, src_state);
470 new_state->idname = BLI_strdup(src_state.idname);
471 BLI_addtail(&new_panel->layout_panel_states, new_state);
472 }
473
474 BLI_addtail(newlb, new_panel);
475 panel_list_copy(&new_panel->children, &old_panel.children);
476 }
477}
478
480{
481 ARegion *dst = MEM_dupalloc(region);
482
483 dst->runtime = MEM_new<bke::ARegionRuntime>(__func__);
484 dst->runtime->type = region->runtime->type;
485 dst->runtime->do_draw = region->runtime->do_draw;
486
487 dst->prev = dst->next = nullptr;
488 dst->panels_category_active.clear_no_delete();
489 dst->ui_lists.clear_no_delete();
490
491 /* use optional regiondata callback */
492 if (region->regiondata) {
494
495 if (art && art->duplicate) {
496 dst->regiondata = art->duplicate(region->regiondata);
497 }
498 else if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
499 dst->regiondata = nullptr;
500 }
501 else {
503 }
504 }
505
506 panel_list_copy(&dst->panels, &region->panels);
507
508 dst->ui_previews.clear_no_delete();
510 dst->view_states.clear_no_delete();
512 dst->textbox_states.clear_no_delete();
513 for (const uiTextboxStateLink &textbox_state : region->textbox_states) {
514 uiTextboxStateLink *copy = MEM_new<uiTextboxStateLink>("uiTextboxStateLink", textbox_state);
515 copy->idname = BLI_strdup(textbox_state.idname);
516 BLI_addtail(&dst->textbox_states, copy);
517 }
518
519 return dst;
520}
521
523{
524 ARegion *region = MEM_new<ARegion>(__func__);
525 region->runtime = MEM_new<bke::ARegionRuntime>(__func__);
526 return region;
527}
528
529/* from lb_src to lb_dst, lb_dst is supposed to be freed */
530static void region_copylist(SpaceType *st, ListBaseT<ARegion> *lb_dst, ListBaseT<ARegion> *lb_src)
531{
532 /* to be sure */
533 lb_dst->clear_no_delete();
534
535 for (ARegion &region : *lb_src) {
536 ARegion *region_new = BKE_area_region_copy(st, &region);
537 BLI_addtail(lb_dst, region_new);
538 }
539}
540
541void BKE_spacedata_copylist(ListBaseT<SpaceLink> *lb_dst, ListBaseT<SpaceLink> *lb_src)
542{
543 lb_dst->clear_no_delete(); /* to be sure */
544
545 for (SpaceLink &sl : *lb_src) {
546 SpaceType *st = BKE_spacetype_from_id(sl.spacetype);
547
548 if (st && st->duplicate) {
549 SpaceLink *slnew = st->duplicate(&sl);
550
551 BLI_addtail(lb_dst, slnew);
552
553 region_copylist(st, &slnew->regionbase, &sl.regionbase);
554 }
555 }
556}
557
559{
560 for (std::unique_ptr<SpaceType> &st : get_space_types()) {
561 for (ARegionType &art : st->regiontypes) {
562 if (lock_flags != 0) {
563 art.do_lock = (art.lock & lock_flags);
564 }
565 else {
566 art.do_lock = 0;
567 }
568 }
569 }
570}
571
573 const ScrArea *area,
574 int region_type)
575{
576 const bool is_slink_active = slink == area->spacedata.first();
577 const ListBaseT<ARegion> *regionbase = (is_slink_active) ? &area->regionbase :
578 &slink->regionbase;
579 ARegion *region = nullptr;
580
581 BLI_assert(BLI_findindex(&area->spacedata, slink) != -1);
582
583 for (ARegion &region_iter : *regionbase) {
584 if (region_iter.regiontype == region_type) {
585 region = &region_iter;
586 break;
587 }
588 }
589
590 /* Should really unit test this instead. */
591 BLI_assert(!is_slink_active || region == BKE_area_find_region_type(area, region_type));
592
593 return region;
594}
595
596static void (*spacedata_id_remap_cb)(ScrArea *area,
597 SpaceLink *sl,
598 ID *old_id,
599 ID *new_id) = nullptr;
600
601void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *area, SpaceLink *sl, ID *, ID *))
602{
604}
605
607{
609 spacedata_id_remap_cb(area, sl, id, nullptr);
610 }
611}
612
617
622
624{
626 return;
627 }
628
629 for (ScrArea &area : screen->areabase) {
630 for (ARegion &region : area.regionbase) {
631 if (region.runtime->gizmo_map != nullptr) {
633 }
634 }
635 }
636}
637
639{
640 for (ScrArea &area : screen->areabase) {
641 area.runtime.tool = nullptr;
642 area.runtime.is_tool_set = false;
643 }
644}
645
649static void (*region_free_gizmomap_callback)(wmGizmoMap *) = nullptr;
650
652{
654}
655
657 const StringRef idname,
658 const bool default_closed)
659{
660 ListBaseT<LayoutPanelState> &layout_panel_states =
662 panel->layout_panel_states;
663 const uint32_t logical_time = ++panel->layout_panel_states_clock;
664 /* Overflow happened, reset all last used times. Not sure if this will ever happen in practice,
665 * but better handle the overflow explicitly. */
666 if (logical_time == 0) {
667 for (LayoutPanelState &state : layout_panel_states) {
668 state.last_used = 0;
669 }
670 }
671 for (LayoutPanelState &state : layout_panel_states) {
672 if (state.idname == idname) {
673 state.last_used = logical_time;
674 return &state;
675 }
676 }
677 LayoutPanelState *state = MEM_new<LayoutPanelState>(__func__);
678 state->idname = BLI_strdupn(idname.data(), idname.size());
680 state->last_used = logical_time;
681 BLI_addtail(&layout_panel_states, state);
682 return state;
683}
684
686{
687 Panel *panel = MEM_new<Panel>(__func__);
688 panel->runtime = MEM_new<Panel_Runtime>(__func__);
689 panel->type = panel_type;
690 if (panel_type) {
691 STRNCPY_UTF8(panel->panelname, panel_type->idname);
692 }
693 return panel;
694}
695
697{
698 MEM_delete(state->idname);
699 MEM_delete(state);
700}
701
703{
704 MEM_SAFE_DELETE_VOID(panel->activedata);
705 MEM_SAFE_DELETE(panel->drawname);
706
707 for (LayoutPanelState &state : panel->layout_panel_states.items_mutable()) {
710 }
711
712 MEM_delete(panel->runtime);
713 MEM_delete(panel);
714}
715
717{
718 for (Panel &child_panel : panel->children.items_mutable()) {
720 }
721 BKE_panel_free(panel);
722}
723
724void BKE_area_region_panels_free(ListBaseT<Panel> *panels)
725{
726 for (Panel &panel : panels->items_mutable()) {
727 /* Delete custom data just for parent panels to avoid a double deletion. */
728 if (panel.runtime->custom_data_ptr) {
729 MEM_delete(panel.runtime->custom_data_ptr);
730 }
732 }
733 panels->clear_no_delete();
734}
735
737{
738 if (st) {
740
741 if (art && art->free) {
742 art->free(region);
743 }
744
745 if (region->regiondata && !(region->flag & RGN_FLAG_TEMP_REGIONDATA)) {
746 printf("regiondata free error\n");
747 }
748 }
749 else if (region->runtime->type && region->runtime->type->free) {
750 region->runtime->type->free(region);
751 }
752
754
755 for (uiList &uilst : region->ui_lists) {
756 if (uilst.dyn_data && uilst.dyn_data->free_runtime_data_fn) {
757 uilst.dyn_data->free_runtime_data_fn(&uilst);
758 }
759 if (uilst.properties) {
761 }
762 MEM_SAFE_DELETE(uilst.dyn_data);
763 }
764
765 if (region->runtime->gizmo_map != nullptr) {
767 }
768
769 region->ui_lists.free_no_destruct();
770 region->ui_previews.free_no_destruct();
771 region->runtime->panels_category.free_no_destruct();
772 region->panels_category_active.free_no_destruct();
773 region->view_states.free_no_destruct();
774 for (uiTextboxStateLink &textbox_state : region->textbox_states.items_mutable()) {
775 BLI_remlink(&region->textbox_states, &textbox_state);
776 MEM_delete(textbox_state.idname);
777 MEM_delete(&textbox_state);
778 }
779
780 MEM_delete(region->runtime);
781}
782
784{
786
787 for (ARegion &region : area->regionbase) {
788 BKE_area_region_free(st, &region);
789 }
790
791 MEM_SAFE_DELETE(area->global);
792 area->regionbase.free_no_destruct();
793
795
796 area->actionzones.free_no_destruct();
797}
798
800{
801 for (ScrArea &area : area_map->areabase.items_mutable()) {
803 }
804
805 area_map->vertbase.free_no_destruct();
806 area_map->edgebase.free_no_destruct();
807 area_map->areabase.free_no_destruct();
808}
809
811{
812 screen_free_data(&screen->id);
813}
814
815void BKE_screen_copy_data(bScreen *screen_dst, const bScreen *screen_src)
816{
817 screen_copy_data(nullptr, std::nullopt, &screen_dst->id, &screen_src->id, 0);
818}
819
821
822/* -------------------------------------------------------------------- */
825
827 const ScrVert *a2,
828 const ScrVert *b1,
829 const ScrVert *b2)
830{
831 if (a1 == b1 && a2 == b2) {
832 return true;
833 }
834 if (a1 == b2 && a2 == b1) {
835 return true;
836 }
837 return false;
838}
839
841{
842 for (ScrEdge &se : screen->edgebase) {
843 if (BKE_screen_scredge_equals(se.v1, se.v2, v1, v2)) {
844 return &se;
845 }
846 }
847
848 return nullptr;
849}
850
852{
853 for (ScrVert &verg : screen->vertbase) {
854 if (verg.newv == nullptr) { /* !!! */
855 ScrVert *v1 = verg.next;
856 while (v1) {
857 if (v1->newv == nullptr) { /* !?! */
858 if (v1->vec.x == verg.vec.x && v1->vec.y == verg.vec.y) {
859 // printf("doublevert\n");
860 v1->newv = &verg;
861 }
862 }
863 v1 = v1->next;
864 }
865 }
866 }
867
868 /* replace pointers in edges and faces */
869 for (ScrEdge &se : screen->edgebase) {
870 if (se.v1->newv) {
871 se.v1 = se.v1->newv;
872 }
873 if (se.v2->newv) {
874 se.v2 = se.v2->newv;
875 }
876 }
877 for (ScrArea &area : screen->areabase) {
878 if (area.v1->newv) {
879 area.v1 = area.v1->newv;
880 }
881 if (area.v2->newv) {
882 area.v2 = area.v2->newv;
883 }
884 if (area.v3->newv) {
885 area.v3 = area.v3->newv;
886 }
887 if (area.v4->newv) {
888 area.v4 = area.v4->newv;
889 }
890 }
891
892 /* remove */
893 for (ScrVert &verg : screen->vertbase.items_mutable()) {
894 if (verg.newv) {
895 BLI_remlink(&screen->vertbase, &verg);
896 MEM_delete(&verg);
897 }
898 }
899}
900
902{
903 /* compare */
904 for (ScrEdge &verg : screen->edgebase) {
905 ScrEdge *se = verg.next;
906 while (se) {
907 ScrEdge *sn = se->next;
908 if (BKE_screen_scredge_equals(verg.v1, verg.v2, se->v1, se->v2)) {
909 BLI_remlink(&screen->edgebase, se);
910 MEM_delete(se);
911 }
912 se = sn;
913 }
914 }
915}
916
918{
919 /* sets flags when edge is used in area */
920
921 for (const auto [a, area] : screen->areabase.enumerate()) {
922 ScrEdge *se = BKE_screen_find_edge(screen, area.v1, area.v2);
923 if (se == nullptr) {
924 printf("error: area %d edge 1 doesn't exist\n", a);
925 }
926 else {
927 se->flag = 1;
928 }
929 se = BKE_screen_find_edge(screen, area.v2, area.v3);
930 if (se == nullptr) {
931 printf("error: area %d edge 2 doesn't exist\n", a);
932 }
933 else {
934 se->flag = 1;
935 }
936 se = BKE_screen_find_edge(screen, area.v3, area.v4);
937 if (se == nullptr) {
938 printf("error: area %d edge 3 doesn't exist\n", a);
939 }
940 else {
941 se->flag = 1;
942 }
943 se = BKE_screen_find_edge(screen, area.v4, area.v1);
944 if (se == nullptr) {
945 printf("error: area %d edge 4 doesn't exist\n", a);
946 }
947 else {
948 se->flag = 1;
949 }
950 }
951 for (ScrEdge &se : screen->edgebase.items_mutable()) {
952 if (se.flag == 0) {
953 BLI_remlink(&screen->edgebase, &se);
954 MEM_delete(&se);
955 }
956 else {
957 se.flag = 0;
958 }
959 }
960}
961
963{
964 /* we assume edges are ok */
965 for (ScrEdge &se : screen->edgebase) {
966 se.v1->flag = 1;
967 se.v2->flag = 1;
968 }
969
970 for (ScrVert &sv : screen->vertbase.items_mutable()) {
971 if (sv.flag == 0) {
972 BLI_remlink(&screen->vertbase, &sv);
973 MEM_delete(&sv);
974 }
975 else {
976 sv.flag = 0;
977 }
978 }
979}
980
982
983/* -------------------------------------------------------------------- */
986
987ARegion *BKE_region_find_in_listbase_by_type(const ListBaseT<ARegion> *regionbase,
988 const int region_type)
989{
990 for (ARegion &region : *regionbase) {
991 if (region.regiontype == region_type) {
992 return &region;
993 }
994 }
995
996 return nullptr;
997}
998
999void BKE_area_copy(ScrArea *area_dst, ScrArea *area_src)
1000{
1001 constexpr eScrArea_Flag flag_copy = HEADER_NO_PULLDOWN;
1002
1003 area_dst->spacetype = area_src->spacetype;
1004 area_dst->type = area_src->type;
1005
1006 /* Remove 'restore from fullscreen' data from the new copy. */
1007 area_dst->full = nullptr;
1008
1009 area_dst->flag = (area_dst->flag & ~flag_copy) | (area_src->flag & flag_copy);
1010
1011 /* Spaces. */
1012 BKE_spacedata_copylist(&area_dst->spacedata, &area_src->spacedata);
1013
1014 /* Regions. */
1015 area_dst->regionbase.clear_no_delete();
1016 /* NOTE: SPACE_EMPTY is possible on new screens. */
1017 SpaceType *st = BKE_spacetype_from_id(area_src->spacetype);
1018 for (ARegion &region_src : area_src->regionbase) {
1019 ARegion *region_dst = BKE_area_region_copy(st, &region_src);
1020 BLI_addtail(&area_dst->regionbase, region_dst);
1021 }
1022}
1023
1024ARegion *BKE_area_find_region_type(const ScrArea *area, int region_type)
1025{
1026 if (area) {
1027 for (ARegion &region : area->regionbase) {
1028 if (region.regiontype == region_type) {
1029 return &region;
1030 }
1031 }
1032 }
1033
1034 return nullptr;
1035}
1036
1038{
1039 if (area == nullptr) {
1040 return nullptr;
1041 }
1042
1043 ARegion *region = static_cast<ARegion *>(
1045 if (region && (region->regiontype == RGN_TYPE_WINDOW)) {
1046 return region;
1047 }
1048
1049 /* fall back to any */
1051}
1052
1053ARegion *BKE_area_find_region_xy(const ScrArea *area, const int regiontype, const int xy[2])
1054{
1055 if (area == nullptr) {
1056 return nullptr;
1057 }
1058
1059 for (ARegion &region : area->regionbase) {
1060 if (ELEM(regiontype, RGN_TYPE_ANY, region.regiontype)) {
1061 if (BLI_rcti_isect_pt_v(&region.winrct, xy)) {
1062 return &region;
1063 }
1064 }
1065 }
1066 return nullptr;
1067}
1068
1069ARegion *BKE_screen_find_region_type(const bScreen *screen, const int region_type)
1070{
1071 for (ARegion &region : screen->regionbase) {
1072 if (region_type == region.regiontype) {
1073 return &region;
1074 }
1075 }
1076 return nullptr;
1077}
1078
1079ARegion *BKE_screen_find_region_xy(const bScreen *screen, const int regiontype, const int xy[2])
1080{
1081 for (ARegion &region : screen->regionbase) {
1082 if (ELEM(regiontype, RGN_TYPE_ANY, region.regiontype)) {
1083 if (BLI_rcti_isect_pt_v(&region.winrct, xy)) {
1084 return &region;
1085 }
1086 }
1087 }
1088 return nullptr;
1089}
1090
1092{
1093 for (ScrArea &area : screen->areabase) {
1094 if (BLI_findindex(&area.spacedata, sl) != -1) {
1095 return &area;
1096 }
1097 }
1098
1099 return nullptr;
1100}
1101
1103 const SpaceLink *sl,
1104 const int region_type)
1105{
1106 for (ScrArea &area : screen->areabase) {
1107 for (SpaceLink &slink : area.spacedata) {
1108 if (&slink == sl) {
1109 ListBaseT<ARegion> *regionbase = (&slink == area.spacedata.first()) ? &area.regionbase :
1110 &slink.regionbase;
1111 return BKE_region_find_in_listbase_by_type(regionbase, region_type);
1112 }
1113 }
1114 }
1115 return nullptr;
1116}
1117
1118std::optional<std::string> BKE_screen_path_to_space(const PointerRNA *ptr)
1119{
1120 const SpaceLink *link = static_cast<const SpaceLink *>(ptr->data);
1121
1122 switch (ptr->owner_id->id_type()) {
1123 case ID_SCR: {
1124 const bScreen *screen = id_cast<const bScreen *>(ptr->owner_id);
1125
1126 for (const auto [area_index, area] : screen->areabase.enumerate()) {
1127 const int space_index = BLI_findindex(&area.spacedata, link);
1128 if (space_index != -1) {
1129 return fmt::format("areas[{}].spaces[{}]", area_index, space_index);
1130 }
1131 }
1132 break;
1133 }
1134 case ID_WM: {
1135 const wmWindowManager *wm = id_cast<const wmWindowManager *>(ptr->owner_id);
1136
1137 for (const auto [win_index, win] : wm->windows.enumerate()) {
1138 for (const auto [area_index, area] : win.global_areas.areabase.enumerate()) {
1139 const int space_index = BLI_findindex(&area.spacedata, link);
1140 if (space_index != -1) {
1141 return fmt::format(
1142 "windows[{}].global_areas[{}].spaces[{}]", win_index, area_index, space_index);
1143 }
1144 }
1145 }
1146 break;
1147 }
1148 default:
1149 break;
1150 }
1151
1153 return std::nullopt;
1154}
1155
1156std::optional<std::string> BKE_screen_path_to_area(const PointerRNA *ptr)
1157{
1158 const ScrArea *area = static_cast<const ScrArea *>(ptr->data);
1159
1160 switch (ptr->owner_id->id_type()) {
1161 case ID_SCR: {
1162 const bScreen *screen = id_cast<const bScreen *>(ptr->owner_id);
1163 const int area_index = BLI_findindex(&screen->areabase, area);
1164 if (area_index == -1) {
1165 return std::nullopt;
1166 }
1167
1168 return fmt::format("areas[{}]", area_index);
1169 }
1170 case ID_WM: {
1171 const wmWindowManager *wm = id_cast<const wmWindowManager *>(ptr->owner_id);
1172
1173 for (const auto [win_index, win] : wm->windows.enumerate()) {
1174 const int area_index = BLI_findindex(&win.global_areas.areabase, area);
1175 if (area_index != -1) {
1176 return fmt::format("windows[{}].global_areas[{}]", win_index, area_index);
1177 }
1178 }
1179 break;
1180 }
1181 default:
1182 break;
1183 }
1184
1186 return std::nullopt;
1187}
1188
1189ScrArea *BKE_screen_find_big_area(const bScreen *screen, const int spacetype, const short min)
1190{
1191 ScrArea *big = nullptr;
1192 int maxsize = 0;
1193
1194 for (ScrArea &area : screen->areabase) {
1195 if (ELEM(spacetype, SPACE_TYPE_ANY, area.spacetype)) {
1196 if (min <= area.winx && min <= area.winy) {
1197 int size = area.winx * area.winy;
1198 if (size > maxsize) {
1199 maxsize = size;
1200 big = &area;
1201 }
1202 }
1203 }
1204 }
1205
1206 return big;
1207}
1208
1210 const int spacetype,
1211 const int xy[2])
1212{
1213 for (ScrArea &area : areamap->areabase) {
1214 /* Test area's outer screen verts, not inner `area->totrct`. */
1215 if (xy[0] >= area.v1->vec.x && xy[0] <= area.v4->vec.x && xy[1] >= area.v1->vec.y &&
1216 xy[1] <= area.v2->vec.y)
1217 {
1218 if (ELEM(spacetype, SPACE_TYPE_ANY, area.spacetype)) {
1219 return &area;
1220 }
1221 break;
1222 }
1223 }
1224 return nullptr;
1225}
1226ScrArea *BKE_screen_find_area_xy(const bScreen *screen, const int spacetype, const int xy[2])
1227{
1228 return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(screen), spacetype, xy);
1229}
1230
1232{
1233 if (v3d->scenelock && v3d->localvd == nullptr) {
1234 v3d->camera = scene->camera;
1235
1236 if (v3d->camera == nullptr) {
1237 for (ARegion &region : v3d->regionbase) {
1238 if (region.regiontype == RGN_TYPE_WINDOW) {
1239 RegionView3D *rv3d = static_cast<RegionView3D *>(region.regiondata);
1240 if (rv3d->persp == RV3D_CAMOB) {
1241 rv3d->persp = RV3D_PERSP;
1242 }
1243 }
1244 }
1245 }
1246 }
1247}
1248
1250{
1251 /* are there cameras in the views that are not in the scene? */
1252 for (ScrArea &area : screen->areabase) {
1253 for (SpaceLink &sl : area.spacedata) {
1254 if (sl.spacetype == SPACE_VIEW3D) {
1255 View3D *v3d = reinterpret_cast<View3D *>(&sl);
1256 BKE_screen_view3d_sync(v3d, scene);
1257 }
1258 }
1259 }
1260}
1261
1263{
1264 *shading = View3DShading();
1265}
1266
1268 const int space_type,
1269 const int xy[2])
1270{
1271 ScrArea *area = BKE_screen_find_area_xy(screen, space_type, xy);
1272 if (!area) {
1273 return nullptr;
1274 }
1275 return BKE_area_find_region_xy(area, RGN_TYPE_WINDOW, xy);
1276}
1277
1278/* Magic zoom calculation, no idea what it signifies, if you find out, tell me! -zr
1279 *
1280 * Simple, its magic dude! Well, to be honest,
1281 * this gives a natural feeling zooming with multiple keypad presses (ton). */
1282
1284{
1285 return powf((float(M_SQRT2) + camzoom / 50.0f), 2.0f) / 4.0f;
1286}
1287
1289{
1290 return ((sqrtf(4.0f * zoomfac) - float(M_SQRT2)) * 50.0f);
1291}
1292
1294{
1295 return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
1296}
1297
1298bool BKE_screen_is_used(const bScreen *screen)
1299{
1300 return (screen->winid != 0);
1301}
1302
1304{
1306 for (ScrArea &area : screen->areabase) {
1307 for (ARegion &region : area.regionbase) {
1309 if (ELEM(area.spacetype,
1310 SPACE_FILE,
1315 {
1316 region.alignment = RGN_ALIGN_TOP;
1317 continue;
1318 }
1319 region.alignment = alignment;
1320 }
1321 if (region.regiontype == RGN_TYPE_FOOTER) {
1322 if (ELEM(area.spacetype,
1323 SPACE_FILE,
1328 {
1329 region.alignment = RGN_ALIGN_BOTTOM;
1330 continue;
1331 }
1333 }
1334 }
1335 }
1336 screen->do_refresh = true;
1337}
1338
1340
1341/* -------------------------------------------------------------------- */
1344
1346{
1347 if (shading->prop) {
1348 IDP_BlendWrite(writer, shading->prop);
1349 }
1350}
1351
1353{
1354 if (shading->prop) {
1355 BLO_read_struct(reader, IDProperty, &shading->prop);
1356 IDP_BlendDataRead(reader, &shading->prop);
1357 }
1358}
1359
1361{
1362 /* Some values like winmat/viewmat/viewinv/persmat/persinv/is_persp/pixsize are derived but are
1363 * not zeroed. They can be read before they are recomputed when a file is newly loaded,
1364 * especially when running Blender in background mode. */
1366 zero_m4(rv3d.viewmatob);
1367 zero_m4(rv3d.persmatob);
1368 memset(rv3d.clip_local, 0, sizeof(rv3d.clip_local));
1369 zero_m4(rv3d.twmat);
1370 zero_v3(rv3d.tw_axis_min);
1371 zero_v3(rv3d.tw_axis_max);
1372 zero_m3(rv3d.tw_axis_matrix);
1373 rv3d.twdrawflag = 0;
1375 rv3d.runtime_viewlock = {};
1376 rv3d.ndof_rot_angle = 0;
1377 zero_v3(rv3d.ndof_rot_axis);
1378 rv3d.view_render = nullptr;
1379 rv3d.sms = nullptr;
1380 rv3d.smooth_timer = nullptr;
1381}
1382
1383static void write_region(BlendWriter *writer, ARegion *region, int spacetype)
1384{
1385 writer->write_struct(region, [](BlendStructWriter<ARegion> &struct_writer) {
1386 ARegion &shallow_region = struct_writer.shallow_data;
1387 shallow_region.runtime = nullptr;
1391 shallow_region.v2d.sms = nullptr;
1392 shallow_region.v2d.smooth_timer = nullptr;
1393 shallow_region.v2d.scroll_ui = {};
1394 shallow_region.v2d.flag &= ~V2D_IS_NAVIGATING;
1395 /* Matches #direct_link_region. */
1396 shallow_region.v2d.alpha_hor = 255;
1397 shallow_region.v2d.alpha_vert = 255;
1398 /* For some region types, #View2D.tot is pure runtime data. */
1399 if (ELEM(shallow_region.regiontype,
1404 {
1405 shallow_region.v2d.tot = shallow_region.v2d.cur;
1406 }
1407 });
1408
1409 if (region->regiondata) {
1410 if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
1411 return;
1412 }
1413
1414 if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
1416 return;
1417 }
1418
1419 switch (spacetype) {
1420 case SPACE_VIEW3D:
1421 if (region->regiontype == RGN_TYPE_WINDOW) {
1422 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
1423 writer->write_struct(rv3d, [](BlendStructWriter<RegionView3D> &struct_writer) {
1425 });
1426
1427 if (rv3d->localvd) {
1428 writer->write_struct(rv3d->localvd,
1429 [](BlendStructWriter<RegionView3D> &struct_writer) {
1430 zero_regionview3d_runtime_fields(struct_writer.shallow_data);
1431 });
1432 }
1433 if (rv3d->clipbb) {
1434 writer->write_struct(rv3d->clipbb);
1435 }
1436 }
1437 else {
1438 printf("regiondata write missing!\n");
1439 }
1440 break;
1441 default:
1442 printf("regiondata write missing!\n");
1443 }
1444 }
1445}
1446
1447static void write_uilist(BlendWriter *writer, uiList *ui_list)
1448{
1449 writer->write_struct(ui_list);
1450
1451 if (ui_list->properties) {
1452 IDP_BlendWrite(writer, ui_list->properties);
1453 }
1454}
1455
1456static void write_panel_list(BlendWriter *writer, ListBaseT<Panel> *lb)
1457{
1458 for (Panel &panel : *lb) {
1459 writer->write_struct(&panel, [](BlendStructWriter<Panel> &struct_writer) {
1460 struct_writer.shallow_data.runtime_flag = 0;
1461 struct_writer.shallow_data.runtime = nullptr;
1462 });
1463 writer->write_struct_list(&panel.layout_panel_states);
1464 for (LayoutPanelState &state : panel.layout_panel_states) {
1465 writer->write_string(state.idname);
1466 }
1467 write_panel_list(writer, &panel.children);
1468 }
1469}
1470
1471static void write_area(BlendWriter *writer, ScrArea *area)
1472{
1473 for (ARegion &region : area->regionbase) {
1474 write_region(writer, &region, area->spacetype);
1475 write_panel_list(writer, &region.panels);
1476
1477 for (PanelCategoryStack &pc_act : region.panels_category_active) {
1478 writer->write_struct(&pc_act);
1479 }
1480
1481 for (uiList &ui_list : region.ui_lists) {
1482 write_uilist(writer, &ui_list);
1483 }
1484
1485 for (uiPreview &ui_preview : region.ui_previews) {
1486 writer->write_struct(&ui_preview, [](BlendStructWriter<uiPreview> &struct_writer) {
1487 struct_writer.shallow_data.tag = {};
1488 struct_writer.shallow_data.id_session_uid = 0;
1489 });
1490 }
1491
1492 for (uiViewStateLink &view_state : region.view_states) {
1493 writer->write_struct(&view_state);
1494 }
1495 for (uiTextboxStateLink &textbox_state : region.textbox_states) {
1496 writer->write_struct(&textbox_state);
1497 writer->write_string(textbox_state.idname);
1498 }
1499 }
1500
1501 for (SpaceLink &sl : area->spacedata) {
1502 for (ARegion &region : sl.regionbase) {
1503 write_region(writer, &region, sl.spacetype);
1504 }
1505
1506 SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
1507 if (space_type && space_type->blend_write) {
1508 space_type->blend_write(writer, &sl);
1509 }
1510 }
1511}
1512
1514{
1515 writer->write_struct_list(&area_map->vertbase);
1516 writer->write_struct_list(&area_map->edgebase);
1517 for (ScrArea &area : area_map->areabase) {
1518 area.butspacetype = area.spacetype; /* Just for compatibility, will be reset below. */
1519
1520 writer->write_struct(&area, [](BlendStructWriter<ScrArea> &struct_writer) {
1521 ScrArea &shallow_area = struct_writer.shallow_data;
1522 shallow_area.type = nullptr;
1523 shallow_area.do_refresh = 0;
1524 shallow_area.region_active_win = -1;
1527 shallow_area.handlers.clear_no_delete();
1528 shallow_area.actionzones.clear_no_delete();
1529 shallow_area.runtime = {};
1530 });
1531
1532 writer->write_struct(area.global);
1533
1534 write_area(writer, &area);
1535
1536 area.butspacetype = SPACE_EMPTY; /* Unset again, was changed above. */
1537 }
1538}
1539
1540static void remove_least_recently_used_panel_states(Panel &panel, const int64_t max_kept)
1541{
1544 all_states.append(&state);
1545 }
1546 if (all_states.size() <= max_kept) {
1547 return;
1548 }
1549 std::ranges::sort(all_states, [](const LayoutPanelState *a, const LayoutPanelState *b) {
1550 return a->last_used < b->last_used;
1551 });
1552 for (LayoutPanelState *state : all_states.as_span().drop_back(max_kept)) {
1555 }
1556}
1557
1558static void direct_link_panel_list(BlendDataReader *reader, ListBaseT<Panel> *lb)
1559{
1560 BLO_read_struct_list(reader, Panel, lb);
1561
1562 for (Panel &panel : *lb) {
1563 panel.runtime = MEM_new<Panel_Runtime>(__func__);
1564 panel.runtime_flag = 0;
1565 panel.activedata = nullptr;
1566 panel.type = nullptr;
1567 panel.drawname = nullptr;
1568 BLO_read_struct_list(reader, LayoutPanelState, &panel.layout_panel_states);
1569 for (LayoutPanelState &state : panel.layout_panel_states) {
1570 BLO_read_string(reader, &state.idname);
1571 }
1572 /* Reduce the number of panel states to a reasonable number. This avoids the list getting
1573 * arbitrarily large over time. Ideally this could be done more eagerly and not only when
1574 * loading the file. However, it's hard to make sure that no other code is currently
1575 * referencing the panel states in other cases. */
1577 direct_link_panel_list(reader, &panel.children);
1578 }
1579}
1580
1581static void direct_link_region(BlendDataReader *reader, ARegion *region, int spacetype)
1582{
1583 direct_link_panel_list(reader, &region->panels);
1584
1586
1587 BLO_read_struct_list(reader, uiList, &region->ui_lists);
1589
1591 for (uiTextboxStateLink &textbox_state : region->textbox_states) {
1592 BLO_read_string(reader, &textbox_state.idname);
1593 }
1594
1595 /* The area's search filter is runtime only, so we need to clear the active flag on read. */
1596 /* Clear runtime flags (e.g. search filter is runtime only). */
1598
1599 for (uiList &ui_list : region->ui_lists) {
1600 ui_list.type = nullptr;
1601 ui_list.dyn_data = nullptr;
1602 BLO_read_struct(reader, IDProperty, &ui_list.properties);
1603 IDP_BlendDataRead(reader, &ui_list.properties);
1604 }
1605
1606 BLO_read_struct_list(reader, uiPreview, &region->ui_previews);
1607 for (uiPreview &ui_preview : region->ui_previews) {
1609 ui_preview.tag = uiPreviewTag{};
1610 }
1611
1612 if (spacetype == SPACE_EMPTY) {
1613 /* unknown space type, don't leak regiondata */
1614 region->regiondata = nullptr;
1615 }
1616 else if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
1617 /* Runtime data, don't use. */
1618 region->regiondata = nullptr;
1619 }
1620 else {
1621 if (spacetype == SPACE_VIEW3D) {
1622 if (region->regiontype == RGN_TYPE_WINDOW) {
1623 BLO_read_struct(reader, RegionView3D, &region->regiondata);
1624
1625 if (region->regiondata == nullptr) {
1626 /* To avoid crashing on some old files. */
1627 region->regiondata = MEM_new<RegionView3D>("region view3d");
1628 }
1629
1630 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
1631
1632 BLO_read_struct(reader, RegionView3D, &rv3d->localvd);
1633 BLO_read_struct(reader, BoundBox, &rv3d->clipbb);
1634
1635 rv3d->view_render = nullptr;
1636 rv3d->sms = nullptr;
1637 rv3d->smooth_timer = nullptr;
1638
1639 rv3d->rflag &= ~(RV3D_NAVIGATING | RV3D_PAINTING);
1641 }
1642 }
1643 if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
1645 }
1646 }
1647
1648 region->runtime = MEM_new<bke::ARegionRuntime>(__func__);
1649 region->v2d.sms = nullptr;
1650 region->v2d.alpha_hor = region->v2d.alpha_vert = 255; /* visible by default */
1651}
1652
1653void BKE_screen_view3d_do_versions_250(View3D *v3d, ListBaseT<ARegion> *regions)
1654{
1655 for (ARegion &region : *regions) {
1656 if (region.regiontype == RGN_TYPE_WINDOW && region.regiondata == nullptr) {
1657 RegionView3D *rv3d;
1658
1659 rv3d = MEM_new<RegionView3D>("region v3d patch");
1660 rv3d->persp = v3d->persp;
1661 rv3d->view = v3d->view;
1662 rv3d->dist = v3d->dist;
1663 copy_v3_v3(rv3d->ofs, v3d->ofs);
1664 copy_qt_qt(rv3d->viewquat, v3d->viewquat);
1665 region.regiondata = rv3d;
1666 }
1667 }
1668
1669 /* this was not initialized correct always */
1670 if (v3d->gridsubdiv == 0) {
1671 v3d->gridsubdiv = 10;
1672 }
1673}
1674
1675static void direct_link_area(BlendDataReader *reader, ScrArea *area)
1676{
1677 const bool has_spacedata = area->spacedata.first() != nullptr;
1679 reader, &area->spacedata, [](const SpaceLink &sl) {
1680 const SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
1681 return space_type ? size_t(space_type->struct_size) : sizeof(SpaceLink);
1682 });
1683 BLO_read_struct_list(reader, ARegion, &(area->regionbase));
1684
1685 /* The first space data is the active one, its type must match the area space type. If it
1686 * failed to read, leave the area empty. Files before 2.50 can have areas without space data
1687 * of their own type (e.g. the info header), which versioning handles. */
1688 const SpaceLink *sl_active = area->spacedata.first();
1689 if (sl_active == nullptr) {
1690 /* Space types removed from DNA (e.g. timeline and logic editors) are handled below. */
1691 if (has_spacedata && BKE_spacetype_exists(area->spacetype)) {
1692 area->spacetype = SPACE_EMPTY;
1693 }
1694 }
1695 else if (sl_active->spacetype != area->spacetype && BLO_read_fileversion_get(reader) >= 250) {
1696 BLO_read_data_invalidate(reader, "Corrupt .blend file, mismatched area space type.");
1697 area->spacetype = SPACE_EMPTY;
1698 }
1699
1700 area->handlers.clear_no_delete();
1701 area->type = nullptr; /* spacetype callbacks */
1702
1703 area->runtime = ScrArea_Runtime{};
1704
1705 /* Should always be unset so that rna_Area_type_get works correctly. */
1706 area->butspacetype = SPACE_EMPTY;
1707
1708 area->region_active_win = -1;
1709
1711
1712 BLO_read_struct(reader, ScrGlobalAreaData, &area->global);
1713
1714 /* if we do not have the spacetype registered we cannot
1715 * free it, so don't allocate any new memory for such spacetypes. */
1716 if (!BKE_spacetype_exists(area->spacetype)) {
1717 /* Hint for versioning code to replace deprecated space types. */
1718 area->butspacetype = area->spacetype;
1719
1720 area->spacetype = SPACE_EMPTY;
1721 }
1722
1723 for (ARegion &region : area->regionbase) {
1724 direct_link_region(reader, &region, area->spacetype);
1725 }
1726
1727 /* accident can happen when read/save new file with older version */
1728 /* 2.50: we now always add spacedata for info */
1729 if (area->spacedata.first() == nullptr) {
1730 SpaceInfo *sinfo = MEM_new<SpaceInfo>("spaceinfo");
1731 area->spacetype = sinfo->spacetype = SPACE_INFO;
1732 BLI_addtail(&area->spacedata, sinfo);
1733 }
1734 /* add local view3d too */
1735 else if (area->spacetype == SPACE_VIEW3D) {
1737 }
1738
1739 for (SpaceLink &sl : area->spacedata) {
1740 BLO_read_struct_list(reader, ARegion, &(sl.regionbase));
1741
1742 /* if we do not have the spacetype registered we cannot
1743 * free it, so don't allocate any new memory for such spacetypes. */
1746 }
1747
1748 for (ARegion &region : sl.regionbase) {
1749 direct_link_region(reader, &region, sl.spacetype);
1750 }
1751
1752 SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
1753 if (space_type && space_type->blend_read_data) {
1754 space_type->blend_read_data(reader, &sl);
1755 }
1756 }
1757
1758 area->actionzones.clear_no_delete();
1759
1760 BLO_read_struct(reader, ScrVert, &area->v1);
1761 BLO_read_struct(reader, ScrVert, &area->v2);
1762 BLO_read_struct(reader, ScrVert, &area->v3);
1763 BLO_read_struct(reader, ScrVert, &area->v4);
1764}
1765
1767{
1768 BLO_read_struct_list(reader, ScrVert, &area_map->vertbase);
1769 BLO_read_struct_list(reader, ScrEdge, &area_map->edgebase);
1770 BLO_read_struct_list(reader, ScrArea, &area_map->areabase);
1771 for (ScrArea &area : area_map->areabase) {
1772 direct_link_area(reader, &area);
1773 }
1774
1775 /* edges */
1776 for (ScrEdge &se : area_map->edgebase) {
1777 BLO_read_struct(reader, ScrVert, &se.v1);
1778 BLO_read_struct(reader, ScrVert, &se.v2);
1779
1780 if (se.v1 == nullptr || se.v2 == nullptr) {
1781 BLI_freelinkN(&area_map->edgebase, &se);
1782
1783 return false;
1784 }
1785 }
1786
1787 return true;
1788}
1789
1794static void regions_remove_invalid(SpaceType *space_type, ListBaseT<ARegion> *regionbase)
1795{
1796 for (ARegion &region : regionbase->items_mutable()) {
1797 if (BKE_regiontype_from_id(space_type, region.regiontype) != nullptr) {
1798 continue;
1799 }
1800
1802 "Region type %d missing in space type \"%s\" (id: %d) - removing region",
1803 region.regiontype,
1804 space_type->name,
1805 space_type->spaceid);
1806
1807 BKE_area_region_free(space_type, &region);
1808 BLI_freelinkN(regionbase, &region);
1809 }
1810}
1811
1813{
1814 for (SpaceLink &sl : area->spacedata) {
1815 SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
1816 ListBaseT<ARegion> *regionbase = (&sl == area->spacedata.first()) ? &area->regionbase :
1817 &sl.regionbase;
1818
1819 /* We cannot restore the region type without a valid space type. So delete all regions to make
1820 * sure no data is kept around that can't be restored safely (like the type dependent
1821 * #ARegion.regiondata). */
1822 if (!space_type) {
1823 for (ARegion &region : regionbase->items_mutable()) {
1824 BKE_area_region_free(nullptr, &region);
1825 BLI_freelinkN(regionbase, &region);
1826 }
1827
1828 continue;
1829 }
1830
1831 if (space_type->blend_read_after_liblink) {
1832 space_type->blend_read_after_liblink(reader, parent_id, &sl);
1833 }
1834
1835 regions_remove_invalid(space_type, regionbase);
1836 }
1837}
1838
1840
1841} // namespace blender
#define IDP_BlendDataRead(reader, prop)
#define MAIN_ID_SESSION_UID_UNSET
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define M_SQRT2
#define STRNCPY_UTF8(dst, src)
Compatibility-like things for windows.
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_SCREEN
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define FILTER_ID_SCR
Definition DNA_ID.h:1235
#define FILTER_ID_SCE
Definition DNA_ID.h:1219
#define ID_SCRN
#define AREAMAP_FROM_SCREEN(screen)
#define RGN_TYPE_ANY
#define SPACE_TYPE_ANY
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
int64_t size() const
void append(const T &value)
Span< T > as_span() const
constexpr int64_t size() const
constexpr const char * data() const
#define powf(x, y)
const int state
void region_blend_read_data(BlendDataReader *reader, ARegion *region)
void region_blend_write(BlendWriter *writer, ARegion *region)
BMesh Iterators.
void BPY_callback_screen_free(ARegionType *art)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
ARegion * BKE_area_find_region_active_win(const ScrArea *area)
Definition screen.cc:1037
@ LAYOUT_PANEL_STATE_FLAG_OPEN
__int64 int64_t
Definition BKE_text.h:90
bool BKE_regiontype_uses_panel_categories_search(const ARegionType *region_type)
Definition screen.cc:417
void BKE_previewimg_id_free(ID *id)
Panel * BKE_panel_new(PanelType *panel_type)
Definition screen.cc:685
void BKE_screen_remove_double_scrverts(bScreen *screen)
Definition screen.cc:851
bool BKE_spacetype_exists(int spaceid)
Definition screen.cc:393
bool BKE_screen_blend_read_data(BlendDataReader *reader, bScreen *screen)
Definition screen.cc:238
void BKE_screen_area_free(ScrArea *area)
Definition screen.cc:783
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BKE_previewimg_blend_read(BlendDataReader *reader, PreviewImage *prv)
static void(*) region_refresh_tag_gizmomap_callback(wmGizmoMap *)
Definition screen.cc:616
ARegionDrawLockFlags
@ RGN_TYPE_ASSET_SHELF_HEADER
static void direct_link_region(BlendDataReader *reader, ARegion *region, int spacetype)
Definition screen.cc:1581
void BKE_screen_view3d_shading_init(View3DShading *shading)
Definition screen.cc:1262
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:834
bool BKE_screen_is_used(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:1298
void BKE_screen_remove_unused_scredges(bScreen *screen)
Definition screen.cc:917
void BKE_spacedata_draw_locks(ARegionDrawLockFlags lock_flags)
Definition screen.cc:558
void BKE_screen_remove_unused_scrverts(bScreen *screen)
Definition screen.cc:962
@ IDWALK_DO_DEPRECATED_POINTERS
void BKE_previewimg_blend_write(BlendWriter *writer, const PreviewImage *prv)
void BKE_screen_area_map_free(ScrAreaMap *area_map) ATTR_NONNULL()
Definition screen.cc:799
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1696
void BKE_area_region_free(SpaceType *st, ARegion *region)
Definition screen.cc:736
bool BKE_regiontype_uses_category_tabs(const ARegionType *region_type)
Definition screen.cc:407
void BKE_screen_area_map_blend_write(BlendWriter *writer, ScrAreaMap *area_map)
Definition screen.cc:1513
void BKE_area_region_panels_free(ListBaseT< Panel > *panels)
Definition screen.cc:724
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
static void write_panel_list(BlendWriter *writer, ListBaseT< Panel > *lb)
Definition screen.cc:1456
void BKE_screen_view3d_shading_blend_read_data(BlendDataReader *reader, View3DShading *shading)
Definition screen.cc:1352
void BLO_read_data_invalidate(BlendDataReader *reader, const char *message)
Definition readfile.cc:6839
static void direct_link_panel_list(BlendDataReader *reader, ListBaseT< Panel > *lb)
Definition screen.cc:1558
ARegion ARegion ScrArea ARegion * BKE_screen_find_region_in_space(const bScreen *screen, const SpaceLink *sl, int region_type) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
Definition screen.cc:1102
void BKE_spacedata_id_unref(ScrArea *area, SpaceLink *sl, ID *id)
Definition screen.cc:606
LibraryForeachIDFlag BKE_lib_query_foreachid_process_flags_get(const LibraryForeachIDData *data)
Definition lib_query.cc:133
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
bool BKE_screen_scredge_equals(const ScrVert *a1, const ScrVert *a2, const ScrVert *b1, const ScrVert *b2)
Definition screen.cc:826
void MEM_delete_void(void *vmemh)
static void write_uilist(BlendWriter *writer, uiList *ui_list)
Definition screen.cc:1447
ARegion * BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *area, int region_type) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:572
ARegion * BKE_area_region_copy(const SpaceType *st, const ARegion *region)
Definition screen.cc:479
@ LIB_ID_COPY_NO_PREVIEW
ScrArea * BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap, int spacetype, const int xy[2]) ATTR_NONNULL(1
Definition screen.cc:1209
static void layout_panel_state_delete(LayoutPanelState *state)
Definition screen.cc:696
MINLINE void zero_v4(float r[4])
bool BKE_regiontype_uses_categories(const ARegionType *region_type)
Definition screen.cc:398
static void write_area(BlendWriter *writer, ScrArea *area)
Definition screen.cc:1471
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
static void zero_regionview3d_runtime_fields(RegionView3D &rv3d)
Definition screen.cc:1360
unsigned int uint32_t
Definition BKE_text.h:81
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
static void screen_init_data(ID *id)
Definition screen.cc:70
static void screen_foreach_id(ID *id, LibraryForeachIDData *data)
Definition screen.cc:192
static void write_region(BlendWriter *writer, ARegion *region, int spacetype)
Definition screen.cc:1383
void * MEM_dupalloc_void(const void *vmemh) ATTR_WARN_UNUSED_RESULT
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void copy_qt_qt(float q[4], const float a[4])
BMesh const char void * data
void BKE_screen_header_alignment_reset(bScreen *screen)
Definition screen.cc:1303
float BKE_screen_view3d_zoom_from_fac(float zoomfac)
Definition screen.cc:1288
void BKE_screen_area_blend_read_after_liblink(BlendLibReader *reader, ID *parent_id, ScrArea *area)
Definition screen.cc:1812
ARegion * BKE_screen_find_region_xy(const bScreen *screen, int regiontype, const int xy[2]) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
Definition screen.cc:1079
void BKE_spacedata_copylist(ListBaseT< SpaceLink > *lb_dst, ListBaseT< SpaceLink > *lb_src)
Definition screen.cc:541
void BKE_screen_runtime_refresh_for_blendfile(bScreen *screen)
Definition screen.cc:638
static CLG_LogRef LOG_BLEND_DOVERSION
Definition screen.cc:64
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:6591
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
std::optional< std::string > BKE_screen_path_to_area(const PointerRNA *ptr)
Definition screen.cc:1156
static void remove_least_recently_used_panel_states(Panel &panel, const int64_t max_kept)
Definition screen.cc:1540
ScrEdge * BKE_screen_find_edge(const bScreen *screen, ScrVert *v1, ScrVert *v2)
Definition screen.cc:840
ARegionType * BKE_regiontype_from_id(const SpaceType *st, int regionid)
Definition screen.cc:364
SpaceType * BKE_spacetype_from_id(int spaceid)
Definition screen.cc:354
void BKE_area_copy(ScrArea *area_dst, ScrArea *area_src)
Definition screen.cc:999
void BKE_region_callback_refresh_tag_gizmomap_set(void(*callback)(wmGizmoMap *))
Definition screen.cc:618
void BKE_screen_view3d_sync(View3D *v3d, Scene *scene)
Definition screen.cc:1231
LayoutPanelState * BKE_panel_layout_panel_state_ensure(Panel *panel, StringRef idname, bool default_closed)
Definition screen.cc:656
ARegion ARegion * BKE_screen_find_main_region_at_xy(const bScreen *screen, int space_type, const int xy[2]) ATTR_NONNULL(1
Definition screen.cc:1267
ARegion * BKE_area_region_new()
Definition screen.cc:522
MINLINE void zero_v3(float r[3])
ScrArea ScrArea * BKE_screen_find_area_xy(const bScreen *screen, int spacetype, const int xy[2]) ATTR_NONNULL(1
Definition screen.cc:1226
ARegion ARegion ScrArea ARegion std::optional< std::string > BKE_screen_path_to_space(const PointerRNA *ptr)
Definition screen.cc:1118
ScrArea ScrArea void BKE_screen_gizmo_tag_refresh(bScreen *screen)
Definition screen.cc:623
static void region_copylist(SpaceType *st, ListBaseT< ARegion > *lb_dst, ListBaseT< ARegion > *lb_src)
Definition screen.cc:530
void BKE_panel_free(Panel *panel)
Definition screen.cc:702
void BKE_spacedata_freelist(ListBaseT< SpaceLink > *lb)
Definition screen.cc:434
static void screen_free_data(ID *id)
Definition screen.cc:79
void BKE_screen_view3d_do_versions_250(View3D *v3d, ListBaseT< ARegion > *regions)
Definition screen.cc:1653
ARegion * BKE_region_find_in_listbase_by_type(const ListBaseT< ARegion > *regionbase, const int region_type)
Definition screen.cc:987
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
Definition screen.cc:1024
void BKE_screen_foreach_id_screen_area(LibraryForeachIDData *data, ScrArea *area)
Definition screen.cc:179
void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
Span< std::unique_ptr< SpaceType > > BKE_spacetypes_list()
Definition screen.cc:374
IDTypeInfo IDType_ID_SCR
Definition screen.cc:271
void BKE_screen_view3d_scene_sync(bScreen *screen, Scene *scene)
Definition screen.cc:1249
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static void screen_copy_data(Main *, std::optional< Library * > owner_library, ID *id_dst, const ID *id_src, int flag)
Definition screen.cc:104
@ INDEX_ID_SCR
Definition DNA_ID.h:1354
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1403
static void(*) region_free_gizmomap_callback(wmGizmoMap *)
Definition screen.cc:649
void BKE_region_callback_free_gizmomap_set(void(*callback)(wmGizmoMap *))
Definition screen.cc:651
void BKE_spacetype_register(std::unique_ptr< SpaceType > st)
Definition screen.cc:379
int BLO_read_fileversion_get(BlendDataReader *reader)
Definition readfile.cc:6546
void BKE_screen_copy_data(bScreen *screen_dst, const bScreen *screen_src)
Definition screen.cc:815
static Vector< std::unique_ptr< SpaceType > > & get_space_types()
Definition screen.cc:313
ARegion ARegion ScrArea * BKE_screen_find_area_from_space(const bScreen *screen, const SpaceLink *sl) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
Definition screen.cc:1091
ScrArea * BKE_screen_find_big_area(const bScreen *screen, int spacetype, short min)
Definition screen.cc:1189
static void area_region_panels_free_recursive(Panel *panel)
Definition screen.cc:716
bool BKE_screen_is_fullscreen_area(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:1293
void zero_m4(float m[4][4])
void zero_m3(float m[3][3])
bool BKE_region_panel_categories_search_filter_visible(const ARegion *region)
Definition screen.cc:422
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2])
void BKE_spacedata_callback_id_remap_set(void(*func)(ScrArea *area, SpaceLink *sl, ID *old_id, ID *new_id))
Definition screen.cc:601
float BKE_screen_view3d_zoom_to_fac(float camzoom)
Definition screen.cc:1283
void BKE_screen_view3d_shading_blend_write(BlendWriter *writer, View3DShading *shading)
Definition screen.cc:1345
@ RGN_FLAG_SEARCH_FILTER_SHOW
@ RGN_FLAG_SEARCH_FILTER_ACTIVE
@ RGN_FLAG_SEARCH_FILTER_UPDATE
@ RGN_FLAG_TEMP_REGIONDATA
void BKE_screen_free_data(bScreen *screen)
Definition screen.cc:810
static void panel_list_copy(ListBaseT< Panel > *newlb, const ListBaseT< Panel > *lb)
Definition screen.cc:454
void BKE_spacetypes_free()
Definition screen.cc:349
static void screen_blend_read_after_liblink(BlendLibReader *reader, ID *id)
Definition screen.cc:262
static void direct_link_area(BlendDataReader *reader, ScrArea *area)
Definition screen.cc:1675
bool BKE_screen_area_map_blend_read_data(BlendDataReader *reader, ScrAreaMap *area_map)
Definition screen.cc:1766
ARegion * BKE_screen_find_region_type(const bScreen *screen, int region_type) ATTR_NONNULL(1)
Definition screen.cc:1069
static void(*) spacedata_id_remap_cb(ScrArea *area, SpaceLink *sl, ID *old_id, ID *new_id)
Definition screen.cc:596
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:6653
static void screen_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition screen.cc:209
void BKE_screen_remove_double_scredges(bScreen *screen)
Definition screen.cc:901
@ AREA_FLAG_REGION_SIZE_UPDATE
@ AREA_FLAG_ACTIONZONES_UPDATE
@ AREA_FLAG_ACTIVE_TOOL_UPDATE
ARegion * BKE_area_find_region_xy(const ScrArea *area, int regiontype, const int xy[2]) ATTR_NONNULL(3)
Definition screen.cc:1053
static void regions_remove_invalid(SpaceType *space_type, ListBaseT< ARegion > *regionbase)
Definition screen.cc:1794
@ 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
#define sqrtf
#define min(a, b)
Definition sort.cc:38
ARegionTypeFlag flag
void *(*) duplicate(void *poin)
void(*) free(ARegion *)
ListBaseT< uiList > ui_lists
struct ARegion * next
ListBaseT< Panel > panels
bke::ARegionRuntime * runtime
ListBaseT< uiTextboxStateLink > textbox_states
struct ARegion * prev
ListBaseT< uiViewStateLink > view_states
eRegion_Alignment alignment
ListBaseT< uiPreview > ui_previews
eRegion_Type regiontype
ListBaseT< PanelCategoryStack > panels_category_active
void write_string(const char *data)
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)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
StructFreeFunc free
ExtensionRNA rna_ext
char name[258]
Definition DNA_ID.h:433
ListBaseT< LinkData > children
char idname[BKE_ST_MAXNAME]
ExtensionRNA rna_ext
ListBaseT< LayoutPanelState > * layout_panel_states_storage
struct PanelType * type
uint32_t layout_panel_states_clock
ListBaseT< Panel > children
ListBaseT< LayoutPanelState > layout_panel_states
struct Panel_Runtime * runtime
struct RegionView3D * localvd
eRegionView3D_Flag rflag
eRegionView3D_ViewLock runtime_viewlock
struct ViewRender * view_render
struct BoundBox * clipbb
struct wmTimer * smooth_timer
eRegionView3D_Persp persp
struct SmoothView3DStore * sms
eRegionView3D_View view
struct Object * camera
ListBaseT< ScrArea > areabase
ListBaseT< ScrVert > vertbase
ListBaseT< ScrEdge > edgebase
ListBaseT< struct wmEventHandler > handlers
ListBaseT< struct AZone > actionzones
ListBaseT< ARegion > regionbase
ScrArea_Runtime runtime
struct ScrArea * next
ListBaseT< SpaceLink > spacedata
ScrGlobalAreaData * global
struct SpaceType * type
struct ScrEdge * next
struct ScrVert * newv
struct ScrVert * next
void(*) foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
ListBaseT< ARegionType > regiontypes
SpaceLink *(*) duplicate(SpaceLink *sl)
void(*) blend_write(BlendWriter *writer, SpaceLink *space_link)
void(*) free(SpaceLink *sl)
void(*) blend_read_data(BlendDataReader *reader, SpaceLink *space_link)
void(*) blend_read_after_liblink(BlendLibReader *reader, ID *parent_id, SpaceLink *space_link)
char name[BKE_ST_MAXNAME]
ui::SmoothView2DStore * sms
struct wmTimer * smooth_timer
eView2D_ScrollUI scroll_ui
struct IDProperty * prop
DNA_DEPRECATED eRegionView3D_Persp persp
struct Object * camera
ListBaseT< ARegion > regionbase
DNA_DEPRECATED float ofs[2]
DNA_DEPRECATED float dist
struct View3D * localvd
DNA_DEPRECATED eRegionView3D_View view
DNA_DEPRECATED float viewquat[4]
eScreen_State state
struct wmTimer * animtimer
struct ARegion * active_region
ListBaseT< struct ScrEdge > edgebase
ListBaseT< struct ScrVert > vertbase
ListBaseT< struct ScrArea > areabase
DNA_DEPRECATED struct Scene * scene
eScreen_Redraws_Flag redraws_flag
PreviewImage * preview
ListBaseT< ARegion > regionbase
struct wmTooltipState * tool_tip
ListBaseT< PanelCategoryDyn > panels_category
struct ARegionType * type
uiListFreeRuntimeDataFunc free_runtime_data_fn
IDProperty * properties
struct uiListType * type
unsigned int id_session_uid
#define N_(msgid)