Blender V4.5
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
9/* Allow using deprecated functionality for .blend file I/O. */
10#define DNA_DEPRECATED_ALLOW
11
12#ifdef WIN32
13# include "BLI_winstuff.h"
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_defaults.h"
25#include "DNA_scene_types.h"
26#include "DNA_screen_types.h"
27#include "DNA_space_types.h"
28#include "DNA_userdef_types.h"
29#include "DNA_view3d_types.h"
30
31#include "BLI_listbase.h"
32#include "BLI_math_rotation.h"
33#include "BLI_math_vector.h"
34#include "BLI_rect.h"
35#include "BLI_string.h"
36#include "BLI_utildefines.h"
37
38#include "BLT_translation.hh"
39
40#include "BKE_idprop.hh"
41#include "BKE_idtype.hh"
42#include "BKE_lib_id.hh"
43#include "BKE_lib_query.hh"
44#include "BKE_preview_image.hh"
45#include "BKE_screen.hh"
46
47#include "BLO_read_write.hh"
48
49/* TODO(@JulianEisel): For asset shelf region reading/writing. Region read/write should be done via
50 * a #ARegionType callback. */
52
53#ifdef WITH_PYTHON
54# include "BPY_extern.hh"
55#endif
56
57#include "WM_types.hh"
58
59using blender::Span;
61using blender::Vector;
62
63/* -------------------------------------------------------------------- */
67static void screen_free_data(ID *id)
68{
69 bScreen *screen = (bScreen *)id;
70
71 /* No animation-data here. */
72
73 LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
74 BKE_area_region_free(nullptr, region);
75 }
76
77 BLI_freelistN(&screen->regionbase);
78
80
82
83 /* Region and timer are freed by the window manager. */
84 /* Cannot use MEM_SAFE_FREE, as #wmTooltipState type is only defined in `WM_types.hh`, which is
85 * currently not included here. */
86 if (screen->tool_tip) {
87 MEM_freeN(static_cast<void *>(screen->tool_tip));
88 screen->tool_tip = nullptr;
89 }
90}
91
93{
95
96 LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
97 SpaceType *space_type = BKE_spacetype_from_id(sl->spacetype);
98
99 if (space_type && space_type->foreach_id) {
100 space_type->foreach_id(sl, data);
101 }
102 }
103}
104
106{
107 bScreen *screen = reinterpret_cast<bScreen *>(id);
109
112 }
113
114 if (flag & IDWALK_INCLUDE_UI) {
115 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
117 }
118 }
119}
120
121static void screen_blend_write(BlendWriter *writer, ID *id, const void *id_address)
122{
123 bScreen *screen = (bScreen *)id;
124
125 /* write LibData */
126 /* in 2.50+ files, the file identifier for screens is patched, forward compatibility */
127 BLO_write_struct_at_address_with_filecode(writer, ID_SCRN, bScreen, id_address, screen);
128 BKE_id_blend_write(writer, &screen->id);
129
130 BKE_previewimg_blend_write(writer, screen->preview);
131
132 /* direct data */
134}
135
137{
138 bool success = true;
139
140 screen->regionbase.first = screen->regionbase.last = nullptr;
141 screen->context = nullptr;
142 screen->active_region = nullptr;
143 screen->animtimer = nullptr; /* saved in rare cases */
144 screen->tool_tip = nullptr;
145 screen->scrubbing = false;
146
147 BLO_read_struct(reader, PreviewImage, &screen->preview);
148 BKE_previewimg_blend_read(reader, screen->preview);
149
151 printf("Error reading Screen %s... removing it.\n", screen->id.name + 2);
152 success = false;
153 }
154
155 return success;
156}
157
158/* NOTE: file read without screens option G_FILE_NO_UI;
159 * check lib pointers in call below */
161{
162 bScreen *screen = reinterpret_cast<bScreen *>(id);
163
164 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
165 BKE_screen_area_blend_read_after_liblink(reader, &screen->id, area);
166 }
167}
168
170 /*id_code*/ bScreen::id_type,
171 /*id_filter*/ FILTER_ID_SCR,
172 /* NOTE: Can actually link to any ID type through UI (e.g. Outliner Editor).
173 * This is handled separately though. */
174 /*dependencies_id_types*/ FILTER_ID_SCE,
175 /*main_listbase_index*/ INDEX_ID_SCR,
176 /*struct_size*/ sizeof(bScreen),
177 /*name*/ "Screen",
178 /*name_plural*/ N_("screens"),
179 /*translation_context*/ BLT_I18NCONTEXT_ID_SCREEN,
182 /*asset_type_info*/ nullptr,
183
184 /*init_data*/ nullptr,
185 /*copy_data*/ nullptr,
186 /*free_data*/ screen_free_data,
187 /*make_local*/ nullptr,
188 /*foreach_id*/ screen_foreach_id,
189 /*foreach_cache*/ nullptr,
190 /*foreach_path*/ nullptr,
191 /*owner_pointer_get*/ nullptr,
192
193 /*blend_write*/ screen_blend_write,
194 /* Cannot be used yet, because #direct_link_screen has a return value. */
195 /*blend_read_data*/ nullptr,
196 /*blend_read_after_liblink*/ screen_blend_read_after_liblink,
197
198 /*blend_read_undo_preserve*/ nullptr,
199
200 /*lib_override_apply_post*/ nullptr,
201};
202
205/* -------------------------------------------------------------------- */
211{
212 static Vector<std::unique_ptr<SpaceType>> space_types;
213 return space_types;
214}
215
216/* not SpaceType itself */
218{
219 LISTBASE_FOREACH (ARegionType *, art, &this->regiontypes) {
220#ifdef WITH_PYTHON
222#endif
223 BLI_freelistN(&art->drawcalls);
224
225 LISTBASE_FOREACH (PanelType *, pt, &art->paneltypes) {
226 if (pt->rna_ext.free) {
227 pt->rna_ext.free(pt->rna_ext.data);
228 }
229
230 BLI_freelistN(&pt->children);
231 }
232
233 LISTBASE_FOREACH (HeaderType *, ht, &art->headertypes) {
234 if (ht->rna_ext.free) {
235 ht->rna_ext.free(ht->rna_ext.data);
236 }
237 }
238
239 BLI_freelistN(&art->paneltypes);
240 BLI_freelistN(&art->headertypes);
241 }
242
244}
245
247{
248 get_space_types().clear_and_shrink();
249}
250
252{
253 for (std::unique_ptr<SpaceType> &st : get_space_types()) {
254 if (st->spaceid == spaceid) {
255 return st.get();
256 }
257 }
258 return nullptr;
259}
260
262{
264 if (art->regionid == regionid) {
265 return art;
266 }
267 }
268 return nullptr;
269}
270
275
276void BKE_spacetype_register(std::unique_ptr<SpaceType> st)
277{
278 BLI_assert(st->struct_size >= int(sizeof(SpaceLink)));
279
280 /* sanity check */
281 SpaceType *stype = BKE_spacetype_from_id(st->spaceid);
282 if (stype) {
283 printf("error: redefinition of spacetype %s\n", stype->name);
284 return;
285 }
286
287 get_space_types().append(std::move(st));
288}
289
290bool BKE_spacetype_exists(int spaceid)
291{
292 return BKE_spacetype_from_id(spaceid) != nullptr;
293}
294
297/* -------------------------------------------------------------------- */
302{
303 LISTBASE_FOREACH (SpaceLink *, sl, lb) {
304 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
305
306 /* free regions for pushed spaces */
307 LISTBASE_FOREACH (ARegion *, region, &sl->regionbase) {
308 BKE_area_region_free(st, region);
309 }
310
311 BLI_freelistN(&sl->regionbase);
312
313 if (st && st->free) {
314 st->free(sl);
315 }
316 }
317
318 BLI_freelistN(lb);
319}
320
321static void panel_list_copy(ListBase *newlb, const ListBase *lb)
322{
323 BLI_listbase_clear(newlb);
324
325 LISTBASE_FOREACH (const Panel *, old_panel, lb) {
326 Panel *new_panel = BKE_panel_new(old_panel->type);
327 Panel_Runtime *new_runtime = new_panel->runtime;
328 *new_panel = *old_panel;
329 new_panel->runtime = new_runtime;
330 new_panel->activedata = nullptr;
331 new_panel->drawname = nullptr;
332
334 new_panel->layout_panel_states_clock = old_panel->layout_panel_states_clock;
335 LISTBASE_FOREACH (LayoutPanelState *, src_state, &old_panel->layout_panel_states) {
336 LayoutPanelState *new_state = MEM_dupallocN<LayoutPanelState>(__func__, *src_state);
337 new_state->idname = BLI_strdup(src_state->idname);
338 BLI_addtail(&new_panel->layout_panel_states, new_state);
339 }
340
341 BLI_addtail(newlb, new_panel);
342 panel_list_copy(&new_panel->children, &old_panel->children);
343 }
344}
345
347{
348 ARegion *dst = static_cast<ARegion *>(MEM_dupallocN(region));
349
350 dst->runtime = MEM_new<blender::bke::ARegionRuntime>(__func__);
351 dst->runtime->type = region->runtime->type;
352 dst->runtime->do_draw = region->runtime->do_draw;
353
354 dst->prev = dst->next = nullptr;
357
358 /* use optional regiondata callback */
359 if (region->regiondata) {
361
362 if (art && art->duplicate) {
363 dst->regiondata = art->duplicate(region->regiondata);
364 }
365 else if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
366 dst->regiondata = nullptr;
367 }
368 else {
369 dst->regiondata = MEM_dupallocN(region->regiondata);
370 }
371 }
372
373 panel_list_copy(&dst->panels, &region->panels);
374
379
380 return dst;
381}
382
384{
385 ARegion *region = MEM_callocN<ARegion>(__func__);
386 region->runtime = MEM_new<blender::bke::ARegionRuntime>(__func__);
387 return region;
388}
389
390/* from lb_src to lb_dst, lb_dst is supposed to be freed */
391static void region_copylist(SpaceType *st, ListBase *lb_dst, ListBase *lb_src)
392{
393 /* to be sure */
394 BLI_listbase_clear(lb_dst);
395
396 LISTBASE_FOREACH (ARegion *, region, lb_src) {
397 ARegion *region_new = BKE_area_region_copy(st, region);
398 BLI_addtail(lb_dst, region_new);
399 }
400}
401
403{
404 BLI_listbase_clear(lb_dst); /* to be sure */
405
406 LISTBASE_FOREACH (SpaceLink *, sl, lb_src) {
407 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
408
409 if (st && st->duplicate) {
410 SpaceLink *slnew = st->duplicate(sl);
411
412 BLI_addtail(lb_dst, slnew);
413
414 region_copylist(st, &slnew->regionbase, &sl->regionbase);
415 }
416 }
417}
418
420{
421 for (std::unique_ptr<SpaceType> &st : get_space_types()) {
422 LISTBASE_FOREACH (ARegionType *, art, &st->regiontypes) {
423 if (lock_flags != 0) {
424 art->do_lock = (art->lock & lock_flags);
425 }
426 else {
427 art->do_lock = 0;
428 }
429 }
430 }
431}
432
434 const ScrArea *area,
435 int region_type)
436{
437 const bool is_slink_active = slink == area->spacedata.first;
438 const ListBase *regionbase = (is_slink_active) ? &area->regionbase : &slink->regionbase;
439 ARegion *region = nullptr;
440
441 BLI_assert(BLI_findindex(&area->spacedata, slink) != -1);
442
443 LISTBASE_FOREACH (ARegion *, region_iter, regionbase) {
444 if (region_iter->regiontype == region_type) {
445 region = region_iter;
446 break;
447 }
448 }
449
450 /* Should really unit test this instead. */
451 BLI_assert(!is_slink_active || region == BKE_area_find_region_type(area, region_type));
452
453 return region;
454}
455
456static void (*spacedata_id_remap_cb)(ScrArea *area,
457 SpaceLink *sl,
458 ID *old_id,
459 ID *new_id) = nullptr;
460
461void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *area, SpaceLink *sl, ID *, ID *))
462{
464}
465
467{
469 spacedata_id_remap_cb(area, sl, id, nullptr);
470 }
471}
472
477
482
484{
486 return;
487 }
488
489 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
490 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
491 if (region->runtime->gizmo_map != nullptr) {
492 region_refresh_tag_gizmomap_callback(region->runtime->gizmo_map);
493 }
494 }
495 }
496}
497
499{
500 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
501 area->runtime.tool = nullptr;
502 area->runtime.is_tool_set = false;
503 }
504}
505
509static void (*region_free_gizmomap_callback)(wmGizmoMap *) = nullptr;
510
515
517 const StringRef idname,
518 const bool default_closed)
519{
520 const uint32_t logical_time = ++panel->layout_panel_states_clock;
521 /* Overflow happened, reset all last used times. Not sure if this will ever happen in practice,
522 * but better handle the overflow explicitly. */
523 if (logical_time == 0) {
525 state->last_used = 0;
526 }
527 }
529 if (state->idname == idname) {
530 state->last_used = logical_time;
531 return state;
532 }
533 }
535 state->idname = BLI_strdupn(idname.data(), idname.size());
537 state->last_used = logical_time;
539 return state;
540}
541
543{
544 Panel *panel = MEM_callocN<Panel>(__func__);
545 panel->runtime = MEM_new<Panel_Runtime>(__func__);
546 panel->type = panel_type;
547 if (panel_type) {
548 STRNCPY(panel->panelname, panel_type->idname);
549 }
550 return panel;
551}
552
558
560{
562 MEM_SAFE_FREE(panel->drawname);
563
567 }
568
569 MEM_delete(panel->runtime);
570 MEM_freeN(panel);
571}
572
574{
575 LISTBASE_FOREACH_MUTABLE (Panel *, child_panel, &panel->children) {
577 }
578 BKE_panel_free(panel);
579}
580
582{
583 LISTBASE_FOREACH_MUTABLE (Panel *, panel, panels) {
584 /* Delete custom data just for parent panels to avoid a double deletion. */
585 if (panel->runtime->custom_data_ptr) {
586 MEM_delete(panel->runtime->custom_data_ptr);
587 }
589 }
590 BLI_listbase_clear(panels);
591}
592
594{
595 if (st) {
597
598 if (art && art->free) {
599 art->free(region);
600 }
601 else if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
602 /* Avoid leak with future blend files asset shelf regions for which we
603 * do not define art->free. */
605 }
606
607 if (region->regiondata && !(region->flag & RGN_FLAG_TEMP_REGIONDATA)) {
608 printf("regiondata free error\n");
609 }
610 }
611 else if (region->runtime->type && region->runtime->type->free) {
612 region->runtime->type->free(region);
613 }
614
616
617 LISTBASE_FOREACH (uiList *, uilst, &region->ui_lists) {
618 if (uilst->dyn_data && uilst->dyn_data->free_runtime_data_fn) {
619 uilst->dyn_data->free_runtime_data_fn(uilst);
620 }
621 if (uilst->properties) {
622 IDP_FreeProperty(uilst->properties);
623 }
624 MEM_SAFE_FREE(uilst->dyn_data);
625 }
626
627 if (region->runtime->gizmo_map != nullptr) {
628 region_free_gizmomap_callback(region->runtime->gizmo_map);
629 }
630
631 BLI_freelistN(&region->ui_lists);
632 BLI_freelistN(&region->ui_previews);
633 BLI_freelistN(&region->runtime->panels_category);
635 BLI_freelistN(&region->view_states);
636 MEM_delete(region->runtime);
637}
638
640{
642
643 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
644 BKE_area_region_free(st, region);
645 }
646
647 MEM_SAFE_FREE(area->global);
649
651
653}
654
656{
657 LISTBASE_FOREACH_MUTABLE (ScrArea *, area, &area_map->areabase) {
659 }
660
661 BLI_freelistN(&area_map->vertbase);
662 BLI_freelistN(&area_map->edgebase);
663 BLI_freelistN(&area_map->areabase);
664}
665
667{
668 screen_free_data(&screen->id);
669}
670
673/* -------------------------------------------------------------------- */
678{
680 LISTBASE_FOREACH (ScrEdge *, se, &screen->edgebase) {
681 if (se->v1 == v1 && se->v2 == v2) {
682 return se;
683 }
684 }
685
686 return nullptr;
687}
688
690{
691 if (*v1 > *v2) {
692 ScrVert *tmp = *v1;
693 *v1 = *v2;
694 *v2 = tmp;
695 }
696}
697
699{
700 LISTBASE_FOREACH (ScrVert *, verg, &screen->vertbase) {
701 if (verg->newv == nullptr) { /* !!! */
702 ScrVert *v1 = verg->next;
703 while (v1) {
704 if (v1->newv == nullptr) { /* !?! */
705 if (v1->vec.x == verg->vec.x && v1->vec.y == verg->vec.y) {
706 // printf("doublevert\n");
707 v1->newv = verg;
708 }
709 }
710 v1 = v1->next;
711 }
712 }
713 }
714
715 /* replace pointers in edges and faces */
716 LISTBASE_FOREACH (ScrEdge *, se, &screen->edgebase) {
717 if (se->v1->newv) {
718 se->v1 = se->v1->newv;
719 }
720 if (se->v2->newv) {
721 se->v2 = se->v2->newv;
722 }
723 /* edges changed: so.... */
724 BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
725 }
726 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
727 if (area->v1->newv) {
728 area->v1 = area->v1->newv;
729 }
730 if (area->v2->newv) {
731 area->v2 = area->v2->newv;
732 }
733 if (area->v3->newv) {
734 area->v3 = area->v3->newv;
735 }
736 if (area->v4->newv) {
737 area->v4 = area->v4->newv;
738 }
739 }
740
741 /* remove */
742 LISTBASE_FOREACH_MUTABLE (ScrVert *, verg, &screen->vertbase) {
743 if (verg->newv) {
744 BLI_remlink(&screen->vertbase, verg);
745 MEM_freeN(verg);
746 }
747 }
748}
749
751{
752 /* compare */
753 LISTBASE_FOREACH (ScrEdge *, verg, &screen->edgebase) {
754 ScrEdge *se = verg->next;
755 while (se) {
756 ScrEdge *sn = se->next;
757 if (verg->v1 == se->v1 && verg->v2 == se->v2) {
758 BLI_remlink(&screen->edgebase, se);
759 MEM_freeN(se);
760 }
761 se = sn;
762 }
763 }
764}
765
767{
768 /* sets flags when edge is used in area */
769 int a = 0;
770 LISTBASE_FOREACH_INDEX (ScrArea *, area, &screen->areabase, a) {
771 ScrEdge *se = BKE_screen_find_edge(screen, area->v1, area->v2);
772 if (se == nullptr) {
773 printf("error: area %d edge 1 doesn't exist\n", a);
774 }
775 else {
776 se->flag = 1;
777 }
778 se = BKE_screen_find_edge(screen, area->v2, area->v3);
779 if (se == nullptr) {
780 printf("error: area %d edge 2 doesn't exist\n", a);
781 }
782 else {
783 se->flag = 1;
784 }
785 se = BKE_screen_find_edge(screen, area->v3, area->v4);
786 if (se == nullptr) {
787 printf("error: area %d edge 3 doesn't exist\n", a);
788 }
789 else {
790 se->flag = 1;
791 }
792 se = BKE_screen_find_edge(screen, area->v4, area->v1);
793 if (se == nullptr) {
794 printf("error: area %d edge 4 doesn't exist\n", a);
795 }
796 else {
797 se->flag = 1;
798 }
799 }
800 LISTBASE_FOREACH_MUTABLE (ScrEdge *, se, &screen->edgebase) {
801 if (se->flag == 0) {
802 BLI_remlink(&screen->edgebase, se);
803 MEM_freeN(se);
804 }
805 else {
806 se->flag = 0;
807 }
808 }
809}
810
812{
813 /* we assume edges are ok */
814 LISTBASE_FOREACH (ScrEdge *, se, &screen->edgebase) {
815 se->v1->flag = 1;
816 se->v2->flag = 1;
817 }
818
819 LISTBASE_FOREACH_MUTABLE (ScrVert *, sv, &screen->vertbase) {
820 if (sv->flag == 0) {
821 BLI_remlink(&screen->vertbase, sv);
822 MEM_freeN(sv);
823 }
824 else {
825 sv->flag = 0;
826 }
827 }
828}
829
832/* -------------------------------------------------------------------- */
836ARegion *BKE_region_find_in_listbase_by_type(const ListBase *regionbase, const int region_type)
837{
838 LISTBASE_FOREACH (ARegion *, region, regionbase) {
839 if (region->regiontype == region_type) {
840 return region;
841 }
842 }
843
844 return nullptr;
845}
846
847ARegion *BKE_area_find_region_type(const ScrArea *area, int region_type)
848{
849 if (area) {
850 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
851 if (region->regiontype == region_type) {
852 return region;
853 }
854 }
855 }
856
857 return nullptr;
858}
859
861{
862 if (area == nullptr) {
863 return nullptr;
864 }
865
866 ARegion *region = static_cast<ARegion *>(
868 if (region && (region->regiontype == RGN_TYPE_WINDOW)) {
869 return region;
870 }
871
872 /* fall back to any */
874}
875
876ARegion *BKE_area_find_region_xy(const ScrArea *area, const int regiontype, const int xy[2])
877{
878 if (area == nullptr) {
879 return nullptr;
880 }
881
882 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
883 if (ELEM(regiontype, RGN_TYPE_ANY, region->regiontype)) {
884 if (BLI_rcti_isect_pt_v(&region->winrct, xy)) {
885 return region;
886 }
887 }
888 }
889 return nullptr;
890}
891
892ARegion *BKE_screen_find_region_type(const bScreen *screen, const int region_type)
893{
894 LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
895 if (region_type == region->regiontype) {
896 return region;
897 }
898 }
899 return nullptr;
900}
901
902ARegion *BKE_screen_find_region_xy(const bScreen *screen, const int regiontype, const int xy[2])
903{
904 LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
905 if (ELEM(regiontype, RGN_TYPE_ANY, region->regiontype)) {
906 if (BLI_rcti_isect_pt_v(&region->winrct, xy)) {
907 return region;
908 }
909 }
910 }
911 return nullptr;
912}
913
915{
916 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
917 if (BLI_findindex(&area->spacedata, sl) != -1) {
918 return area;
919 }
920 }
921
922 return nullptr;
923}
924
925std::optional<std::string> BKE_screen_path_from_screen_to_space(const PointerRNA *ptr)
926{
927 if (GS(ptr->owner_id->name) != ID_SCR) {
929 return std::nullopt;
930 }
931
932 const bScreen *screen = reinterpret_cast<const bScreen *>(ptr->owner_id);
933 const SpaceLink *link = static_cast<const SpaceLink *>(ptr->data);
934
935 int area_index;
936 LISTBASE_FOREACH_INDEX (const ScrArea *, area, &screen->areabase, area_index) {
937 const int space_index = BLI_findindex(&area->spacedata, link);
938 if (space_index != -1) {
939 return fmt::format("areas[{}].spaces[{}]", area_index, space_index);
940 }
941 }
942 return std::nullopt;
943}
944
945ScrArea *BKE_screen_find_big_area(const bScreen *screen, const int spacetype, const short min)
946{
947 ScrArea *big = nullptr;
948 int maxsize = 0;
949
950 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
951 if (ELEM(spacetype, SPACE_TYPE_ANY, area->spacetype)) {
952 if (min <= area->winx && min <= area->winy) {
953 int size = area->winx * area->winy;
954 if (size > maxsize) {
955 maxsize = size;
956 big = area;
957 }
958 }
959 }
960 }
961
962 return big;
963}
964
966 const int spacetype,
967 const int xy[2])
968{
969 LISTBASE_FOREACH (ScrArea *, area, &areamap->areabase) {
970 /* Test area's outer screen verts, not inner `area->totrct`. */
971 if (xy[0] >= area->v1->vec.x && xy[0] <= area->v4->vec.x && xy[1] >= area->v1->vec.y &&
972 xy[1] <= area->v2->vec.y)
973 {
974 if (ELEM(spacetype, SPACE_TYPE_ANY, area->spacetype)) {
975 return area;
976 }
977 break;
978 }
979 }
980 return nullptr;
981}
982ScrArea *BKE_screen_find_area_xy(const bScreen *screen, const int spacetype, const int xy[2])
983{
984 return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(screen), spacetype, xy);
985}
986
988{
989 if (v3d->scenelock && v3d->localvd == nullptr) {
990 v3d->camera = scene->camera;
991
992 if (v3d->camera == nullptr) {
993 LISTBASE_FOREACH (ARegion *, region, &v3d->regionbase) {
994 if (region->regiontype == RGN_TYPE_WINDOW) {
995 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
996 if (rv3d->persp == RV3D_CAMOB) {
997 rv3d->persp = RV3D_PERSP;
998 }
999 }
1000 }
1001 }
1002 }
1003}
1004
1006{
1007 /* are there cameras in the views that are not in the scene? */
1008 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1009 LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1010 if (sl->spacetype == SPACE_VIEW3D) {
1011 View3D *v3d = (View3D *)sl;
1013 }
1014 }
1015 }
1016}
1017
1019{
1020 const View3DShading *shading_default = DNA_struct_default_get(View3DShading);
1021 memcpy(shading, shading_default, sizeof(*shading));
1022}
1023
1025 const int space_type,
1026 const int xy[2])
1027{
1028 ScrArea *area = BKE_screen_find_area_xy(screen, space_type, xy);
1029 if (!area) {
1030 return nullptr;
1031 }
1033}
1034
1035/* Magic zoom calculation, no idea what it signifies, if you find out, tell me! -zr
1036 *
1037 * Simple, its magic dude! Well, to be honest,
1038 * this gives a natural feeling zooming with multiple keypad presses (ton). */
1039
1041{
1042 return powf((float(M_SQRT2) + camzoom / 50.0f), 2.0f) / 4.0f;
1043}
1044
1046{
1047 return ((sqrtf(4.0f * zoomfac) - float(M_SQRT2)) * 50.0f);
1048}
1049
1051{
1052 return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
1053}
1054
1055bool BKE_screen_is_used(const bScreen *screen)
1056{
1057 return (screen->winid != 0);
1058}
1059
1061{
1062 int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
1063 LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1064 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1065 if (ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER)) {
1067 region->alignment = RGN_ALIGN_TOP;
1068 continue;
1069 }
1070 region->alignment = alignment;
1071 }
1072 if (region->regiontype == RGN_TYPE_FOOTER) {
1074 region->alignment = RGN_ALIGN_BOTTOM;
1075 continue;
1076 }
1077 region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_TOP : RGN_ALIGN_BOTTOM;
1078 }
1079 }
1080 }
1081 screen->do_refresh = true;
1082}
1083
1086/* -------------------------------------------------------------------- */
1091{
1092 if (shading->prop) {
1093 IDP_BlendWrite(writer, shading->prop);
1094 }
1095}
1096
1098{
1099 if (shading->prop) {
1100 BLO_read_struct(reader, IDProperty, &shading->prop);
1101 IDP_BlendDataRead(reader, &shading->prop);
1102 }
1103}
1104
1105static void write_region(BlendWriter *writer, ARegion *region, int spacetype)
1106{
1107 BLO_write_struct(writer, ARegion, region);
1108
1109 if (region->regiondata) {
1110 if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
1111 return;
1112 }
1113
1114 if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
1116 return;
1117 }
1118
1119 switch (spacetype) {
1120 case SPACE_VIEW3D:
1121 if (region->regiontype == RGN_TYPE_WINDOW) {
1122 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
1123 BLO_write_struct(writer, RegionView3D, rv3d);
1124
1125 if (rv3d->localvd) {
1126 BLO_write_struct(writer, RegionView3D, rv3d->localvd);
1127 }
1128 if (rv3d->clipbb) {
1129 BLO_write_struct(writer, BoundBox, rv3d->clipbb);
1130 }
1131 }
1132 else {
1133 printf("regiondata write missing!\n");
1134 }
1135 break;
1136 default:
1137 printf("regiondata write missing!\n");
1138 }
1139 }
1140}
1141
1142static void write_uilist(BlendWriter *writer, uiList *ui_list)
1143{
1144 BLO_write_struct(writer, uiList, ui_list);
1145
1146 if (ui_list->properties) {
1147 IDP_BlendWrite(writer, ui_list->properties);
1148 }
1149}
1150
1151static void write_panel_list(BlendWriter *writer, ListBase *lb)
1152{
1153 LISTBASE_FOREACH (Panel *, panel, lb) {
1154 BLO_write_struct(writer, Panel, panel);
1155 BLO_write_struct_list(writer, LayoutPanelState, &panel->layout_panel_states);
1156 LISTBASE_FOREACH (LayoutPanelState *, state, &panel->layout_panel_states) {
1157 BLO_write_string(writer, state->idname);
1158 }
1159 write_panel_list(writer, &panel->children);
1160 }
1161}
1162
1163static void write_area(BlendWriter *writer, ScrArea *area)
1164{
1165 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1166 write_region(writer, region, area->spacetype);
1167 write_panel_list(writer, &region->panels);
1168
1169 LISTBASE_FOREACH (PanelCategoryStack *, pc_act, &region->panels_category_active) {
1170 BLO_write_struct(writer, PanelCategoryStack, pc_act);
1171 }
1172
1173 LISTBASE_FOREACH (uiList *, ui_list, &region->ui_lists) {
1174 write_uilist(writer, ui_list);
1175 }
1176
1177 LISTBASE_FOREACH (uiPreview *, ui_preview, &region->ui_previews) {
1178 BLO_write_struct(writer, uiPreview, ui_preview);
1179 }
1180
1181 LISTBASE_FOREACH (uiViewStateLink *, view_state, &region->view_states) {
1182 BLO_write_struct(writer, uiViewStateLink, view_state);
1183 }
1184 }
1185
1186 LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1187 LISTBASE_FOREACH (ARegion *, region, &sl->regionbase) {
1188 write_region(writer, region, sl->spacetype);
1189 }
1190
1191 SpaceType *space_type = BKE_spacetype_from_id(sl->spacetype);
1192 if (space_type && space_type->blend_write) {
1193 space_type->blend_write(writer, sl);
1194 }
1195 }
1196}
1197
1199{
1200 BLO_write_struct_list(writer, ScrVert, &area_map->vertbase);
1201 BLO_write_struct_list(writer, ScrEdge, &area_map->edgebase);
1202 LISTBASE_FOREACH (ScrArea *, area, &area_map->areabase) {
1203 area->butspacetype = area->spacetype; /* Just for compatibility, will be reset below. */
1204
1205 BLO_write_struct(writer, ScrArea, area);
1206
1208
1209 write_area(writer, area);
1210
1211 area->butspacetype = SPACE_EMPTY; /* Unset again, was changed above. */
1212 }
1213}
1214
1215static void remove_least_recently_used_panel_states(Panel &panel, const int64_t max_kept)
1216{
1219 all_states.append(state);
1220 }
1221 if (all_states.size() <= max_kept) {
1222 return;
1223 }
1224 std::sort(all_states.begin(),
1225 all_states.end(),
1226 [](const LayoutPanelState *a, const LayoutPanelState *b) {
1227 return a->last_used < b->last_used;
1228 });
1229 for (LayoutPanelState *state : all_states.as_span().drop_back(max_kept)) {
1232 }
1233}
1234
1236{
1237 BLO_read_struct_list(reader, Panel, lb);
1238
1239 LISTBASE_FOREACH (Panel *, panel, lb) {
1240 panel->runtime = MEM_new<Panel_Runtime>(__func__);
1241 panel->runtime_flag = 0;
1242 panel->activedata = nullptr;
1243 panel->type = nullptr;
1244 panel->drawname = nullptr;
1245 BLO_read_struct_list(reader, LayoutPanelState, &panel->layout_panel_states);
1246 LISTBASE_FOREACH (LayoutPanelState *, state, &panel->layout_panel_states) {
1247 BLO_read_string(reader, &state->idname);
1248 }
1249 /* Reduce the number of panel states to a reasonable number. This avoids the list getting
1250 * arbitrarily large over time. Ideally this could be done more eagerly and not only when
1251 * loading the file. However, it's hard to make sure that no other code is currently
1252 * referencing the panel states in other cases. */
1254 direct_link_panel_list(reader, &panel->children);
1255 }
1256}
1257
1258static void direct_link_region(BlendDataReader *reader, ARegion *region, int spacetype)
1259{
1260 direct_link_panel_list(reader, &region->panels);
1261
1263
1264 BLO_read_struct_list(reader, uiList, &region->ui_lists);
1266
1267 /* The area's search filter is runtime only, so we need to clear the active flag on read. */
1268 /* Clear runtime flags (e.g. search filter is runtime only). */
1270
1271 LISTBASE_FOREACH (uiList *, ui_list, &region->ui_lists) {
1272 ui_list->type = nullptr;
1273 ui_list->dyn_data = nullptr;
1274 BLO_read_struct(reader, IDProperty, &ui_list->properties);
1275 IDP_BlendDataRead(reader, &ui_list->properties);
1276 }
1277
1278 BLO_read_struct_list(reader, uiPreview, &region->ui_previews);
1279 LISTBASE_FOREACH (uiPreview *, ui_preview, &region->ui_previews) {
1280 ui_preview->id_session_uid = MAIN_ID_SESSION_UID_UNSET;
1281 ui_preview->tag = 0;
1282 }
1283
1284 if (spacetype == SPACE_EMPTY) {
1285 /* unknown space type, don't leak regiondata */
1286 region->regiondata = nullptr;
1287 }
1288 else if (region->flag & RGN_FLAG_TEMP_REGIONDATA) {
1289 /* Runtime data, don't use. */
1290 region->regiondata = nullptr;
1291 }
1292 else {
1293 if (spacetype == SPACE_VIEW3D) {
1294 if (region->regiontype == RGN_TYPE_WINDOW) {
1295 BLO_read_struct(reader, RegionView3D, &region->regiondata);
1296
1297 if (region->regiondata == nullptr) {
1298 /* To avoid crashing on some old files. */
1299 region->regiondata = MEM_callocN<RegionView3D>("region view3d");
1300 }
1301
1302 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
1303
1304 BLO_read_struct(reader, RegionView3D, &rv3d->localvd);
1305 BLO_read_struct(reader, BoundBox, &rv3d->clipbb);
1306
1307 rv3d->view_render = nullptr;
1308 rv3d->sms = nullptr;
1309 rv3d->smooth_timer = nullptr;
1310
1311 rv3d->rflag &= ~(RV3D_NAVIGATING | RV3D_PAINTING);
1312 rv3d->runtime_viewlock = 0;
1313 }
1314 }
1315 if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
1317 }
1318 }
1319
1320 region->runtime = MEM_new<blender::bke::ARegionRuntime>(__func__);
1321 region->v2d.sms = nullptr;
1322 region->v2d.alpha_hor = region->v2d.alpha_vert = 255; /* visible by default */
1323}
1324
1326{
1327 LISTBASE_FOREACH (ARegion *, region, regions) {
1328 if (region->regiontype == RGN_TYPE_WINDOW && region->regiondata == nullptr) {
1329 RegionView3D *rv3d;
1330
1331 rv3d = MEM_callocN<RegionView3D>("region v3d patch");
1332 rv3d->persp = char(v3d->persp);
1333 rv3d->view = char(v3d->view);
1334 rv3d->dist = v3d->dist;
1335 copy_v3_v3(rv3d->ofs, v3d->ofs);
1336 copy_qt_qt(rv3d->viewquat, v3d->viewquat);
1337 region->regiondata = rv3d;
1338 }
1339 }
1340
1341 /* this was not initialized correct always */
1342 if (v3d->gridsubdiv == 0) {
1343 v3d->gridsubdiv = 10;
1344 }
1345}
1346
1347static void direct_link_area(BlendDataReader *reader, ScrArea *area)
1348{
1349 const bool has_spacedata = area->spacedata.first != nullptr;
1351 reader, &area->spacedata, [](const SpaceLink &sl) {
1352 const SpaceType *space_type = BKE_spacetype_from_id(sl.spacetype);
1353 return space_type ? size_t(space_type->struct_size) : sizeof(SpaceLink);
1354 });
1355 BLO_read_struct_list(reader, ARegion, &(area->regionbase));
1356
1357 /* The first space data is the active one, its type must match the area space type. If it
1358 * failed to read, leave the area empty. Files before 2.50 can have areas without space data
1359 * of their own type (e.g. the info header), which versioning handles. */
1360 const SpaceLink *sl_active = static_cast<const SpaceLink *>(area->spacedata.first);
1361 if (sl_active == nullptr) {
1362 /* Space types removed from DNA (e.g. timeline and logic editors) are handled below. */
1363 if (has_spacedata && BKE_spacetype_exists(area->spacetype)) {
1364 area->spacetype = SPACE_EMPTY;
1365 }
1366 }
1367 else if (sl_active->spacetype != area->spacetype && BLO_read_fileversion_get(reader) >= 250) {
1368 BLO_read_data_invalidate(reader, "Corrupt .blend file, mismatched area space type.");
1369 area->spacetype = SPACE_EMPTY;
1370 }
1371
1373 area->type = nullptr; /* spacetype callbacks */
1374
1375 area->runtime = ScrArea_Runtime{};
1376
1377 /* Should always be unset so that rna_Area_type_get works correctly. */
1378 area->butspacetype = SPACE_EMPTY;
1379
1380 area->region_active_win = -1;
1381
1382 area->flag &= ~AREA_FLAG_ACTIVE_TOOL_UPDATE;
1383
1384 BLO_read_struct(reader, ScrGlobalAreaData, &area->global);
1385
1386 /* if we do not have the spacetype registered we cannot
1387 * free it, so don't allocate any new memory for such spacetypes. */
1388 if (!BKE_spacetype_exists(area->spacetype)) {
1389 /* Hint for versioning code to replace deprecated space types. */
1390 area->butspacetype = area->spacetype;
1391
1392 area->spacetype = SPACE_EMPTY;
1393 }
1394
1395 LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1396 direct_link_region(reader, region, area->spacetype);
1397 }
1398
1399 /* accident can happen when read/save new file with older version */
1400 /* 2.50: we now always add spacedata for info */
1401 if (area->spacedata.first == nullptr) {
1402 SpaceInfo *sinfo = MEM_callocN<SpaceInfo>("spaceinfo");
1403 area->spacetype = sinfo->spacetype = SPACE_INFO;
1404 BLI_addtail(&area->spacedata, sinfo);
1405 }
1406 /* add local view3d too */
1407 else if (area->spacetype == SPACE_VIEW3D) {
1409 &area->regionbase);
1410 }
1411
1412 LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1413 BLO_read_struct_list(reader, ARegion, &(sl->regionbase));
1414
1415 /* if we do not have the spacetype registered we cannot
1416 * free it, so don't allocate any new memory for such spacetypes. */
1417 if (!BKE_spacetype_exists(sl->spacetype)) {
1418 sl->spacetype = SPACE_EMPTY;
1419 }
1420
1421 LISTBASE_FOREACH (ARegion *, region, &sl->regionbase) {
1422 direct_link_region(reader, region, sl->spacetype);
1423 }
1424
1425 SpaceType *space_type = BKE_spacetype_from_id(sl->spacetype);
1426 if (space_type && space_type->blend_read_data) {
1427 space_type->blend_read_data(reader, sl);
1428 }
1429 }
1430
1432
1433 BLO_read_struct(reader, ScrVert, &area->v1);
1434 BLO_read_struct(reader, ScrVert, &area->v2);
1435 BLO_read_struct(reader, ScrVert, &area->v3);
1436 BLO_read_struct(reader, ScrVert, &area->v4);
1437}
1438
1440{
1441 BLO_read_struct_list(reader, ScrVert, &area_map->vertbase);
1442 BLO_read_struct_list(reader, ScrEdge, &area_map->edgebase);
1443 BLO_read_struct_list(reader, ScrArea, &area_map->areabase);
1444 LISTBASE_FOREACH (ScrArea *, area, &area_map->areabase) {
1445 direct_link_area(reader, area);
1446 }
1447
1448 /* edges */
1449 LISTBASE_FOREACH (ScrEdge *, se, &area_map->edgebase) {
1450 BLO_read_struct(reader, ScrVert, &se->v1);
1451 BLO_read_struct(reader, ScrVert, &se->v2);
1452 BKE_screen_sort_scrvert(&se->v1, &se->v2);
1453
1454 if (se->v1 == nullptr || se->v2 == nullptr) {
1455 BLI_freelinkN(&area_map->edgebase, se);
1456
1457 return false;
1458 }
1459 }
1460
1461 return true;
1462}
1463
1468static void regions_remove_invalid(SpaceType *space_type, ListBase *regionbase)
1469{
1470 LISTBASE_FOREACH_MUTABLE (ARegion *, region, regionbase) {
1471 if (BKE_regiontype_from_id(space_type, region->regiontype) != nullptr) {
1472 continue;
1473 }
1474
1475 printf("Warning: region type %d missing in space type \"%s\" (id: %d) - removing region\n",
1476 region->regiontype,
1477 space_type->name,
1478 space_type->spaceid);
1479
1480 BKE_area_region_free(space_type, region);
1481 BLI_freelinkN(regionbase, region);
1482 }
1483}
1484
1486{
1487 LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1488 SpaceType *space_type = BKE_spacetype_from_id(sl->spacetype);
1489 ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase : &sl->regionbase;
1490
1491 /* We cannot restore the region type without a valid space type. So delete all regions to make
1492 * sure no data is kept around that can't be restored safely (like the type dependent
1493 * #ARegion.regiondata). */
1494 if (!space_type) {
1495 LISTBASE_FOREACH_MUTABLE (ARegion *, region, regionbase) {
1496 BKE_area_region_free(nullptr, region);
1497 BLI_freelinkN(regionbase, region);
1498 }
1499
1500 continue;
1501 }
1502
1503 if (space_type->blend_read_after_liblink) {
1504 space_type->blend_read_after_liblink(reader, parent_id, sl);
1505 }
1506
1507 regions_remove_invalid(space_type, regionbase);
1508 }
1509}
#define IDP_BlendDataRead(reader, prop)
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1243
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1453
@ IDTYPE_FLAGS_NO_ANIMDATA
Definition BKE_idtype.hh:46
@ IDTYPE_FLAGS_ONLY_APPEND
Definition BKE_idtype.hh:38
@ IDTYPE_FLAGS_NO_COPY
Definition BKE_idtype.hh:30
@ IDTYPE_FLAGS_NO_MEMFILE_UNDO
Definition BKE_idtype.hh:55
#define MAIN_ID_SESSION_UID_UNSET
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2611
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
@ IDWALK_CB_NOP
LibraryForeachIDFlag BKE_lib_query_foreachid_process_flags_get(const LibraryForeachIDData *data)
Definition lib_query.cc:129
@ IDWALK_DO_DEPRECATED_POINTERS
@ IDWALK_INCLUDE_UI
void BKE_previewimg_blend_write(BlendWriter *writer, const PreviewImage *prv)
void BKE_previewimg_free(PreviewImage **prv)
void BKE_previewimg_blend_read(BlendDataReader *reader, PreviewImage *prv)
ARegionDrawLockFlags
#define BLI_assert_unreachable()
Definition BLI_assert.h:93
#define BLI_assert(a)
Definition BLI_assert.h:46
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:586
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:534
#define LISTBASE_FOREACH(type, var, list)
BLI_INLINE void BLI_listbase_clear(ListBase *lb)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:270
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
void void BLI_freelistN(ListBase *listbase) ATTR_NONNULL(1)
Definition listbase.cc:497
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:111
#define LISTBASE_FOREACH_INDEX(type, var, list, index_var)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:131
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
#define M_SQRT2
void copy_qt_qt(float q[4], const float a[4])
MINLINE void copy_v3_v3(float r[3], const float a[3])
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2])
std::string data
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
Definition string.cc:41
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition string.cc:30
char * STRNCPY(char(&dst)[N], const char *src)
Definition BLI_string.h:688
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
Compatibility-like things for windows.
int BLO_read_fileversion_get(BlendDataReader *reader)
Definition readfile.cc:5588
#define BLO_write_struct_at_address_with_filecode(writer, filecode, struct_name, address, data_ptr)
void BLO_read_data_invalidate(BlendDataReader *reader, const char *message)
Definition readfile.cc:5937
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, blender::FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:5647
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:5783
void BLO_write_string(BlendWriter *writer, const char *data_ptr)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_write_struct_list(writer, struct_name, list_ptr)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_SCREEN
void BPY_callback_screen_free(ARegionType *art)
#define FILTER_ID_SCR
Definition DNA_ID.h:1141
@ INDEX_ID_SCR
Definition DNA_ID.h:1261
#define FILTER_ID_SCE
Definition DNA_ID.h:1125
@ ID_SCR
#define ID_SCRN
#define DNA_struct_default_get(struct_name)
@ LAYOUT_PANEL_STATE_FLAG_OPEN
@ RGN_ALIGN_BOTTOM
@ RGN_ALIGN_TOP
#define AREAMAP_FROM_SCREEN(screen)
@ RGN_TYPE_TOOL_HEADER
@ RGN_TYPE_WINDOW
@ RGN_TYPE_ASSET_SHELF
@ RGN_TYPE_FOOTER
@ RGN_TYPE_HEADER
struct bScreen bScreen
#define RGN_TYPE_ANY
@ RGN_FLAG_POLL_FAILED
@ RGN_FLAG_TEMP_REGIONDATA
@ RGN_FLAG_SEARCH_FILTER_ACTIVE
@ SCREENFULL
@ SCREENMAXIMIZED
@ SPACE_OUTLINER
@ SPACE_USERPREF
@ SPACE_FILE
@ SPACE_PROPERTIES
@ SPACE_EMPTY
@ SPACE_VIEW3D
@ SPACE_INFO
#define SPACE_TYPE_ANY
@ USER_HEADER_BOTTOM
@ RV3D_PAINTING
@ RV3D_NAVIGATING
@ RV3D_CAMOB
@ RV3D_PERSP
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition btDbvt.cpp:52
unsigned int U
Definition btGjkEpa3.h:78
constexpr int64_t size() const
constexpr const char * data() const
int64_t size() const
void append(const T &value)
Span< T > as_span() const
Scene scene
DEGForeachIDComponentCallback callback
#define powf(x, y)
#define sqrtf(x)
#define GS(x)
PointerRNA ptr
unsigned int uint32_t
#define printf(...)
void * MEM_callocN(size_t len, const char *str)
Definition mallocn.cc:118
void * MEM_dupallocN(const void *vmemh)
Definition mallocn.cc:143
void MEM_freeN(void *vmemh)
Definition mallocn.cc:113
static ulong state[N]
void region_blend_read_data(BlendDataReader *reader, ARegion *region)
void region_blend_write(BlendWriter *writer, ARegion *region)
void region_free(ARegion *region)
static void(* region_refresh_tag_gizmomap_callback)(wmGizmoMap *)
Definition screen.cc:476
static void area_region_panels_free_recursive(Panel *panel)
Definition screen.cc:573
static void(* region_free_gizmomap_callback)(wmGizmoMap *)
Definition screen.cc:509
void BKE_screen_remove_unused_scrverts(bScreen *screen)
Definition screen.cc:811
void BKE_screen_view3d_shading_blend_read_data(BlendDataReader *reader, View3DShading *shading)
Definition screen.cc:1097
bool BKE_screen_is_used(const bScreen *screen)
Definition screen.cc:1055
void BKE_screen_area_map_blend_write(BlendWriter *writer, ScrAreaMap *area_map)
Definition screen.cc:1198
void BKE_spacetypes_free()
Definition screen.cc:246
static void regions_remove_invalid(SpaceType *space_type, ListBase *regionbase)
Definition screen.cc:1468
void BKE_screen_remove_unused_scredges(bScreen *screen)
Definition screen.cc:766
static void screen_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition screen.cc:121
ARegion * BKE_area_find_region_xy(const ScrArea *area, const int regiontype, const int xy[2])
Definition screen.cc:876
void BKE_spacedata_copylist(ListBase *lb_dst, ListBase *lb_src)
Definition screen.cc:402
static void layout_panel_state_delete(LayoutPanelState *state)
Definition screen.cc:553
LayoutPanelState * BKE_panel_layout_panel_state_ensure(Panel *panel, const StringRef idname, const bool default_closed)
Definition screen.cc:516
float BKE_screen_view3d_zoom_from_fac(float zoomfac)
Definition screen.cc:1045
void BKE_screen_area_blend_read_after_liblink(BlendLibReader *reader, ID *parent_id, ScrArea *area)
Definition screen.cc:1485
void BKE_spacedata_callback_id_remap_set(void(*func)(ScrArea *area, SpaceLink *sl, ID *, ID *))
Definition screen.cc:461
ARegion * BKE_screen_find_main_region_at_xy(const bScreen *screen, const int space_type, const int xy[2])
Definition screen.cc:1024
void BKE_screen_remove_double_scrverts(bScreen *screen)
Definition screen.cc:698
bool BKE_screen_blend_read_data(BlendDataReader *reader, bScreen *screen)
Definition screen.cc:136
void BKE_spacetype_register(std::unique_ptr< SpaceType > st)
Definition screen.cc:276
ARegion * BKE_area_find_region_active_win(const ScrArea *area)
Definition screen.cc:860
void BKE_spacedata_freelist(ListBase *lb)
Definition screen.cc:301
static void write_area(BlendWriter *writer, ScrArea *area)
Definition screen.cc:1163
std::optional< std::string > BKE_screen_path_from_screen_to_space(const PointerRNA *ptr)
Definition screen.cc:925
ScrArea * BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap, const int spacetype, const int xy[2])
Definition screen.cc:965
ARegion * BKE_area_region_new()
Definition screen.cc:383
static void region_copylist(SpaceType *st, ListBase *lb_dst, ListBase *lb_src)
Definition screen.cc:391
Span< std::unique_ptr< SpaceType > > BKE_spacetypes_list()
Definition screen.cc:271
void BKE_screen_view3d_shading_blend_write(BlendWriter *writer, View3DShading *shading)
Definition screen.cc:1090
void BKE_region_callback_free_gizmomap_set(void(*callback)(wmGizmoMap *))
Definition screen.cc:511
ARegion * BKE_screen_find_region_xy(const bScreen *screen, const int regiontype, const int xy[2])
Definition screen.cc:902
void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2)
Definition screen.cc:689
ScrEdge * BKE_screen_find_edge(const bScreen *screen, ScrVert *v1, ScrVert *v2)
Definition screen.cc:677
static void remove_least_recently_used_panel_states(Panel &panel, const int64_t max_kept)
Definition screen.cc:1215
static void direct_link_panel_list(BlendDataReader *reader, ListBase *lb)
Definition screen.cc:1235
static void write_region(BlendWriter *writer, ARegion *region, int spacetype)
Definition screen.cc:1105
static Vector< std::unique_ptr< SpaceType > > & get_space_types()
Definition screen.cc:210
void BKE_screen_area_free(ScrArea *area)
Definition screen.cc:639
bool BKE_spacetype_exists(int spaceid)
Definition screen.cc:290
SpaceType * BKE_spacetype_from_id(int spaceid)
Definition screen.cc:251
static void write_panel_list(BlendWriter *writer, ListBase *lb)
Definition screen.cc:1151
ARegionType * BKE_regiontype_from_id(const SpaceType *st, int regionid)
Definition screen.cc:261
void BKE_screen_header_alignment_reset(bScreen *screen)
Definition screen.cc:1060
ARegion * BKE_region_find_in_listbase_by_type(const ListBase *regionbase, const int region_type)
Definition screen.cc:836
void BKE_screen_area_map_free(ScrAreaMap *area_map)
Definition screen.cc:655
void BKE_spacedata_draw_locks(ARegionDrawLockFlags lock_flags)
Definition screen.cc:419
void BKE_spacedata_id_unref(ScrArea *area, SpaceLink *sl, ID *id)
Definition screen.cc:466
ARegion * BKE_screen_find_region_type(const bScreen *screen, const int region_type)
Definition screen.cc:892
void BKE_area_region_free(SpaceType *st, ARegion *region)
Definition screen.cc:593
void BKE_screen_gizmo_tag_refresh(bScreen *screen)
Definition screen.cc:483
bool BKE_screen_is_fullscreen_area(const bScreen *screen)
Definition screen.cc:1050
bool BKE_screen_area_map_blend_read_data(BlendDataReader *reader, ScrAreaMap *area_map)
Definition screen.cc:1439
ScrArea * BKE_screen_find_big_area(const bScreen *screen, const int spacetype, const short min)
Definition screen.cc:945
static void(* spacedata_id_remap_cb)(ScrArea *area, SpaceLink *sl, ID *old_id, ID *new_id)
Definition screen.cc:456
void BKE_screen_view3d_scene_sync(bScreen *screen, Scene *scene)
Definition screen.cc:1005
void BKE_panel_free(Panel *panel)
Definition screen.cc:559
void BKE_screen_remove_double_scredges(bScreen *screen)
Definition screen.cc:750
void BKE_region_callback_refresh_tag_gizmomap_set(void(*callback)(wmGizmoMap *))
Definition screen.cc:478
void BKE_screen_runtime_refresh_for_blendfile(bScreen *screen)
Definition screen.cc:498
float BKE_screen_view3d_zoom_to_fac(float camzoom)
Definition screen.cc:1040
Panel * BKE_panel_new(PanelType *panel_type)
Definition screen.cc:542
IDTypeInfo IDType_ID_SCR
Definition screen.cc:169
void BKE_screen_view3d_shading_init(View3DShading *shading)
Definition screen.cc:1018
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
Definition screen.cc:847
ScrArea * BKE_screen_find_area_xy(const bScreen *screen, const int spacetype, const int xy[2])
Definition screen.cc:982
ARegion * BKE_area_region_copy(const SpaceType *st, const ARegion *region)
Definition screen.cc:346
void BKE_screen_view3d_sync(View3D *v3d, Scene *scene)
Definition screen.cc:987
ScrArea * BKE_screen_find_area_from_space(const bScreen *screen, const SpaceLink *sl)
Definition screen.cc:914
static void direct_link_area(BlendDataReader *reader, ScrArea *area)
Definition screen.cc:1347
static void write_uilist(BlendWriter *writer, uiList *ui_list)
Definition screen.cc:1142
void BKE_area_region_panels_free(ListBase *panels)
Definition screen.cc:581
static void screen_foreach_id(ID *id, LibraryForeachIDData *data)
Definition screen.cc:105
ARegion * BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *area, int region_type)
Definition screen.cc:433
void BKE_screen_view3d_do_versions_250(View3D *v3d, ListBase *regions)
Definition screen.cc:1325
static void screen_blend_read_after_liblink(BlendLibReader *reader, ID *id)
Definition screen.cc:160
void BKE_screen_free_data(bScreen *screen)
Definition screen.cc:666
static void direct_link_region(BlendDataReader *reader, ARegion *region, int spacetype)
Definition screen.cc:1258
void BKE_screen_foreach_id_screen_area(LibraryForeachIDData *data, ScrArea *area)
Definition screen.cc:92
static void panel_list_copy(ListBase *newlb, const ListBase *lb)
Definition screen.cc:321
static void screen_free_data(ID *id)
Definition screen.cc:67
#define min(a, b)
Definition sort.cc:36
__int64 int64_t
Definition stdint.h:89
void(* free)(ARegion *)
void *(* duplicate)(void *poin)
void * regiondata
struct ARegion * prev
ListBase panels_category_active
ListBase ui_previews
ARegionRuntimeHandle * runtime
struct ARegion * next
ListBase panels
ListBase ui_lists
ListBase view_states
Definition DNA_ID.h:404
char name[66]
Definition DNA_ID.h:415
void * last
void * first
char idname[BKE_ST_MAXNAME]
struct PanelType * type
ListBase layout_panel_states
struct Panel_Runtime * runtime
uint32_t layout_panel_states_clock
void * activedata
char * drawname
char panelname[64]
ListBase children
ID * owner_id
Definition RNA_types.hh:51
void * data
Definition RNA_types.hh:53
struct SmoothView3DStore * sms
struct ViewRender * view_render
struct RegionView3D * localvd
struct wmTimer * smooth_timer
struct BoundBox * clipbb
struct Object * camera
ListBase vertbase
ListBase edgebase
ListBase areabase
struct bToolRef * tool
ListBase handlers
ScrVert * v2
ListBase actionzones
ScrVert * v3
ListBase spacedata
short region_active_win
struct SpaceType * type
bScreen * full
ScrArea_Runtime runtime
ScrVert * v1
ListBase regionbase
ScrGlobalAreaData * global
ScrVert * v4
ScrVert * v1
struct ScrEdge * next
ScrVert * v2
struct ScrVert * next
struct ScrVert * newv
ListBase regiontypes
SpaceLink *(* duplicate)(SpaceLink *sl)
void(* free)(SpaceLink *sl)
Definition BKE_screen.hh:97
void(* blend_read_data)(BlendDataReader *reader, SpaceLink *space_link)
void(* blend_read_after_liblink)(BlendLibReader *reader, ID *parent_id, SpaceLink *space_link)
~SpaceType()
Definition screen.cc:217
char name[BKE_ST_MAXNAME]
Definition BKE_screen.hh:83
void(* blend_write)(BlendWriter *writer, SpaceLink *space_link)
void(* foreach_id)(SpaceLink *space_link, LibraryForeachIDData *data)
char alpha_vert
struct SmoothView2DStore * sms
struct IDProperty * prop
struct Object * camera
short gridsubdiv
struct View3D * localvd
short scenelock
ListBase regionbase
ListBase edgebase
PreviewImage * preview
ListBase regionbase
struct wmTooltipState * tool_tip
ListBase vertbase
struct wmTimer * animtimer
ListBase areabase
struct ARegion * active_region
IDProperty * properties
short y
short x
#define N_(msgid)
int xy[2]
Definition wm_draw.cc:174