Blender V5.3
screen_edit.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cmath>
10#include <cstring>
11#include <limits>
12
13#include "DNA_space_types.h"
14#include "MEM_guardedalloc.h"
15
16#include "DNA_object_types.h"
17#include "DNA_scene_types.h"
18#include "DNA_userdef_types.h"
19
20#include "BLI_listbase.hh"
21#include "BLI_rect.hh"
22#include "BLI_string_utf8.hh"
23#include "BLI_utildefines.hh"
24
25#include "BKE_context.hh"
26#include "BKE_global.hh"
27#include "BKE_icons.hh"
28#include "BKE_image.hh"
29#include "BKE_layer.hh"
30#include "BKE_lib_id.hh"
31#include "BKE_main.hh"
32#include "BKE_report.hh"
33#include "BKE_scene.hh"
34#include "BKE_screen.hh"
35#include "BKE_sound.hh"
36#include "BKE_workspace.hh"
37
38#include "WM_api.hh"
39#include "WM_types.hh"
40
41#include "ED_clip.hh"
42#include "ED_node.hh"
43#include "ED_screen.hh"
44#include "ED_screen_types.hh"
45#include "ED_sequencer.hh"
46
47#include "RNA_access.hh"
48#include "RNA_enum_types.hh"
49
50#include "UI_interface.hh"
51
52#include "WM_message.hh"
53#include "WM_toolsystem.hh"
54
56
57#include "screen_intern.hh" /* own module include */
58
59namespace blender {
60
61/* adds no space data */
63 ScrVert *bottom_left,
64 ScrVert *top_left,
65 ScrVert *top_right,
66 ScrVert *bottom_right,
67 const eSpace_Type space_type)
68{
69 ScrArea *area = MEM_new<ScrArea>("addscrarea");
70
71 area->v1 = bottom_left;
72 area->v2 = top_left;
73 area->v3 = top_right;
74 area->v4 = bottom_right;
75 area->spacetype = space_type;
76
77 BLI_addtail(&area_map->areabase, area);
78
79 return area;
80}
82 ScrVert *left_bottom,
83 ScrVert *left_top,
84 ScrVert *right_top,
85 ScrVert *right_bottom,
86 const eSpace_Type space_type)
87{
88 return screen_addarea_ex(
89 AREAMAP_FROM_SCREEN(screen), left_bottom, left_top, right_top, right_bottom, space_type);
90}
91
92static void screen_delarea(bContext *C, bScreen *screen, ScrArea *area)
93{
94
95 ED_area_exit(C, area);
96
98
99 BLI_remlink(&screen->areabase, area);
100 MEM_delete(area);
101}
102
104 bScreen *screen,
105 ScrArea *area,
106 const eScreenAxis dir_axis,
107 const float fac)
108{
109 ScrArea *newa = nullptr;
110
111 if (area == nullptr) {
112 return nullptr;
113 }
114
115 rcti window_rect;
116 WM_window_rect_calc(win, &window_rect);
117
118 short split = screen_geom_find_area_split_point(area, &window_rect, dir_axis, fac);
119 if (split == 0) {
120 return nullptr;
121 }
122
123 /* NOTE(@ideasman42): regarding (fac > 0.5f) checks below.
124 * normally it shouldn't matter which is used since the copy should match the original
125 * however with viewport rendering and python console this isn't the case. */
126
127 if (dir_axis == SCREEN_AXIS_H) {
128 /* new vertices */
129 ScrVert *sv1 = screen_geom_vertex_add(screen, area->v1->vec.x, split);
130 ScrVert *sv2 = screen_geom_vertex_add(screen, area->v4->vec.x, split);
131
132 /* new edges */
133 screen_geom_edge_add(screen, area->v1, sv1);
134 screen_geom_edge_add(screen, sv1, area->v2);
135 screen_geom_edge_add(screen, area->v3, sv2);
136 screen_geom_edge_add(screen, sv2, area->v4);
137 screen_geom_edge_add(screen, sv1, sv2);
138
139 if (fac > 0.5f) {
140 /* new areas: top */
141 newa = screen_addarea(screen, sv1, area->v2, area->v3, sv2, eSpace_Type(area->spacetype));
142
143 /* area below */
144 area->v2 = sv1;
145 area->v3 = sv2;
146 }
147 else {
148 /* new areas: bottom */
149 newa = screen_addarea(screen, area->v1, sv1, sv2, area->v4, eSpace_Type(area->spacetype));
150
151 /* area above */
152 area->v1 = sv1;
153 area->v4 = sv2;
154 }
155
156 ED_area_data_copy(newa, area, true);
157 }
158 else {
159 /* new vertices */
160 ScrVert *sv1 = screen_geom_vertex_add(screen, split, area->v1->vec.y);
161 ScrVert *sv2 = screen_geom_vertex_add(screen, split, area->v2->vec.y);
162
163 /* new edges */
164 screen_geom_edge_add(screen, area->v1, sv1);
165 screen_geom_edge_add(screen, sv1, area->v4);
166 screen_geom_edge_add(screen, area->v2, sv2);
167 screen_geom_edge_add(screen, sv2, area->v3);
168 screen_geom_edge_add(screen, sv1, sv2);
169
170 if (fac > 0.5f) {
171 /* new areas: right */
172 newa = screen_addarea(screen, sv1, sv2, area->v3, area->v4, eSpace_Type(area->spacetype));
173
174 /* area left */
175 area->v3 = sv2;
176 area->v4 = sv1;
177 }
178 else {
179 /* new areas: left */
180 newa = screen_addarea(screen, area->v1, area->v2, sv2, sv1, eSpace_Type(area->spacetype));
181
182 /* area right */
183 area->v1 = sv1;
184 area->v2 = sv2;
185 }
186
187 ED_area_data_copy(newa, area, true);
188 }
189
192
193 return newa;
194}
195
196bScreen *screen_add(Main *bmain, const char *name, const rcti *rect)
197{
198 bScreen *screen = BKE_id_new<bScreen>(bmain, name);
199
200 ScrVert *sv1 = screen_geom_vertex_add(screen, rect->xmin, rect->ymin);
201 ScrVert *sv2 = screen_geom_vertex_add(screen, rect->xmin, rect->ymax - 1);
202 ScrVert *sv3 = screen_geom_vertex_add(screen, rect->xmax - 1, rect->ymax - 1);
203 ScrVert *sv4 = screen_geom_vertex_add(screen, rect->xmax - 1, rect->ymin);
204
205 screen_geom_edge_add(screen, sv1, sv2);
206 screen_geom_edge_add(screen, sv2, sv3);
207 screen_geom_edge_add(screen, sv3, sv4);
208 screen_geom_edge_add(screen, sv4, sv1);
209
210 /* dummy type, no spacedata */
211 screen_addarea(screen, sv1, sv2, sv3, sv4, SPACE_EMPTY);
212
213 return screen;
214}
215
216void screen_new_activate_prepare(const wmWindow *win, bScreen *screen_new)
217{
218 screen_new->winid = win->winid;
219 screen_new->do_refresh = true;
220 screen_new->do_draw = true;
221}
222
224{
225 if (sa_a == nullptr || sa_b == nullptr || sa_a == sa_b) {
226 return SCREEN_DIR_NONE;
227 }
228
229 short left_a = sa_a->v1->vec.x;
230 short right_a = sa_a->v3->vec.x;
231 short top_a = sa_a->v3->vec.y;
232 short bottom_a = sa_a->v1->vec.y;
233
234 short left_b = sa_b->v1->vec.x;
235 short right_b = sa_b->v3->vec.x;
236 short top_b = sa_b->v3->vec.y;
237 short bottom_b = sa_b->v1->vec.y;
238
239 /* How much these areas share a common edge. */
240 short overlapx = std::min(right_a, right_b) - std::max(left_a, left_b);
241 short overlapy = std::min(top_a, top_b) - std::max(bottom_a, bottom_b);
242
243 /* Minimum overlap required. */
244 const short minx = std::min({int(AREAJOINTOLERANCEX), right_a - left_a, right_b - left_b});
245 const short miny = std::min({int(AREAJOINTOLERANCEY), top_a - bottom_a, top_b - bottom_b});
246
247 if (top_a == bottom_b && overlapx >= minx) {
248 return eScreenDir(1); /* sa_a to bottom of sa_b = N */
249 }
250 if (bottom_a == top_b && overlapx >= minx) {
251 return eScreenDir(3); /* sa_a on top of sa_b = S */
252 }
253 if (left_a == right_b && overlapy >= miny) {
254 return eScreenDir{}; /* sa_a to right of sa_b = W */
255 }
256 if (right_a == left_b && overlapy >= miny) {
257 return eScreenDir(2); /* sa_a to left of sa_b = E */
258 }
259
260 return eScreenDir(-1);
261}
262
264 ScrArea *sa_a, ScrArea *sa_b, const eScreenDir dir, int *r_offset1, int *r_offset2)
265{
266 if (sa_a == nullptr || sa_b == nullptr) {
267 *r_offset1 = std::numeric_limits<int>::max();
268 *r_offset2 = std::numeric_limits<int>::max();
269 }
270 else if (dir == SCREEN_DIR_W) { /* West: sa on right and sa_b to the left. */
271 *r_offset1 = sa_b->v3->vec.y - sa_a->v2->vec.y;
272 *r_offset2 = sa_b->v4->vec.y - sa_a->v1->vec.y;
273 }
274 else if (dir == SCREEN_DIR_N) { /* North: sa below and sa_b above. */
275 *r_offset1 = sa_a->v2->vec.x - sa_b->v1->vec.x;
276 *r_offset2 = sa_a->v3->vec.x - sa_b->v4->vec.x;
277 }
278 else if (dir == SCREEN_DIR_E) { /* East: sa on left and sa_b to the right. */
279 *r_offset1 = sa_b->v2->vec.y - sa_a->v3->vec.y;
280 *r_offset2 = sa_b->v1->vec.y - sa_a->v4->vec.y;
281 }
282 else if (dir == SCREEN_DIR_S) { /* South: sa above and sa_b below. */
283 *r_offset1 = sa_a->v1->vec.x - sa_b->v2->vec.x;
284 *r_offset2 = sa_a->v4->vec.x - sa_b->v3->vec.x;
285 }
286 else {
288 *r_offset1 = std::numeric_limits<int>::max();
289 *r_offset2 = std::numeric_limits<int>::max();
290 }
291}
292
293/* Screen verts with horizontal position equal to from_x are moved to to_x. */
294static void screen_verts_halign(const wmWindow *win,
295 const bScreen *screen,
296 const short from_x,
297 const short to_x)
298{
299 ED_screen_verts_iter(win, screen, v1)
300 {
301 if (v1->vec.x == from_x) {
302 v1->vec.x = to_x;
303 }
304 }
305}
306
307/* Screen verts with vertical position equal to from_y are moved to to_y. */
308static void screen_verts_valign(const wmWindow *win,
309 const bScreen *screen,
310 const short from_y,
311 const short to_y)
312{
313 ED_screen_verts_iter(win, screen, v1)
314 {
315 if (v1->vec.y == from_y) {
316 v1->vec.y = to_y;
317 }
318 }
319}
320
321/* Test if two adjoining areas can be aligned by having their screen edges adjusted. */
323 ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2, eScreenDir dir)
324{
325 if (dir == SCREEN_DIR_NONE) {
326 return false;
327 }
328
329 int offset1;
330 int offset2;
331 area_getoffsets(sa1, sa2, dir, &offset1, &offset2);
332
334 if ((abs(offset1) >= tolerance) || (abs(offset2) >= tolerance)) {
335 /* Misalignment is too great. */
336 return false;
337 }
338
339 /* Areas that are _smaller_ than minimum sizes, sharing an edge to be moved. See #100772. */
340 if (SCREEN_DIR_IS_VERTICAL(dir)) {
341 const short xmin = std::min(sa1->v1->vec.x, sa2->v1->vec.x);
342 const short xmax = std::max(sa1->v3->vec.x, sa2->v3->vec.x);
343 for (ScrArea &area : screen->areabase) {
344 if (ELEM(&area, sa1, sa2)) {
345 continue;
346 }
347 if (area.v3->vec.x - area.v1->vec.x < tolerance &&
348 (area.v1->vec.x == xmin || area.v3->vec.x == xmax))
349 {
350 BKE_report(reports, RPT_ERROR, "A narrow vertical area interferes with this operation");
351 return false;
352 }
353 }
354 }
355 else {
356 const short ymin = std::min(sa1->v1->vec.y, sa2->v1->vec.y);
357 const short ymax = std::max(sa1->v3->vec.y, sa2->v3->vec.y);
358 for (ScrArea &area : screen->areabase) {
359 if (ELEM(&area, sa1, sa2)) {
360 continue;
361 }
362 if (area.v3->vec.y - area.v1->vec.y < tolerance &&
363 (area.v1->vec.y == ymin || area.v3->vec.y == ymax))
364 {
365 BKE_report(reports, RPT_ERROR, "A narrow horizontal area interferes with this operation");
366 return false;
367 }
368 }
369 }
370
371 return true;
372}
373
374/* Adjust all screen edges to allow joining two areas. 'dir' value is like area_getorientation().
375 */
377 ReportList *reports,
378 bScreen *screen,
379 ScrArea *sa1,
380 ScrArea *sa2,
381 const eScreenDir dir)
382{
383 if (!screen_areas_can_align(reports, screen, sa1, sa2, dir)) {
384 return false;
385 }
386
387 wmWindow *win = CTX_wm_window(C);
388
389 if (SCREEN_DIR_IS_HORIZONTAL(dir)) {
390 /* horizontal join, use average for new top and bottom. */
391 int top = (sa1->v2->vec.y + sa2->v2->vec.y) / 2;
392 int bottom = (sa1->v4->vec.y + sa2->v4->vec.y) / 2;
393
394 /* Move edges exactly matching source top and bottom. */
395 screen_verts_valign(win, screen, sa1->v2->vec.y, top);
396 screen_verts_valign(win, screen, sa1->v4->vec.y, bottom);
397
398 /* Move edges exactly matching target top and bottom. */
399 screen_verts_valign(win, screen, sa2->v2->vec.y, top);
400 screen_verts_valign(win, screen, sa2->v4->vec.y, bottom);
401 }
402 else {
403 /* Vertical join, use averages for new left and right. */
404 int left = (sa1->v1->vec.x + sa2->v1->vec.x) / 2;
405 int right = (sa1->v3->vec.x + sa2->v3->vec.x) / 2;
406
407 /* Move edges exactly matching source left and right. */
408 screen_verts_halign(win, screen, sa1->v1->vec.x, left);
409 screen_verts_halign(win, screen, sa1->v3->vec.x, right);
410
411 /* Move edges exactly matching target left and right */
412 screen_verts_halign(win, screen, sa2->v1->vec.x, left);
413 screen_verts_halign(win, screen, sa2->v3->vec.x, right);
414 }
415
416 return true;
417}
418
419/* Simple join of two areas without any splitting. Will return false if not possible. */
421 bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
422{
423 const eScreenDir dir = area_getorientation(sa1, sa2);
424
425 /* Ensure that the area edges are exactly aligned. */
426 if (!screen_areas_align(C, reports, screen, sa1, sa2, dir)) {
427 return false;
428 }
429
430 if (dir == SCREEN_DIR_W) { /* sa1 to right of sa2 = West. */
431 sa1->v1 = sa2->v1; /* BL */
432 sa1->v2 = sa2->v2; /* TL */
433 screen_geom_edge_add(screen, sa1->v2, sa1->v3);
434 screen_geom_edge_add(screen, sa1->v1, sa1->v4);
435 }
436 else if (dir == SCREEN_DIR_N) { /* sa1 to bottom of sa2 = North. */
437 sa1->v2 = sa2->v2; /* TL */
438 sa1->v3 = sa2->v3; /* TR */
439 screen_geom_edge_add(screen, sa1->v1, sa1->v2);
440 screen_geom_edge_add(screen, sa1->v3, sa1->v4);
441 }
442 else if (dir == SCREEN_DIR_E) { /* sa1 to left of sa2 = East. */
443 sa1->v3 = sa2->v3; /* TR */
444 sa1->v4 = sa2->v4; /* BR */
445 screen_geom_edge_add(screen, sa1->v2, sa1->v3);
446 screen_geom_edge_add(screen, sa1->v1, sa1->v4);
447 }
448 else if (dir == SCREEN_DIR_S) { /* sa1 on top of sa2 = South. */
449 sa1->v1 = sa2->v1; /* BL */
450 sa1->v4 = sa2->v4; /* BR */
451 screen_geom_edge_add(screen, sa1->v1, sa1->v2);
452 screen_geom_edge_add(screen, sa1->v3, sa1->v4);
453 }
454
455 screen_delarea(C, screen, sa2);
457 /* Update preview thumbnail */
458 BKE_icon_changed(screen->id.icon_id);
459
460 return true;
461}
462
463/* Slice off and return new area. "Reverse" gives right/bottom, rather than left/top. */
465 bContext *C, bScreen *screen, ScrArea **area, int size, eScreenDir dir, bool reverse)
466{
467 const bool vertical = SCREEN_DIR_IS_VERTICAL(dir);
468 if (abs(size) < (vertical ? AREAJOINTOLERANCEX : AREAJOINTOLERANCEY)) {
469 return nullptr;
470 }
471
472 /* Measurement with ScrVerts because winx and winy might not be correct at this time. */
473 float fac = abs(size) / float(vertical ? ((*area)->v3->vec.x - (*area)->v1->vec.x) :
474 ((*area)->v3->vec.y - (*area)->v1->vec.y));
475 fac = (reverse == vertical) ? 1.0f - fac : fac;
476 ScrArea *newsa = area_split(
477 CTX_wm_window(C), screen, *area, vertical ? SCREEN_AXIS_V : SCREEN_AXIS_H, fac);
478
479 /* area_split always returns smallest of the two areas, so might have to swap. */
480 if (((fac > 0.5f) == vertical) != reverse) {
481 ScrArea *temp = *area;
482 *area = newsa;
483 newsa = temp;
484 }
485
486 return newsa;
487}
488
489/* Join any two neighboring areas. Might create new areas, kept if over min_remainder. */
491 ReportList *reports,
492 bScreen *screen,
493 ScrArea *sa1,
494 ScrArea *sa2,
495 bool close_all_remainders)
496{
497 const eScreenDir dir = area_getorientation(sa1, sa2);
498 if (dir == SCREEN_DIR_NONE) {
499 return false;
500 }
501
502 int offset1;
503 int offset2;
504 area_getoffsets(sa1, sa2, dir, &offset1, &offset2);
505
506 /* Split Left/Top into new area if overhanging. */
507 ScrArea *side1 = screen_area_trim(C, screen, (offset1 > 0) ? &sa2 : &sa1, offset1, dir, false);
508
509 /* Split Right/Bottom into new area if overhanging. */
510 ScrArea *side2 = screen_area_trim(C, screen, (offset2 > 0) ? &sa1 : &sa2, offset2, dir, true);
511
512 /* The two areas now line up, so join them. */
513 screen_area_join_aligned(C, reports, screen, sa1, sa2);
514
515 if (close_all_remainders || offset1 < 0 || offset2 > 0) {
516 /* Close both if trimming `sa1`. */
517 float inner[4] = {0.0f, 0.0f, 0.0f, 0.7f};
518 if (side1) {
519 rcti rect = {side1->v1->vec.x, side1->v3->vec.x, side1->v1->vec.y, side1->v3->vec.y};
520 /* Close side1 but not by joining with the area that we just split. */
521 if (screen_area_close(C, reports, screen, side1, sa1)) {
523 CTX_wm_window(C), CTX_wm_screen(C), &rect, inner, nullptr, AREA_CLOSE_FADEOUT);
524 if (sa1->spacetype == SPACE_OUTLINER) {
525 /* Outliner needs a full rebuild. #153395. */
527 }
528 }
529 }
530 if (side2) {
531 rcti rect = {side2->v1->vec.x, side2->v3->vec.x, side2->v1->vec.y, side2->v3->vec.y};
532 /* Close side2 but not by joining with the area that we just split. */
533 if (screen_area_close(C, reports, screen, side2, sa1)) {
535 CTX_wm_window(C), CTX_wm_screen(C), &rect, inner, nullptr, AREA_CLOSE_FADEOUT);
536 if (sa1->spacetype == SPACE_OUTLINER) {
537 /* Outliner needs a full rebuild. #153395. */
539 }
540 }
541 }
542 }
543 else {
544 /* Force full rebuild. #130732 */
545 ED_area_tag_redraw(side1);
546 ED_area_tag_redraw(side2);
547 }
548
549 if (sa1 != CTX_wm_area(C)) {
550 /* Active area has changed so active region could be invalid. It is
551 * safe to set null and let it be set later by mouse position. #131751. */
552 screen->active_region = nullptr;
553 }
554
555 BKE_icon_changed(screen->id.icon_id);
556 return true;
557}
558
559int screen_area_join(bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
560{
561 return screen_area_join_ex(C, reports, screen, sa1, sa2, false);
562}
563
565 bContext *C, ReportList *reports, bScreen *screen, ScrArea *area, ScrArea *not_area)
566{
567 if (area == nullptr) {
568 return false;
569 }
570
571 ScrArea *sa2 = nullptr;
572 float best_alignment = 0.0f;
573
574 for (ScrArea &neighbor : screen->areabase) {
575 if (ELEM(&neighbor, area, not_area)) {
576 continue;
577 }
578 const eScreenDir dir = area_getorientation(area, &neighbor);
579 /* Must at least partially share an edge and not be a global area. */
580 if ((dir != SCREEN_DIR_NONE) && (neighbor.global == nullptr)) {
581 /* Winx/Winy might not be updated yet, so get lengths from verts. */
582 const bool vertical = SCREEN_DIR_IS_VERTICAL(dir);
583 const int area_length = vertical ? (area->v3->vec.x - area->v1->vec.x) :
584 (area->v3->vec.y - area->v1->vec.y);
585 const int ar_length = vertical ? (neighbor.v3->vec.x - neighbor.v1->vec.x) :
586 (neighbor.v3->vec.y - neighbor.v1->vec.y);
587 /* Calculate the ratio of the lengths of the shared edges. */
588 float alignment = std::min(area_length, ar_length) / float(std::max(area_length, ar_length));
589 if (alignment > best_alignment) {
590 best_alignment = alignment;
591 sa2 = &neighbor;
592 }
593 }
594 }
595
596 /* Join from neighbor into this area to close it. */
597 return sa2 && screen_area_join_ex(C, reports, screen, sa2, area, true);
598}
599
600void screen_area_spacelink_add(const Scene *scene, ScrArea *area, eSpace_Type space_type)
601{
602 SpaceType *stype = BKE_spacetype_from_id(space_type);
603 SpaceLink *slink = stype->create(area, scene);
604
605 area->regionbase = slink->regionbase;
606
607 BLI_addhead(&area->spacedata, slink);
608 slink->regionbase.clear_no_delete();
609}
610
611/* ****************** EXPORTED API TO OTHER MODULES *************************** */
612
613/* screen sets cursor based on active region */
614static void region_cursor_set_ex(wmWindow *win, ScrArea *area, ARegion *region, bool swin_changed)
615{
616 BLI_assert(WM_window_get_active_screen(win)->active_region == region);
617 if (win->tag_cursor_refresh || swin_changed ||
618 (region->runtime->type && region->runtime->type->event_cursor))
619 {
620 win->tag_cursor_refresh = false;
621 ED_region_cursor_set(win, area, region);
622 }
623}
624
625static void region_cursor_set(wmWindow *win, bool swin_changed)
626{
628
629 /* Don't touch cursor if something else is controlling it, like button handling. See #51739. */
630 if (win->grabcursor) {
631 return;
632 }
633 ED_screen_areas_iter (win, screen, area) {
634 for (ARegion &region : area->regionbase) {
635 if (&region == screen->active_region) {
636 region_cursor_set_ex(win, area, &region, swin_changed);
637 return;
638 }
639 }
640 }
641}
642
644{
645 wmWindow *win = CTX_wm_window(C);
646 bScreen *screen = CTX_wm_screen(C);
647
648 /* generic notes */
649 switch (note->category) {
650 case NC_WM:
651 if (note->data == ND_FILEREAD) {
652 screen->do_draw = true;
653 }
654 break;
655 case NC_WINDOW:
658 }
659 screen->do_draw = true;
660 break;
661 case NC_SCREEN:
662 if (note->action == NA_EDITED) {
665 }
666 screen->do_draw = screen->do_refresh = true;
667 }
668 break;
669 case NC_SCENE:
670 if (note->data == ND_MODE) {
671 region_cursor_set(win, true);
672 }
673 break;
674 }
675}
676
677static bool region_poll(const bContext *C,
678 const bScreen *screen,
679 const ScrArea *area,
680 const ARegion *region)
681{
682 if (!region->runtime->type) {
684 return false;
685 }
686 if (!region->runtime->type->poll) {
687 /* Show region by default. */
688 return true;
689 }
690
691 RegionPollParams params = {nullptr};
692 params.screen = screen;
693 params.area = area;
694 params.region = region;
695 params.context = C;
696
697 return region->runtime->type->poll(&params);
698}
699
700bool area_regions_poll(bContext *C, const bScreen *screen, ScrArea *area)
701{
702 bScreen *prev_screen = CTX_wm_screen(C);
703 ScrArea *prev_area = CTX_wm_area(C);
704 ARegion *prev_region = CTX_wm_region(C);
705
706 CTX_wm_screen_set(C, const_cast<bScreen *>(screen));
707 CTX_wm_area_set(C, area);
708
709 bool any_changed = false;
710 for (ARegion &region : area->regionbase) {
711 const int old_region_flag = region.flag;
712
713 region.flag &= ~RGN_FLAG_POLL_FAILED;
714
715 CTX_wm_region_set(C, &region);
716 if (region_poll(C, screen, area, &region) == false) {
717 region.flag |= RGN_FLAG_POLL_FAILED;
718 }
719 else if (region.runtime->type && region.runtime->type->on_poll_success) {
720 region.runtime->type->on_poll_success(C, &region);
721 }
722
723 if (old_region_flag != region.flag) {
724 any_changed = true;
725
726 /* Enforce complete re-init. */
727 region.v2d.flag &= ~V2D_IS_INIT;
728
729 const bool is_hidden = region.flag & (RGN_FLAG_HIDDEN | RGN_FLAG_POLL_FAILED);
730 /* Don't re-init areas, caller is expected to handle that. In fact, this code might actually
731 * run as part of #ED_area_init(). */
732 const bool do_init = false;
733 ED_region_visibility_change_update_ex(C, area, &region, is_hidden, do_init);
734 }
735 }
736
737 CTX_wm_screen_set(C, prev_screen);
738 CTX_wm_area_set(C, prev_area);
739 CTX_wm_region_set(C, prev_region);
740
741 return any_changed;
742}
743
747static bool screen_regions_poll(bContext *C, wmWindow *win, const bScreen *screen)
748{
749 wmWindow *prev_win = CTX_wm_window(C);
750 ScrArea *prev_area = CTX_wm_area(C);
751 ARegion *prev_region = CTX_wm_region(C);
752
753 CTX_wm_window_set(C, win);
754
755 bool any_changed = false;
756 ED_screen_areas_iter (win, screen, area) {
757 if (area_regions_poll(C, screen, area)) {
758 any_changed = true;
759 }
760 }
761
762 CTX_wm_window_set(C, prev_win);
763 CTX_wm_area_set(C, prev_area);
764 CTX_wm_region_set(C, prev_region);
765
766 return any_changed;
767}
768
776{
778
779 /* Exception for background mode, we only need the screen context. */
780 if (!G.background) {
781 if (screen->do_refresh) {
782 ED_screen_areas_iter (win, screen, area) {
783 /* Ensure all area and region types are set before polling, it depends on it (see #130583).
784 */
786 }
787 }
788
789 /* Returns true if a change was done that requires refreshing. */
790 if (screen_regions_poll(C, win, screen)) {
791 screen->do_refresh = true;
792 }
793
794 if (!screen->do_refresh) {
795 return;
796 }
797
798 /* Called even when creating the ghost window fails in #WM_window_open. */
799 if (win->runtime->ghostwin) {
800 /* Header size depends on DPI, let's verify. */
802 }
803
805
806 screen_geom_vertices_scale(win, screen);
807
808 ED_screen_areas_iter (win, screen, area) {
809 /* Set space-type and region callbacks, calls init() */
810 /* Sets sub-windows for regions, adds handlers. */
811 ED_area_init(C, win, area);
812 }
813
814 /* wake up animtimer */
815 if (screen->animtimer) {
816 WM_event_timer_sleep(wm, win, screen->animtimer, false);
817 }
818 }
819
820 if (G.debug & G_DEBUG_EVENTS) {
821 printf("%s: set screen\n", __func__);
822 }
823 screen->do_refresh = false;
824 /* Prevent multi-window errors. */
825 screen->winid = win->winid;
826
827 screen->context = reinterpret_cast<void *>(ed_screen_context);
828}
829
831{
833 /* Enforce full refresh. */
834 screen->do_refresh = true;
836}
837
839{
840 wmWindow *prev_ctx_win = CTX_wm_window(C);
841 BLI_SCOPED_DEFER([&]() { CTX_wm_window_set(C, prev_ctx_win); });
842
843 for (wmWindow &win : wm->windows) {
844 /* Region polls may need window/screen context. */
845 CTX_wm_window_set(C, &win);
846
847 if (BKE_workspace_active_get(win.workspace_hook) == nullptr) {
849 }
850
851 ED_screen_refresh(C, wm, &win);
852 if (win.runtime->eventstate) {
853 ED_screen_set_active_region(nullptr, &win, win.runtime->eventstate->xy);
854 }
855 }
856
857 if (U.uiflag & USER_HEADER_FROM_PREF) {
858 for (bScreen &screen : bmain->screens) {
860 }
861 }
862}
863
868
870{
871 ED_region_exit(C, region);
872 BKE_area_region_free(area->type, region);
873 BLI_freelinkN(&area->regionbase, region);
874}
875
876/* *********** exit calls are for closing running stuff ******** */
877
879{
881 wmWindow *win = CTX_wm_window(C);
882 ARegion *prevar = CTX_wm_region(C);
883
884 if (region->runtime->type && region->runtime->type->exit) {
885 region->runtime->type->exit(wm, region);
886 }
887
888 CTX_wm_region_set(C, region);
889
891 WM_event_modal_handler_region_replace(win, region, nullptr);
892
893 /* Stop panel animation in this region if there are any. */
894 for (Panel &panel : region->panels) {
896 }
897
898 if (region->regiontype == RGN_TYPE_TEMPORARY) {
899 /* This may be a popup region such as a popover or splash screen.
900 * In the case of popups which spawn popups it's possible for
901 * the parent popup to be freed *before* a popup which created it.
902 * The child may have a reference to the freed parent unless cleared here, see: #122132.
903 *
904 * Having parent popups freed before the popups they spawn could be investigated although
905 * they're not technically nested as they're both stored in #Screen::regionbase. */
906 WM_event_ui_handler_region_popup_replace(win, region, nullptr);
907 }
908
909 WM_draw_region_free(region);
910 /* The region is not in a state that it can be visible in anymore. Reinitializing is needed. */
911 region->runtime->visible = false;
912
913 MEM_SAFE_DELETE(region->runtime->headerstr);
914
915 if (region->runtime->regiontimer) {
917 region->runtime->regiontimer = nullptr;
918 }
919
920 WM_msgbus_clear_by_owner(wm->runtime->message_bus, region);
921
922 CTX_wm_region_set(C, prevar);
923}
924
926{
928 wmWindow *win = CTX_wm_window(C);
929 ScrArea *prevsa = CTX_wm_area(C);
930
931 if (area->type && area->type->exit) {
932 area->type->exit(wm, area);
933 }
934
935 CTX_wm_area_set(C, area);
936
937 for (ARegion &region : area->regionbase) {
938 ED_region_exit(C, &region);
939 }
940
942 WM_event_modal_handler_area_replace(win, area, nullptr);
943
944 CTX_wm_area_set(C, prevsa);
945}
946
947void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
948{
950 wmWindow *prevwin = CTX_wm_window(C);
951
952 CTX_wm_window_set(C, window);
953
954 if (screen->animtimer) {
955 screen_stop_playback(CTX_data_main(C), wm, window, screen);
956 }
957 screen->animtimer = nullptr;
958 screen->scrubbing = false;
959
960 screen->active_region = nullptr;
961
962 for (ARegion &region : screen->regionbase) {
963 ED_region_exit(C, &region);
964 }
965 for (ScrArea &area : screen->areabase) {
966 ED_area_exit(C, &area);
967 }
968 /* Don't use ED_screen_areas_iter here, it skips hidden areas. */
969 for (ScrArea &area : window->global_areas.areabase) {
970 ED_area_exit(C, &area);
971 }
972
973 /* mark it available for use for other windows */
974 screen->winid = 0;
975
976 if (prevwin && !WM_window_is_temp_screen(prevwin)) {
977 /* use previous window if possible */
978 CTX_wm_window_set(C, prevwin);
979 }
980 else {
981 /* none otherwise */
982 CTX_wm_window_set(C, nullptr);
983 }
984}
985
987{
988 if (area->type && area->type->space_name_get) {
989 return area->type->space_name_get(area);
990 }
991
994 return item.name;
995}
996
997int ED_area_icon(const ScrArea *area)
998{
999 if (area->type && area->type->space_icon_get) {
1000 return area->type->space_icon_get(area);
1001 }
1002
1005 return item.icon;
1006}
1007
1008/* *********************************** */
1009
1010/* case when on area-edge or in azones, or outside window */
1011static void screen_cursor_set(wmWindow *win, const int xy[2])
1012{
1013 const bScreen *screen = WM_window_get_active_screen(win);
1014 AZone *az = nullptr;
1015 ScrArea *area = nullptr;
1016
1017 for (ScrArea &area_iter : screen->areabase) {
1018 az = ED_area_actionzone_find_xy(&area_iter, xy);
1019 /* We used to exclude AZONE_REGION_SCROLL as those used
1020 * to overlap screen edges, but they no longer do so. */
1021 if (az) {
1022 area = &area_iter;
1023 break;
1024 }
1025 }
1026
1027 if (area) {
1028 if (az->type == AZONE_AREA) {
1030 }
1031 else if (az->type == AZONE_REGION_SCROLL) {
1033 }
1034 else if (az->type == AZONE_REGION_QUAD) {
1036 }
1037 else if (az->type == AZONE_REGION) {
1040 }
1041 else {
1043 }
1044 }
1045 }
1046 else {
1047 ScrEdge *actedge = screen_geom_find_active_scredge(win, screen, xy[0], xy[1]);
1048
1049 if (actedge) {
1050 if (screen_geom_edge_is_horizontal(actedge)) {
1051 rcti screen_rect;
1052 WM_window_screen_rect_calc(win, &screen_rect);
1053 /* Check if edge is at top of screen (with small threshold that scales with interface). */
1054 if (actedge->v1->vec.y >= screen_rect.ymax - int(2.0f * UI_SCALE_FAC)) {
1056 }
1057 else {
1059 }
1060 }
1061 else {
1063 }
1064 }
1065 else {
1067 }
1068 }
1069}
1070
1071void ED_screen_set_active_region(bContext *C, wmWindow *win, const int xy[2])
1072{
1073 bScreen *screen = WM_window_get_active_screen(win);
1074 if (screen == nullptr) {
1075 return;
1076 }
1077
1078 ScrArea *area = nullptr;
1079 ARegion *region_prev = screen->active_region;
1080
1081 ED_screen_areas_iter (win, screen, area_iter) {
1082 if (xy[0] > (area_iter->totrct.xmin + BORDERPADDING) &&
1083 xy[0] < (area_iter->totrct.xmax - BORDERPADDING))
1084 {
1085 if (xy[1] > (area_iter->totrct.ymin + BORDERPADDING) &&
1086 xy[1] < (area_iter->totrct.ymax - BORDERPADDING))
1087 {
1088 if (ED_area_azones_update(area_iter, xy) == nullptr) {
1089 area = area_iter;
1090 break;
1091 }
1092 }
1093 }
1094 }
1095 if (area) {
1096 /* Make overlap active when mouse over. */
1097 for (ARegion &region : area->regionbase) {
1098 if (ED_region_contains_xy(&region, xy)) {
1099 screen->active_region = &region;
1100 break;
1101 }
1102 }
1103 }
1104 else {
1105 screen->active_region = nullptr;
1106 }
1107
1108 if (region_prev != screen->active_region || !screen->active_region) {
1110 }
1111
1112 /* Check for redraw headers. */
1113 if (region_prev != screen->active_region) {
1114
1115 ED_screen_areas_iter (win, screen, area_iter) {
1116 bool do_draw = false;
1117
1118 for (ARegion &region : area_iter->regionbase) {
1119 /* Call old area's deactivate if assigned. */
1120 if (&region == region_prev && area_iter->type && area_iter->type->deactivate) {
1121 area_iter->type->deactivate(area_iter);
1122 }
1123
1124 if (&region == region_prev && &region != screen->active_region) {
1125 wmGizmoMap *gzmap = region_prev->runtime->gizmo_map;
1126 if (gzmap) {
1127 if (WM_gizmo_highlight_set(gzmap, nullptr)) {
1129 }
1130 }
1131 }
1132
1133 if (ELEM(&region, region_prev, screen->active_region)) {
1134 do_draw = true;
1135 }
1136 }
1137
1138 if (do_draw) {
1139 for (ARegion &region : area_iter->regionbase) {
1142 }
1143 }
1144 }
1145 }
1146
1147 /* Ensure test-motion values are never shared between regions. */
1148 const int mval[2] = {-1, -1};
1149 const bool use_cycle = !WM_cursor_test_motion_and_update(mval);
1150 UNUSED_VARS(use_cycle);
1151 }
1152
1153 /* Cursors, for time being set always on edges,
1154 * otherwise the active region doesn't switch. */
1155 if (screen->active_region == nullptr) {
1156 screen_cursor_set(win, xy);
1157 }
1158 else {
1159 /* Notifier invokes freeing the buttons... causing a bit too much redraws. */
1160 region_cursor_set_ex(win, area, screen->active_region, region_prev != screen->active_region);
1161
1162 if (region_prev != screen->active_region) {
1163 /* This used to be a notifier, but needs to be done immediate
1164 * because it can undo setting the right button as active due
1165 * to delayed notifier handling. */
1166 if (C) {
1168 }
1169 }
1170 }
1171
1172#ifdef WITH_INPUT_IME
1173 if (region_prev != screen->active_region) {
1174 WM_window_IME_region_refresh(win, area, screen->active_region);
1175 }
1176#endif
1177}
1178
1180{
1181 wmWindow *win = CTX_wm_window(C);
1182 bScreen *screen = CTX_wm_screen(C);
1183 ScrArea *area = CTX_wm_area(C);
1184
1185 if (win && screen && area) {
1187
1188 if (az && az->type == AZONE_REGION) {
1189 return 1;
1190 }
1191
1192 for (ARegion &region : area->regionbase) {
1193 if (&region == screen->active_region) {
1194 return 1;
1195 }
1196 }
1197 }
1198 return 0;
1199}
1200
1206 const rcti *rect,
1207 eSpace_Type space_type)
1208{
1209 ScrVert *bottom_left = screen_geom_vertex_add_ex(area_map, rect->xmin, rect->ymin);
1210 ScrVert *top_left = screen_geom_vertex_add_ex(area_map, rect->xmin, rect->ymax);
1211 ScrVert *top_right = screen_geom_vertex_add_ex(area_map, rect->xmax, rect->ymax);
1212 ScrVert *bottom_right = screen_geom_vertex_add_ex(area_map, rect->xmax, rect->ymin);
1213
1214 screen_geom_edge_add_ex(area_map, bottom_left, top_left);
1215 screen_geom_edge_add_ex(area_map, top_left, top_right);
1216 screen_geom_edge_add_ex(area_map, top_right, bottom_right);
1217 screen_geom_edge_add_ex(area_map, bottom_right, bottom_left);
1218
1219 return screen_addarea_ex(area_map, bottom_left, top_left, top_right, bottom_right, space_type);
1220}
1221
1222static void screen_area_set_geometry_rect(ScrArea *area, const rcti *rect)
1223{
1224 area->v1->vec.x = rect->xmin;
1225 area->v1->vec.y = rect->ymin;
1226 area->v2->vec.x = rect->xmin;
1227 area->v2->vec.y = rect->ymax;
1228 area->v3->vec.x = rect->xmax;
1229 area->v3->vec.y = rect->ymax;
1230 area->v4->vec.x = rect->xmax;
1231 area->v4->vec.y = rect->ymin;
1232}
1233
1235 bScreen *screen,
1236 const eSpace_Type space_type,
1237 GlobalAreaAlign align,
1238 const rcti *rect,
1239 const short height_cur,
1240 const short height_min,
1241 const short height_max)
1242{
1243 /* Full-screens shouldn't have global areas. Don't touch them. */
1244 if (screen->state == SCREENFULL) {
1245 return;
1246 }
1247
1248 ScrArea *area = nullptr;
1249 for (ScrArea &area_iter : win->global_areas.areabase) {
1250 if (area_iter.spacetype == space_type) {
1251 area = &area_iter;
1252 break;
1253 }
1254 }
1255
1256 if (area) {
1258 }
1259 else {
1260 area = screen_area_create_with_geometry(&win->global_areas, rect, space_type);
1262
1263 /* Data specific to global areas. */
1264 area->global = MEM_new<ScrGlobalAreaData>(__func__);
1265 area->global->size_max = height_max;
1266 area->global->size_min = height_min;
1267 area->global->align = align;
1268 }
1269
1270 if (area->global->cur_fixed_height != height_cur) {
1271 /* Refresh layout if size changes. */
1272 area->global->cur_fixed_height = height_cur;
1273 screen->do_refresh = true;
1274 }
1275}
1276
1278{
1279 return int(ceilf(ED_area_headersize() / UI_SCALE_FAC));
1280}
1281
1283{
1284 const short size = screen_global_header_size();
1285 rcti rect;
1286
1287 /* Use content rect to account for CSD, converted to inclusive bounds for area geometry. */
1288 WM_window_rect_calc(win, &rect);
1289 rect.xmax -= 1;
1290 rect.ymin = (rect.ymax - 1) - size;
1291 rect.ymax -= 1;
1292
1294 win, screen, SPACE_TOPBAR, GLOBAL_AREA_ALIGN_TOP, &rect, size, size, size);
1295}
1296
1298{
1299 const short size_min = 1;
1300 const short size_max = 0.85f * screen_global_header_size();
1301 const short size = (screen->flag & SCREEN_COLLAPSE_STATUSBAR) ? size_min : size_max;
1302 rcti rect;
1303
1304 /* Use content rect to account for CSD, converted to inclusive bounds for area geometry. */
1305 WM_window_rect_calc(win, &rect);
1306 rect.xmax -= 1;
1307 rect.ymax = rect.ymin + size_max;
1308
1310 win, screen, SPACE_STATUSBAR, GLOBAL_AREA_ALIGN_BOTTOM, &rect, size, size_min, size_max);
1311}
1312
1314{
1315 /* Update screen flags from height in window, this is weak and perhaps
1316 * global areas should just become part of the screen instead. */
1318
1320
1321 for (ScrArea &area : win->global_areas.areabase) {
1322 if (area.global->cur_fixed_height == area.global->size_min) {
1323 if (area.spacetype == SPACE_STATUSBAR) {
1325 }
1326 }
1327 }
1328}
1329
1331{
1332 /* Don't create global area for child and temporary windows. */
1334 if (!WM_window_is_main_top_level(win)) {
1335 if (win->global_areas.areabase.first_) {
1336 screen->do_refresh = true;
1338 }
1339 return;
1340 }
1341
1344}
1345
1346/* -------------------------------------------------------------------- */
1347/* Screen changing */
1348
1350 bScreen *screen_old, bScreen *screen_new, Main *bmain, bContext *C, wmWindow *win)
1351{
1352 UNUSED_VARS_NDEBUG(bmain);
1353 BLI_assert(BLI_findindex(&bmain->screens, screen_new) != -1);
1354
1355 if (screen_old != screen_new) {
1356 wmTimer *wt = screen_old->animtimer;
1357
1358 /* Remove popup handlers (menus), while unlikely, it's possible an "error"
1359 * popup is displayed when switching screens.
1360 * Ideally popups from reported errors would remain so the error isn't hidden from the user.
1361 * On the other hand this is a rare occurrence, script developers will often show errors
1362 * in a console too, so it's not such a priority to relocate these to the new screen.
1363 * See: #144958. */
1365
1366 /* remove handlers referencing areas in old screen */
1367 for (ScrArea &area : screen_old->areabase) {
1369 }
1370
1371 /* we put timer to sleep, so screen_exit has to think there's no timer */
1372 screen_old->animtimer = nullptr;
1373 if (wt) {
1374 WM_event_timer_sleep(CTX_wm_manager(C), win, wt, true);
1375 }
1376 ED_screen_exit(C, win, screen_old);
1377
1378 /* Same scene, "transfer" playback to new screen. */
1379 if (wt) {
1380 screen_new->animtimer = wt;
1381 }
1382 }
1383}
1384
1386{
1387 Scene *scene = WM_window_get_active_scene(win);
1389 WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, screen);
1390
1391 CTX_wm_window_set(C, win); /* stores C->wm.screen... hrmf */
1392
1394
1395 BKE_screen_view3d_scene_sync(screen, scene); /* sync new screen with scene data */
1398
1399 /* Makes button highlights work. */
1401}
1402
1404{
1405 Main *bmain = CTX_data_main(C);
1406 wmWindow *win = CTX_wm_window(C);
1408 WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, screen);
1409 bScreen *screen_old = CTX_wm_screen(C);
1410
1411 /* Get the actual layout/screen to be activated (guaranteed to be unused, even if that means
1412 * having to duplicate an existing one). */
1414 bmain, workspace, layout, layout, win);
1415 bScreen *screen_new = BKE_workspace_layout_screen_get(layout_new);
1416
1417 screen_change_prepare(screen_old, screen_new, bmain, C, win);
1418
1419 if (screen_old != screen_new) {
1420 WM_window_set_active_screen(win, workspace, screen_new);
1421 screen_change_update(C, win, screen_new);
1422
1423 return true;
1424 }
1425
1426 return false;
1427}
1428
1430 const Main &bmain, Scene *scene, ViewLayer *view_layer, ScrArea *area, View3D *v3d)
1431{
1432 /* Fix any cameras that are used in the 3d view but not in the scene. */
1433 BKE_screen_view3d_sync(v3d, scene);
1434
1435 BKE_view_layer_synced_ensure(bmain, scene, view_layer);
1436 if (!v3d->camera || !BKE_view_layer_base_find(view_layer, v3d->camera)) {
1437 v3d->camera = BKE_view_layer_camera_find(bmain, scene, view_layer);
1438 }
1439 ListBaseT<ARegion> *regionbase;
1440
1441 /* regionbase is in different place depending if space is active. */
1442 if (v3d == area->spacedata.first_) {
1443 regionbase = &area->regionbase;
1444 }
1445 else {
1446 regionbase = &v3d->regionbase;
1447 }
1448
1449 for (ARegion &region : *regionbase) {
1450 if (region.regiontype != RGN_TYPE_WINDOW) {
1451 continue;
1452 }
1453 RegionView3D *rv3d = static_cast<RegionView3D *>(region.regiondata);
1454 /* Keep the information about RV3D_CAMOB even when no camera can be found.
1455 * This prevents jumping off the camera view while scrubbing through the
1456 * Sequencer with some Scene strips without scene. */
1457 if (!v3d->camera) {
1458 if (rv3d->persp == RV3D_CAMOB) {
1459 rv3d->persp = RV3D_PERSP;
1460 rv3d->rflag |= RV3D_WAS_CAMOB;
1461 }
1462 }
1463 else if ((rv3d->rflag & RV3D_WAS_CAMOB) != 0) {
1464 rv3d->persp = RV3D_CAMOB;
1465 rv3d->rflag &= ~RV3D_WAS_CAMOB;
1466 }
1467 }
1468}
1469
1471 wmWindow *win,
1472 Scene *scene,
1473 const bool refresh_toolsystem)
1474{
1475#if 0
1476 ViewLayer *view_layer_old = WM_window_get_active_view_layer(win);
1477#endif
1478
1479 /* Switch scene. */
1480 win->scene = scene;
1481 if (CTX_wm_window(C) == win) {
1482 CTX_data_scene_set(C, scene);
1483 }
1484
1485 /* Ensure the view layer name is updated. */
1487 ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1488
1489#if 0
1490 /* Mode Syncing. */
1491 if (view_layer_old) {
1492 WorkSpace *workspace = CTX_wm_workspace(C);
1493 Object *obact_new = BKE_view_layer_active_object_get(view_layer);
1494 UNUSED_VARS(obact_new);
1495 eObjectMode object_mode_old = workspace->object_mode;
1496 Object *obact_old = BKE_view_layer_active_object_get(view_layer_old);
1497 UNUSED_VARS(obact_old, object_mode_old);
1498 }
1499#endif
1500
1501 /* Update 3D view cameras. */
1502 const Main *bmain = CTX_data_main(C);
1503 const bScreen *screen = WM_window_get_active_screen(win);
1504 for (ScrArea &area : screen->areabase) {
1505 for (SpaceLink &sl : area.spacedata) {
1506 if (sl.spacetype == SPACE_VIEW3D) {
1507 View3D *v3d = reinterpret_cast<View3D *>(&sl);
1508 screen_set_3dview_camera(*bmain, scene, view_layer, &area, v3d);
1509 }
1510 }
1511 }
1512
1513 if (refresh_toolsystem) {
1515 }
1516}
1517
1519{
1520 bScreen *newscreen = nullptr;
1521 ScrArea *newsa = nullptr;
1522 SpaceLink *newsl;
1523
1524 if (!area || area->full == nullptr) {
1526 newsa = newscreen->areabase.first();
1527 BLI_assert(newsa->spacetype == SPACE_EMPTY);
1528 }
1529
1530 if (!newsa) {
1531 newsa = area;
1532 }
1533
1534 BLI_assert(newsa);
1535 newsl = newsa->spacedata.first();
1536
1537 /* Tag the active space before changing, so we can identify it when user wants to go back. */
1538 if (newsl && (newsl->link_flag & SPACE_FLAG_TYPE_TEMPORARY) == 0) {
1540 }
1541
1542 ED_area_newspace(C, newsa, type, (newsl && newsl->link_flag & SPACE_FLAG_TYPE_TEMPORARY));
1543
1544 if (newscreen) {
1545 ED_screen_change(C, newscreen);
1546 }
1547
1548 return newsa;
1549}
1550
1552{
1553 BLI_assert(area->full);
1554
1555 if (area->flag & AREA_FLAG_STACKED_FULLSCREEN) {
1556 /* Stacked full-screen -> only go back to previous area and don't toggle out of full-screen. */
1557 ED_area_prevspace(C, area);
1558 }
1559 else {
1561 }
1562}
1563
1565{
1566 SpaceLink *sl = area->spacedata.first_as<SpaceLink>();
1567
1568 /* In case nether functions below run. */
1569 ED_area_tag_redraw(area);
1570
1572 ED_area_prevspace(C, area);
1573 }
1574
1575 if (area->full) {
1577 }
1578}
1579
1581{
1582 wmWindow *win = CTX_wm_window(C);
1583 SpaceLink *sl = area->spacedata.first_as<SpaceLink>();
1584 bScreen *screen = CTX_wm_screen(C);
1585 eScreen_State state = (screen ? screen->state : SCREENMAXIMIZED);
1586
1587 /* If full-screen area has a temporary space (such as a file browser or full-screen render
1588 * overlaid on top of an existing setup) then return to the previous space. */
1589
1590 if (sl->next) {
1593 }
1594 else {
1595 ED_screen_state_toggle(C, win, area, state);
1596 }
1597 /* WARNING: 'area' may be freed */
1598 }
1599 /* otherwise just tile the area again */
1600 else {
1601 ED_screen_state_toggle(C, win, area, state);
1602 }
1603}
1604
1615 wmWindow *win,
1616 ScrArea *toggle_area,
1618{
1619 Main *bmain = CTX_data_main(C);
1620 WorkSpace *workspace = WM_window_get_active_workspace(win);
1621
1622 /* change from SCREENNORMAL to new state */
1623 WorkSpaceLayout *layout_new;
1624 ScrArea *newa;
1625 char newname[MAX_ID_NAME - 2];
1626
1628
1629 bScreen *oldscreen = WM_window_get_active_screen(win);
1630
1631 oldscreen->state = state;
1632 SNPRINTF_UTF8(newname, "%s-%s", oldscreen->id.name + 2, "nonnormal");
1633
1634 layout_new = ED_workspace_layout_add(bmain, workspace, win, newname);
1635
1636 bScreen *screen = BKE_workspace_layout_screen_get(layout_new);
1637 screen->state = state;
1638 screen->redraws_flag = oldscreen->redraws_flag;
1639 screen->temp = oldscreen->temp;
1640 screen->flag = oldscreen->flag;
1641
1642 /* timer */
1643 screen->animtimer = oldscreen->animtimer;
1644 oldscreen->animtimer = nullptr;
1645
1646 newa = screen->areabase.first();
1647
1648 /* swap area */
1649 if (toggle_area) {
1650 ED_area_data_swap(newa, toggle_area);
1651 newa->flag = toggle_area->flag; /* mostly for AREA_FLAG_WASFULLSCREEN */
1652 newa->quadview_ratio[0] = toggle_area->quadview_ratio[0];
1653 newa->quadview_ratio[1] = toggle_area->quadview_ratio[1];
1654 }
1655
1656 if (state == SCREENFULL) {
1657 /* temporarily hide global areas */
1658 for (ScrArea &glob_area : win->global_areas.areabase) {
1659 glob_area.global->flag |= GLOBAL_AREA_IS_HIDDEN;
1660 }
1661 /* temporarily hide the side panels/header */
1662 for (ARegion &region : newa->regionbase) {
1663 region.flagfullscreen = region.flag;
1664
1665 if (ELEM(region.regiontype,
1674 {
1675 region.flag |= RGN_FLAG_HIDDEN;
1676 }
1677 }
1678
1679 /* Temporarily hide gizmos and overlays. */
1681 if (newa->spacetype == SPACE_VIEW3D) {
1682 View3D *v3d = newa->spacedata.first_as<View3D>();
1683 if (v3d && !(v3d->gizmo_flag & V3D_GIZMO_HIDE_NAVIGATE)) {
1686 }
1687 if (v3d && !(v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT)) {
1690 }
1691 if (v3d && (v3d->overlay.flag & V3D_OVERLAY_STATS)) {
1694 }
1695 }
1696 else if (newa->spacetype == SPACE_CLIP) {
1697 SpaceClip *sc = newa->spacedata.first_as<SpaceClip>();
1698 if (sc && !(sc->gizmo_flag & SCLIP_GIZMO_HIDE_NAVIGATE)) {
1701 }
1702 }
1703 else if (newa->spacetype == SPACE_SEQ) {
1704 SpaceSeq *sseq = newa->spacedata.first_as<SpaceSeq>();
1705 if (sseq && !(sseq->gizmo_flag & SEQ_GIZMO_HIDE_NAVIGATE)) {
1708 }
1709 }
1710 else if (newa->spacetype == SPACE_IMAGE) {
1711 SpaceImage *sima = newa->spacedata.first_as<SpaceImage>();
1712 if (sima && !(sima->gizmo_flag & SI_GIZMO_HIDE_NAVIGATE)) {
1715 }
1716 }
1717 }
1718
1719 if (toggle_area) {
1720 toggle_area->full = oldscreen;
1721 }
1722 newa->full = oldscreen;
1723
1724 ED_area_tag_refresh(newa);
1725
1726 return screen;
1727}
1728
1733
1735 wmWindow *win,
1736 ScrArea *area,
1737 const eScreen_State state)
1738{
1740 WorkSpace *workspace = WM_window_get_active_workspace(win);
1741
1742 if (area) {
1743 /* ensure we don't have a button active anymore, can crash when
1744 * switching screens with tooltip open because region and tooltip
1745 * are no longer in the same screen */
1746 for (ARegion &region : area->regionbase) {
1747 ui::blocklist_free(C, &region);
1748 if (region.runtime->regiontimer) {
1749 WM_event_timer_remove(wm, nullptr, region.runtime->regiontimer);
1750 region.runtime->regiontimer = nullptr;
1751 }
1752 }
1753
1754 /* prevent hanging status prints */
1755 ED_area_status_text(area, nullptr);
1756 ED_workspace_status_text(C, nullptr);
1757 }
1758 bScreen *screen;
1759 if (area && area->full) {
1761 /* restoring back to SCREENNORMAL */
1762 screen = area->full; /* the old screen to restore */
1763 bScreen *oldscreen = WM_window_get_active_screen(win); /* the one disappearing */
1764
1765 BLI_assert(BKE_workspace_layout_screen_get(layout_old) != screen);
1767
1768 screen->state = SCREENNORMAL;
1769 screen->flag = oldscreen->flag;
1770 screen->fullscreen_flag = oldscreen->fullscreen_flag;
1771
1772 /* Find old area we may have swapped dummy space data to. It's swapped back here. */
1773 ScrArea *fullsa = nullptr;
1774 for (ScrArea &old : screen->areabase) {
1775 /* area to restore from is always first */
1776 if (old.full && !fullsa) {
1777 fullsa = &old;
1778 }
1779
1780 /* clear full screen state */
1781 old.full = nullptr;
1782 }
1783
1784 area->full = nullptr;
1785
1786 if (state == SCREENFULL) {
1787 /* unhide global areas */
1788 for (ScrArea &glob_area : win->global_areas.areabase) {
1789 glob_area.global->flag &= ~GLOBAL_AREA_IS_HIDDEN;
1790 }
1791 /* restore the old side panels/header visibility */
1792 for (ARegion &region : area->regionbase) {
1793 region.flag = eRegion_Flag(region.flagfullscreen);
1794 }
1795 /* Restore gizmos and overlays to their prior states. */
1796 if (area->spacetype == SPACE_VIEW3D) {
1797 View3D *v3d = area->spacedata.first_as<View3D>();
1798 if (v3d) {
1808 }
1809 }
1810 else if (area->spacetype == SPACE_CLIP) {
1811 SpaceClip *sc = area->spacedata.first_as<SpaceClip>();
1812 if (sc) {
1816 }
1817 }
1818 else if (area->spacetype == SPACE_SEQ) {
1819 SpaceSeq *sseq = area->spacedata.first_as<SpaceSeq>();
1820 if (sseq) {
1824 }
1825 }
1826 else if (area->spacetype == SPACE_IMAGE) {
1827 SpaceImage *sima = area->spacedata.first_as<SpaceImage>();
1828 if (sima) {
1832 }
1833 }
1834 }
1835
1836 if (fullsa) {
1837 ED_area_data_swap(fullsa, area);
1838 ED_area_tag_refresh(fullsa);
1839 fullsa->quadview_ratio[0] = area->quadview_ratio[0];
1840 fullsa->quadview_ratio[1] = area->quadview_ratio[1];
1841 }
1842
1843 /* animtimer back */
1844 screen->animtimer = oldscreen->animtimer;
1845 oldscreen->animtimer = nullptr;
1846
1847 ED_screen_change(C, screen);
1848
1849 BKE_workspace_layout_remove(CTX_data_main(C), workspace, layout_old);
1850
1851 /* After we've restored back to SCREENNORMAL, we have to wait with
1852 * screen handling as it uses the area coords which aren't updated yet.
1853 * Without doing so, the screen handling gets wrong area coords,
1854 * which in worst case can lead to crashes (see #43139) */
1855 screen->skip_handling = true;
1856 }
1857 else {
1858 ScrArea *toggle_area = area;
1859
1860 /* use random area when we have no active one, e.g. when the
1861 * mouse is outside of the window and we open a file browser */
1862 if (!toggle_area || toggle_area->global) {
1863 bScreen *oldscreen = WM_window_get_active_screen(win);
1864 toggle_area = oldscreen->areabase.first();
1865 }
1866
1867 screen = screen_state_to_nonnormal(C, win, toggle_area, state);
1868
1869 ED_screen_change(C, screen);
1870 }
1871
1872 BLI_assert(CTX_wm_screen(C) == screen);
1873 BLI_assert(CTX_wm_area(C) == nullptr); /* May have been freed. */
1874
1875 /* Setting the area is only needed for Python scripts that call
1876 * operators in succession before returning to the main event loop.
1877 * Without this, scripts can't run any operators that require
1878 * an area after toggling full-screen for example (see: #89526).
1879 * NOTE: an old comment stated this was "bad code",
1880 * however it doesn't cause problems so leave as-is. */
1881 CTX_wm_area_set(C, screen->areabase.first());
1882
1883 return screen->areabase.first();
1884}
1885
1887 bContext *C, const char *title, eSpace_Type space_type, int display_type, bool dialog)
1888{
1889 switch (display_type) {
1891 if (WM_window_open_temp(C, title, space_type, dialog)) {
1892 return CTX_wm_area(C);
1893 }
1894 break;
1896 bScreen *ctx_screen = CTX_wm_screen(C);
1897
1898 if (ctx_screen->state == SCREENMAXIMIZED) {
1899 /* Find the maximized area, check if it has the same type as the one we want to create. */
1900 for (ScrArea &screen_area : ctx_screen->areabase) {
1901 if (screen_area.full && screen_area.spacetype == space_type) {
1902 /* Return the existing area instead of recreating an area on top, which would make the
1903 * "Back to Previous" button seem ineffective. */
1904 return &screen_area;
1905 }
1906 }
1907 }
1908
1909 ScrArea *ctx_area = CTX_wm_area(C);
1910
1911 /* The current area is already fullscreen, stack the new area on top of it. */
1912 if (ctx_area != nullptr && ctx_area->full) {
1913 ScrArea *area = ctx_area;
1914 ED_area_newspace(C, ctx_area, space_type, true);
1916 (area->spacedata.first())->link_flag |= SPACE_FLAG_TYPE_TEMPORARY;
1917 return area;
1918 }
1919
1920 /* Create a new fullscreen area. */
1921 ScrArea *area = ED_screen_full_newspace(C, ctx_area, int(space_type));
1922 (area->spacedata.first())->link_flag |= SPACE_FLAG_TYPE_TEMPORARY;
1923 return area;
1924 }
1925 }
1926
1927 return nullptr;
1928}
1929
1932 FunctionRef<bool(const bScreen &screen)> should_stop_fn)
1933{
1934 /* Cannot use ED_window_animation_playing_no_scrub() here, because that only returns the window,
1935 * and we need the screen too. */
1936 for (wmWindow &win : wm->windows) {
1937 bScreen *screen = WM_window_get_active_screen(&win);
1938 if (!screen || !screen->animtimer) {
1939 continue;
1940 }
1941 if (!should_stop_fn(*screen)) {
1942 continue;
1943 }
1944
1945 screen_stop_playback(bmain, wm, &win, screen);
1946 }
1947}
1948
1950{
1951 /* `ED_screen_animation_playing` isn't used, as it also checks for screens with
1952 * scrubbing enabled*/
1954 if (!stopscreen) {
1955 return;
1956 }
1957 WM_event_timer_remove(wm, win, stopscreen->animtimer);
1958 stopscreen->animtimer = nullptr;
1959}
1960
1962 bContext *C, Scene *scene, ViewLayer *view_layer, int redraws, int sync, int enable)
1963{
1964 bScreen *screen = CTX_wm_screen(C);
1966 wmWindow *win = CTX_wm_window(C);
1967
1969
1970 if (enable) {
1971 ScreenAnimData *sad = MEM_new_zeroed<ScreenAnimData>("ScreenAnimData");
1972
1973 screen->animtimer = WM_event_timer_add(wm, win, TIMER0, (1.0 / scene->frames_per_second()));
1974
1975 sad->region = CTX_wm_region(C);
1976 sad->scene = scene;
1977 sad->view_layer = view_layer;
1978
1980
1981 sad->sfra = scene->r.cfra;
1982 /* Make sure that were are inside the scene or preview frame range. */
1983 BKE_scene_frame_clamp_for_playback(scene, enable > 0);
1984 if (scene->r.cfra != sad->sfra) {
1985 sad->flag |= ANIMPLAY_FLAG_JUMPED;
1986 }
1987
1988 if (sad->flag & ANIMPLAY_FLAG_JUMPED) {
1990 }
1991
1992 sad->redraws = redraws;
1993 sad->flag |= (enable < 0) ? ANIMPLAY_FLAG_REVERSE : 0;
1994 sad->flag |= (sync == 0) ? ANIMPLAY_FLAG_NO_SYNC : (sync == 1) ? ANIMPLAY_FLAG_SYNC : 0;
1995
1996 ScrArea *area = CTX_wm_area(C);
1997
1998 char spacetype = -1;
1999
2000 if (area) {
2001 spacetype = area->spacetype;
2002 }
2003
2005
2006 screen->animtimer->customdata = sad;
2007 }
2008
2009 /* Notifier caught by top header, for button. */
2011}
2012
2013/* helper for screen_animation_play() - only to be used for TimeLine */
2015{
2016 ARegion *region_top_left = nullptr;
2017 int min = 10000;
2018
2019 for (ScrArea &area : screen->areabase) {
2020 if (area.spacetype == SPACE_VIEW3D) {
2021 for (ARegion &region : area.regionbase) {
2022 if (region.regiontype == RGN_TYPE_WINDOW) {
2023 if (region.winrct.xmin - region.winrct.ymin < min) {
2024 region_top_left = &region;
2025 min = region.winrct.xmin - region.winrct.ymin;
2026 }
2027 }
2028 }
2029 }
2030 }
2031
2032 return region_top_left;
2033}
2034
2036{
2037 if (screen && screen->animtimer) {
2038 wmTimer *wt = screen->animtimer;
2039 ScreenAnimData *sad = static_cast<ScreenAnimData *>(wt->customdata);
2040
2041 sad->redraws = redraws;
2042 sad->region = nullptr;
2043 if (redraws & TIME_REGION) {
2044 sad->region = time_top_left_3dwindow(screen);
2045 }
2046 }
2047}
2048
2049void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
2050{
2051 Scene *scene = DEG_get_input_scene(depsgraph);
2052
2053 DEG_time_tag_update(bmain);
2054
2055 void *camera = BKE_scene_camera_switch_find(scene, int(BKE_scene_ctime_get(scene)));
2056 if (camera && scene->camera != camera) {
2057 scene->camera = static_cast<Object *>(camera);
2058 /* are there cameras in the views that are not in the scene? */
2059 for (bScreen &screen : bmain->screens) {
2060 BKE_screen_view3d_scene_sync(&screen, scene);
2061 }
2063 }
2064
2065 ED_clip_update_frame(bmain, scene->r.cfra);
2066
2067 /* this function applies the changes too */
2069}
2070
2071bool ED_screen_stereo3d_required(const bScreen *screen, const Scene *scene)
2072{
2073 const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
2074
2075 for (ScrArea &area : screen->areabase) {
2076 switch (area.spacetype) {
2077 case SPACE_VIEW3D: {
2078 View3D *v3d;
2079
2080 if (!is_multiview) {
2081 continue;
2082 }
2083
2084 v3d = area.spacedata.first_as<View3D>();
2085 if (v3d->camera && v3d->stereo3d_camera == STEREO_3D_ID) {
2086 for (ARegion &region : area.regionbase) {
2087 if (region.regiondata && region.regiontype == RGN_TYPE_WINDOW) {
2088 RegionView3D *rv3d = static_cast<RegionView3D *>(region.regiondata);
2089 if (rv3d->persp == RV3D_CAMOB) {
2090 return true;
2091 }
2092 }
2093 }
2094 }
2095 break;
2096 }
2097 case SPACE_IMAGE: {
2098 SpaceImage *sima;
2099
2100 /* images should always show in stereo, even if
2101 * the file doesn't have views enabled */
2102 sima = area.spacedata.first_as<SpaceImage>();
2103 if (sima->image && BKE_image_is_stereo(sima->image) &&
2104 (sima->iuser.flag & IMA_SHOW_STEREO))
2105 {
2106 return true;
2107 }
2108 break;
2109 }
2110 case SPACE_NODE: {
2111 SpaceNode *snode;
2112
2113 if (!is_multiview) {
2114 continue;
2115 }
2116
2117 snode = area.spacedata.first_as<SpaceNode>();
2118 if ((snode->flag & SNODE_BACKDRAW) && ED_node_is_compositor(snode)) {
2119 return true;
2120 }
2121 break;
2122 }
2123 case SPACE_SEQ: {
2124 SpaceSeq *sseq;
2125
2126 if (!is_multiview) {
2127 continue;
2128 }
2129
2130 sseq = area.spacedata.first_as<SpaceSeq>();
2132 return true;
2133 }
2134
2135 break;
2136 }
2137 }
2138 }
2139
2140 return false;
2141}
2142
2144 const wmWindowManager *wm,
2145 wmWindow **r_window)
2146{
2147 for (wmWindow &win : wm->windows) {
2148 if (WM_window_get_active_screen(&win) == screen) {
2149 if (r_window) {
2150 *r_window = &win;
2151 }
2152 return WM_window_get_active_scene(&win);
2153 }
2154 }
2155
2156 /* Can by nullptr when accessing a screen that isn't active. */
2157 return nullptr;
2158}
2159
2161 const SpaceLink *sl,
2162 const bool only_visible)
2163{
2164 if (only_visible) {
2165 for (ScrArea &area : screen->areabase) {
2166 if (area.spacedata.first() == sl) {
2167 return &area;
2168 }
2169 }
2170 }
2171 else {
2172 for (ScrArea &area : screen->areabase) {
2173 if (BLI_findindex(&area.spacedata, sl) != -1) {
2174 return &area;
2175 }
2176 }
2177 }
2178 return nullptr;
2179}
2180
2182{
2183 return ED_screen_scene_find_with_window(screen, wm, nullptr);
2184}
2185
2187{
2188 for (wmWindow &win : wm->windows) {
2189 if (WM_window_get_active_screen(&win) == screen) {
2190 return &win;
2191 }
2192 }
2193 return nullptr;
2194}
2195
2196} // namespace blender
#define BLI_SCOPED_DEFER(function_to_defer)
#define SNPRINTF_UTF8(dst, format,...)
#define MAX_ID_NAME
Definition DNA_ID.h:367
Object is a sort of wrapper for general info.
#define AREAMAP_FROM_SCREEN(screen)
#define UI_SCALE_FAC
#define ED_screen_verts_iter(win, screen, vert_name)
Definition ED_screen.hh:325
#define ED_screen_areas_iter(win, screen, area_name)
Definition ED_screen.hh:322
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_WINDOW
Definition WM_types.hh:388
#define ND_FILEREAD
Definition WM_types.hh:428
#define NC_WM
Definition WM_types.hh:387
#define NC_SCREEN
Definition WM_types.hh:390
#define ND_MODE
Definition WM_types.hh:464
#define ND_ANIMPLAY
Definition WM_types.hh:441
#define NC_SCENE
Definition WM_types.hh:391
#define NA_EDITED
Definition WM_types.hh:634
#define ND_LAYOUTSET
Definition WM_types.hh:443
#define BLI_assert_unreachable()
#define UNUSED_VARS(...)
#define UNUSED_VARS_NDEBUG(...)
#define ELEM(...)
#define abs
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
const int state
bool is_scene_time_sync_needed(const bContext &C)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
Definition abc_util.cc:68
void blocklist_free(const bContext *C, ARegion *region)
void UI_screen_free_active_but_highlight(const bContext *C, bScreen *screen)
void popup_handlers_remove_all(bContext *C, ListBaseT< wmEventHandler > *handlers)
void panel_stop_animation(const bContext *C, Panel *panel)
BMesh Iterators.
bool ED_node_is_compositor(const SpaceNode *snode)
Definition node_edit.cc:135
UserDef U
Definition blender.cc:58
void ED_region_exit(bContext *C, ARegion *region)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ SEQ_GIZMO_HIDE_NAVIGATE
void DEG_time_tag_update(Main *bmain)
void screen_stop_playback(Main *bmain, wmWindowManager *wm, wmWindow *win, bScreen *screen)
static void screen_global_topbar_area_refresh(wmWindow *win, bScreen *screen)
void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
Definition scene.cc:2953
eScreenDir area_getorientation(ScrArea *sa_a, ScrArea *sa_b)
static ScrArea * screen_area_create_with_geometry(ScrAreaMap *area_map, const rcti *rect, eSpace_Type space_type)
int ED_area_icon(const ScrArea *area)
ScrArea * CTX_wm_area(const bContext *C)
static bool screen_areas_align(bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2, const eScreenDir dir)
bool screen_area_close(bContext *C, ReportList *reports, bScreen *screen, ScrArea *area, ScrArea *not_area)
int screen_area_join(bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
void BKE_workspace_active_set(WorkSpaceInstanceHook *hook, WorkSpace *workspace) SETTER_ATTRS
Definition workspace.cc:637
void ED_screen_ensure_updated(bContext *C, wmWindowManager *wm, wmWindow *win)
void ED_area_data_copy(ScrArea *area_dst, ScrArea *area_src, const bool do_free)
Definition area.cc:2628
void ED_screen_set_active_region(bContext *C, wmWindow *win, const int xy[2])
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
void WM_event_timer_sleep(wmWindowManager *wm, wmWindow *, wmTimer *timer, bool do_sleep)
int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
void ED_screen_scene_change(bContext *C, wmWindow *win, Scene *scene, bool refresh_toolsystem)
ScrEdge * screen_geom_find_active_scredge(const wmWindow *win, const bScreen *screen, const int mx, const int my)
void ED_screen_animation_timer(bContext *C, Scene *scene, ViewLayer *view_layer, int redraws, int sync, int enable)
bScreen * ED_screen_state_maximized_create(bContext *C)
void BKE_screen_remove_double_scrverts(bScreen *screen)
Definition screen.cc:851
void BKE_scene_frame_clamp_for_playback(Scene *scene, bool is_playing_forward)
Definition scene.cc:2615
const EnumPropertyItem rna_enum_space_type_items[]
Definition rna_space.cc:91
static ScrArea * screen_area_trim(bContext *C, bScreen *screen, ScrArea **area, int size, eScreenDir dir, bool reverse)
void BKE_screen_area_free(ScrArea *area)
Definition screen.cc:783
static void screen_verts_halign(const wmWindow *win, const bScreen *screen, const short from_x, const short to_x)
@ FULLSCREEN_RESTORE_STATS
@ FULLSCREEN_RESTORE_TEXT
@ FULLSCREEN_RESTORE_GIZMO_NAVIGATE
ScrArea * area_split(const wmWindow *win, bScreen *screen, ScrArea *area, const eScreenAxis dir_axis, const float fac)
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
WorkSpace * CTX_wm_workspace(const bContext *C)
void ED_region_visibility_change_update_ex(bContext *C, ScrArea *area, ARegion *region, bool is_hidden, bool do_init)
Definition area.cc:2580
void ED_screen_animation_timer_update(bScreen *screen, int redraws)
void ED_screen_global_areas_sync(wmWindow *win)
ScrArea * ED_screen_full_newspace(bContext *C, ScrArea *area, int type)
ScrVert * screen_geom_vertex_add_ex(ScrAreaMap *area_map, short x, short y)
void BKE_screen_remove_unused_scredges(bScreen *screen)
Definition screen.cc:917
@ GLOBAL_AREA_ALIGN_BOTTOM
ScrArea * ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *area, eScreen_State state)
void BKE_screen_area_map_free(ScrAreaMap *area_map) ATTR_NONNULL()
Definition screen.cc:799
static bool screen_area_join_ex(bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2, bool close_all_remainders)
void CTX_wm_window_set(bContext *C, wmWindow *win)
WorkSpaceLayout * WM_window_get_active_layout(const wmWindow *win)
void BKE_area_region_free(SpaceType *st, ARegion *region)
Definition screen.cc:736
void ED_area_prevspace(bContext *C, ScrArea *area)
Definition area.cc:3111
AZone * ED_area_azones_update(ScrArea *area, const int mouse_xy[2])
void WM_window_decoration_style_apply(const wmWindow *win, const bScreen *screen)
Definition wm_window.cc:870
StringRefNull ED_area_name(const ScrArea *area)
void screen_change_prepare(bScreen *screen_old, bScreen *screen_new, Main *bmain, bContext *C, wmWindow *win)
AZone * ED_area_actionzone_find_xy(ScrArea *area, const int xy[2])
void WM_draw_region_free(ARegion *region)
Definition wm_draw.cc:1788
void ED_area_newspace(bContext *C, ScrArea *area, int type, bool skip_region_exit)
Definition area.cc:2929
int ED_area_headersize()
Definition area.cc:4418
wmWindow * CTX_wm_window(const bContext *C)
void ED_screen_restore_temp_type(bContext *C, ScrArea *area)
void ED_area_data_swap(ScrArea *area_dst, ScrArea *area_src)
Definition area.cc:2637
@ SCREEN_COLLAPSE_STATUSBAR
@ SEQ_VIEW_SEQUENCE_PREVIEW
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:684
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
void ED_screen_global_areas_refresh(wmWindow *win)
void ED_screen_animation_timer_remove(wmWindowManager *wm, wmWindow *win)
void ED_screen_full_restore(bContext *C, ScrArea *area)
int RNA_enum_from_value(const EnumPropertyItem *item, const int value)
bool WM_gizmo_highlight_set(wmGizmoMap *gzmap, wmGizmo *gz)
Definition wm_gizmo.cc:401
static bScreen * screen_state_to_nonnormal(bContext *C, wmWindow *win, ScrArea *toggle_area, eScreen_State state)
ScrVert * screen_geom_vertex_add(bScreen *screen, short x, short y)
void ED_screen_animation_stop(Main *bmain, wmWindowManager *wm, FunctionRef< bool(const bScreen &screen)> should_stop_fn)
void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
WorkSpace * BKE_workspace_active_get(WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:633
@ G_DEBUG_EVENTS
Object * BKE_view_layer_camera_find(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
Global G
Definition blender.cc:57
void WM_window_set_active_screen(wmWindow *win, WorkSpace *workspace, bScreen *screen)
static void screen_global_area_refresh(wmWindow *win, bScreen *screen, const eSpace_Type space_type, GlobalAreaAlign align, const rcti *rect, const short height_cur, const short height_min, const short height_max)
void WM_event_modal_handler_area_replace(wmWindow *win, const ScrArea *old_area, ScrArea *new_area)
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void screen_geom_vertices_scale(const wmWindow *win, bScreen *screen)
Main screen-layout calculation function.
static void screen_delarea(bContext *C, bScreen *screen, ScrArea *area)
void WM_event_remove_handlers(bContext *C, ListBaseT< wmEventHandler > *handlers)
void WM_window_rect_calc(const wmWindow *win, rcti *r_rect)
short screen_geom_find_area_split_point(const ScrArea *area, const rcti *window_rect, const eScreenAxis dir_axis, float fac)
void BKE_icon_changed(int icon_id)
Definition icons.cc:215
Scene * WM_window_get_active_scene(const wmWindow *win)
void WM_window_ensure_active_view_layer(wmWindow *win)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void CTX_wm_screen_set(bContext *C, bScreen *screen)
@ SI_GIZMO_HIDE_NAVIGATE
bool BKE_image_is_stereo(const Image *ima)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void DEG_id_tag_update(ID *id, unsigned int flags)
Scene * ED_screen_scene_find_with_window(const bScreen *screen, const wmWindowManager *wm, wmWindow **r_window)
static ARegion * time_top_left_3dwindow(bScreen *screen)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
void BKE_screen_header_alignment_reset(bScreen *screen)
Definition screen.cc:1303
int ED_screen_area_active(const bContext *C)
void ED_screens_init(bContext *C, Main *bmain, wmWindowManager *wm)
wmWindowManager * CTX_wm_manager(const bContext *C)
void ED_region_remove(bContext *C, ScrArea *area, ARegion *region)
static ScrArea * screen_addarea(bScreen *screen, ScrVert *left_bottom, ScrVert *left_top, ScrVert *right_top, ScrVert *right_bottom, const eSpace_Type space_type)
static bool region_poll(const bContext *C, const bScreen *screen, const ScrArea *area, const ARegion *region)
WorkSpaceLayout * ED_workspace_screen_change_ensure_unused_layout(Main *bmain, WorkSpace *workspace, WorkSpaceLayout *layout_new, const WorkSpaceLayout *layout_fallback_base, wmWindow *win) ATTR_NONNULL()
static bool screen_area_join_aligned(bContext *C, ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
static void screen_verts_valign(const wmWindow *win, const bScreen *screen, const short from_y, const short to_y)
static int screen_global_header_size()
WorkSpaceLayout * ED_workspace_layout_add(Main *bmain, WorkSpace *workspace, wmWindow *win, const char *name) ATTR_NONNULL()
void ED_area_exit(bContext *C, ScrArea *area)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
static void region_cursor_set(wmWindow *win, bool swin_changed)
@ AE_RIGHT_TO_TOPLEFT
@ AE_LEFT_TO_TOPRIGHT
WorkSpace * WM_window_get_active_workspace(const wmWindow *win)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
bool screen_geom_edge_is_horizontal(ScrEdge *se)
void WM_window_status_area_tag_redraw(wmWindow *win)
void ED_area_status_text(ScrArea *area, const char *str)
Definition area.cc:975
Scene * ED_screen_scene_find(const bScreen *screen, const wmWindowManager *wm)
SpaceType * BKE_spacetype_from_id(int spaceid)
Definition screen.cc:354
void WM_event_ui_handler_region_popup_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
bool WM_window_is_main_top_level(const wmWindow *win)
void BKE_screen_view3d_sync(View3D *v3d, Scene *scene)
Definition screen.cc:1231
void WM_msgbus_clear_by_owner(wmMsgBus *mbus, void *owner)
ScrArea * ED_screen_temp_space_open(bContext *C, const char *title, eSpace_Type space_type, int display_type, bool dialog) ATTR_NONNULL(1)
void area_getoffsets(ScrArea *sa_a, ScrArea *sa_b, const eScreenDir dir, int *r_offset1, int *r_offset2)
ScrEdge * screen_geom_edge_add_ex(ScrAreaMap *area_map, ScrVert *v1, ScrVert *v2)
static void screen_area_set_geometry_rect(ScrArea *area, const rcti *rect)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool ED_screen_stereo3d_required(const bScreen *screen, const Scene *scene)
wmWindow * WM_window_open_temp(bContext *C, const char *title, int space_type, bool dialog)
bool area_regions_poll(bContext *C, const bScreen *screen, ScrArea *area)
@ WM_CAPABILITY_WINDOW_DECORATION_STYLES
Definition WM_api.hh:243
bScreen * ED_screen_animation_no_scrub(const wmWindowManager *wm)
static void region_cursor_set_ex(wmWindow *win, ScrArea *area, ARegion *region, bool swin_changed)
void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
void ED_area_and_region_types_init(ScrArea *area)
Definition area.cc:2366
static void screen_global_statusbar_area_refresh(wmWindow *win, bScreen *screen)
void screen_animate_area_highlight(wmWindow *win, bScreen *screen, const rcti *rect, float inner[4], float outline[4], float seconds)
Object * BKE_scene_camera_switch_find(const Scene *scene, const int time)
Definition scene.cc:2440
@ WM_CURSOR_Y_MOVE
Definition wm_cursors.hh:42
@ WM_CURSOR_EDIT
Definition wm_cursors.hh:21
@ WM_CURSOR_NSEW_SCROLL
Definition wm_cursors.hh:54
@ WM_CURSOR_DEFAULT
Definition wm_cursors.hh:17
@ WM_CURSOR_X_MOVE
Definition wm_cursors.hh:41
@ USER_TEMP_SPACE_DISPLAY_FULLSCREEN
@ USER_TEMP_SPACE_DISPLAY_WINDOW
void BKE_screen_view3d_scene_sync(bScreen *screen, Scene *scene)
Definition screen.cc:1249
static void screen_set_3dview_camera(const Main &bmain, Scene *scene, ViewLayer *view_layer, ScrArea *area, View3D *v3d)
void ED_screen_full_prevspace(bContext *C, ScrArea *area)
void ED_area_init(bContext *C, const wmWindow *win, ScrArea *area)
Definition area.cc:2383
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
static void screen_refresh_if_needed(bContext *C, wmWindowManager *wm, wmWindow *win)
Main * CTX_data_main(const bContext *C)
void ED_region_cursor_set(wmWindow *win, ScrArea *area, ARegion *region)
Definition area.cc:2554
float BKE_scene_ctime_get(const Scene *scene)
Definition scene.cc:2581
static ScrArea * screen_addarea_ex(ScrAreaMap *area_map, ScrVert *bottom_left, ScrVert *top_left, ScrVert *top_right, ScrVert *bottom_right, const eSpace_Type space_type)
eWM_CapabilitiesFlag WM_capabilities_flag()
bScreen * BKE_workspace_layout_screen_get(const WorkSpaceLayout *layout) GETTER_ATTRS
Definition workspace.cc:709
void BKE_workspace_layout_remove(Main *bmain, WorkSpace *workspace, WorkSpaceLayout *layout) ATTR_NONNULL()
Definition workspace.cc:472
bool ED_region_contains_xy(const ARegion *region, const int event_xy[2])
@ ANIMPLAY_FLAG_REVERSE
@ ANIMPLAY_FLAG_NO_SYNC
@ ID_RECALC_PARAMETERS
Definition DNA_ID.h:1138
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
@ ID_RECALC_FRAME_CHANGE
Definition DNA_ID.h:1125
Scene * DEG_get_input_scene(const Depsgraph *graph)
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
ScrEdge * screen_geom_edge_add(bScreen *screen, ScrVert *v1, ScrVert *v2)
static bool screen_regions_poll(bContext *C, wmWindow *win, const bScreen *screen)
void WM_event_remove_handlers_by_area(ListBaseT< wmEventHandler > *handlers, const ScrArea *area)
bool ED_screen_change(bContext *C, bScreen *screen)
Change the active screen.
bScreen * screen_add(Main *bmain, const char *name, const rcti *rect)
void ED_screen_refresh(bContext *C, wmWindowManager *wm, wmWindow *win)
bScreen * CTX_wm_screen(const bContext *C)
void CTX_wm_region_set(bContext *C, ARegion *region)
void WM_cursor_set(wmWindow *win, int curs)
void WM_event_modal_handler_region_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
bool WM_cursor_test_motion_and_update(const int mval[2])
static void screen_cursor_set(wmWindow *win, const int xy[2])
void ED_area_tag_refresh(ScrArea *area)
Definition area.cc:813
wmTimer * WM_event_timer_add(wmWindowManager *wm, wmWindow *win, const wmEventType event_type, const double time_step)
void screen_change_update(bContext *C, wmWindow *win, bScreen *screen)
void WM_event_add_mousemove(wmWindow *win)
ScrArea * ED_screen_area_find_with_spacedata(const bScreen *screen, const SpaceLink *sl, bool only_visible)
static bool screen_areas_can_align(ReportList *reports, bScreen *screen, ScrArea *sa1, ScrArea *sa2, eScreenDir dir)
void WM_window_screen_rect_calc(const wmWindow *win, rcti *r_rect)
bScreen * WM_window_get_active_screen(const wmWindow *win)
void screen_new_activate_prepare(const wmWindow *win, bScreen *screen_new)
void ED_screen_do_listen(bContext *C, const wmNotifier *note)
void WM_window_dpi_set_userdef(const wmWindow *win)
Definition wm_window.cc:737
ARegion * CTX_wm_region(const bContext *C)
void ED_workspace_status_text(bContext *C, const char *str)
Definition area.cc:1153
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
void ED_region_tag_redraw_no_rebuild(ARegion *region)
Definition area.cc:727
@ V3D_GIZMO_HIDE_NAVIGATE
void ED_clip_update_frame(const Main *mainp, int cfra)
wmWindow * ED_screen_window_find(const bScreen *screen, const wmWindowManager *wm)
WorkSpaceLayout * BKE_workspace_layout_find(const WorkSpace *workspace, const bScreen *screen) ATTR_NONNULL() ATTR_WARN_UNUSED_RESULT
Definition workspace.cc:499
void WM_toolsystem_refresh_screen_window(const Main &bmain, wmWindow *win)
void CTX_data_scene_set(bContext *C, Scene *scene)
@ SCLIP_GIZMO_HIDE_NAVIGATE
void BKE_screen_remove_double_scredges(bScreen *screen)
Definition screen.cc:901
bool WM_window_is_temp_screen(const wmWindow *win)
@ AREA_FLAG_STACKED_FULLSCREEN
void ED_area_tag_redraw(ScrArea *area)
Definition area.cc:784
void CTX_wm_area_set(bContext *C, ScrArea *area)
@ SPACE_FLAG_TYPE_WAS_ACTIVE
@ SPACE_FLAG_TYPE_TEMPORARY
void screen_area_spacelink_add(const Scene *scene, ScrArea *area, eSpace_Type space_type)
#define ceilf
#define SCREEN_DIR_IS_HORIZONTAL(dir)
#define BORDERPADDING
#define SCREEN_DIR_IS_VERTICAL(dir)
#define AREAJOINTOLERANCEX
#define AREA_CLOSE_FADEOUT
#define AREAJOINTOLERANCEY
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
void(*) exit(wmWindowManager *wm, ARegion *region)
void(*) on_poll_success(const bContext *C, ARegion *region)
bool(*) poll(const RegionPollParams *params)
ListBaseT< Panel > panels
bke::ARegionRuntime * runtime
eRegion_Type regiontype
char name[258]
Definition DNA_ID.h:433
int icon_id
Definition DNA_ID.h:445
eImageUser_Flag flag
ListBaseT< WorkSpace > workspaces
Definition BKE_main.hh:423
ListBaseT< bScreen > screens
Definition BKE_main.hh:400
const bContext * context
eRegionView3D_Flag rflag
eRegionView3D_Persp persp
struct Object * camera
struct RenderData r
ListBaseT< ScrArea > areabase
ListBaseT< struct wmEventHandler > handlers
ListBaseT< ARegion > regionbase
ListBaseT< SpaceLink > spacedata
ScrGlobalAreaData * global
struct SpaceType * type
eSpaceClip_Gizmo_Flag gizmo_flag
eSpaceImage_Gizmo_Flag gizmo_flag
struct ImageUser iuser
eSpaceNode_Flag flag
eSpaceSeq_Gizmo_Flag gizmo_flag
eSpaceSeq_Displays view
SpaceLink *(*) create(const ScrArea *area, const Scene *scene)
StringRefNull(*) space_name_get(const ScrArea *area)
void(*) exit(wmWindowManager *wm, ScrArea *area)
int(*) space_icon_get(const ScrArea *area)
eView3DOverlay_Flag flag
View3DOverlay overlay
struct Object * camera
ListBaseT< ARegion > regionbase
eView3D_GizmoFlag gizmo_flag
eScreen_State state
eScreen_Fullscreen_Flag fullscreen_flag
struct wmTimer * animtimer
struct ARegion * active_region
ListBaseT< struct ScrArea > areabase
eScreen_Redraws_Flag redraws_flag
ListBaseT< ARegion > regionbase
ListBaseT< wmEventHandler > handlers
struct ARegionType * type
ListBaseT< wmEventHandler > modalhandlers
unsigned int action
Definition WM_types.hh:371
unsigned int category
Definition WM_types.hh:371
unsigned int data
Definition WM_types.hh:371
bke::WindowRuntime * runtime
struct WorkSpaceInstanceHook * workspace_hook