Blender  V3.3
screen_edit.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2008 Blender Foundation. All rights reserved. */
3 
8 #include <math.h>
9 #include <string.h>
10 
11 #include "MEM_guardedalloc.h"
12 
13 #include "DNA_object_types.h"
14 #include "DNA_scene_types.h"
15 #include "DNA_userdef_types.h"
16 #include "DNA_workspace_types.h"
17 
18 #include "BLI_blenlib.h"
19 #include "BLI_utildefines.h"
20 
21 #include "BKE_context.h"
22 #include "BKE_global.h"
23 #include "BKE_icons.h"
24 #include "BKE_image.h"
25 #include "BKE_layer.h"
26 #include "BKE_lib_id.h"
27 #include "BKE_main.h"
28 #include "BKE_scene.h"
29 #include "BKE_screen.h"
30 #include "BKE_sound.h"
31 #include "BKE_workspace.h"
32 
33 #include "WM_api.h"
34 #include "WM_types.h"
35 
36 #include "ED_clip.h"
37 #include "ED_node.h"
38 #include "ED_screen.h"
39 #include "ED_screen_types.h"
40 
41 #include "UI_interface.h"
42 
43 #include "WM_message.h"
44 #include "WM_toolsystem.h"
45 
46 #include "DEG_depsgraph_query.h"
47 
48 #include "screen_intern.h" /* own module include */
49 
50 /* adds no space data */
52  ScrVert *bottom_left,
53  ScrVert *top_left,
54  ScrVert *top_right,
55  ScrVert *bottom_right,
56  const eSpace_Type space_type)
57 {
58  ScrArea *area = MEM_callocN(sizeof(ScrArea), "addscrarea");
59 
60  area->v1 = bottom_left;
61  area->v2 = top_left;
62  area->v3 = top_right;
63  area->v4 = bottom_right;
64  area->spacetype = space_type;
65 
66  BLI_addtail(&area_map->areabase, area);
67 
68  return area;
69 }
70 static ScrArea *screen_addarea(bScreen *screen,
71  ScrVert *left_bottom,
72  ScrVert *left_top,
73  ScrVert *right_top,
74  ScrVert *right_bottom,
75  const eSpace_Type space_type)
76 {
77  return screen_addarea_ex(
78  AREAMAP_FROM_SCREEN(screen), left_bottom, left_top, right_top, right_bottom, space_type);
79 }
80 
81 static void screen_delarea(bContext *C, bScreen *screen, ScrArea *area)
82 {
83 
85 
87 
88  BLI_remlink(&screen->areabase, area);
89  MEM_freeN(area);
90 }
91 
93  bScreen *screen,
94  ScrArea *area,
95  const eScreenAxis dir_axis,
96  const float fac,
97  const bool merge)
98 {
99  ScrArea *newa = NULL;
100 
101  if (area == NULL) {
102  return NULL;
103  }
104 
105  rcti window_rect;
106  WM_window_rect_calc(win, &window_rect);
107 
108  short split = screen_geom_find_area_split_point(area, &window_rect, dir_axis, fac);
109  if (split == 0) {
110  return NULL;
111  }
112 
113  /* NOTE(campbell): regarding (fac > 0.5f) checks below.
114  * normally it shouldn't matter which is used since the copy should match the original
115  * however with viewport rendering and python console this isn't the case. */
116 
117  if (dir_axis == SCREEN_AXIS_H) {
118  /* new vertices */
119  ScrVert *sv1 = screen_geom_vertex_add(screen, area->v1->vec.x, split);
120  ScrVert *sv2 = screen_geom_vertex_add(screen, area->v4->vec.x, split);
121 
122  /* new edges */
123  screen_geom_edge_add(screen, area->v1, sv1);
124  screen_geom_edge_add(screen, sv1, area->v2);
125  screen_geom_edge_add(screen, area->v3, sv2);
126  screen_geom_edge_add(screen, sv2, area->v4);
127  screen_geom_edge_add(screen, sv1, sv2);
128 
129  if (fac > 0.5f) {
130  /* new areas: top */
131  newa = screen_addarea(screen, sv1, area->v2, area->v3, sv2, area->spacetype);
132 
133  /* area below */
134  area->v2 = sv1;
135  area->v3 = sv2;
136  }
137  else {
138  /* new areas: bottom */
139  newa = screen_addarea(screen, area->v1, sv1, sv2, area->v4, area->spacetype);
140 
141  /* area above */
142  area->v1 = sv1;
143  area->v4 = sv2;
144  }
145 
146  ED_area_data_copy(newa, area, true);
147  }
148  else {
149  /* new vertices */
150  ScrVert *sv1 = screen_geom_vertex_add(screen, split, area->v1->vec.y);
151  ScrVert *sv2 = screen_geom_vertex_add(screen, split, area->v2->vec.y);
152 
153  /* new edges */
154  screen_geom_edge_add(screen, area->v1, sv1);
155  screen_geom_edge_add(screen, sv1, area->v4);
156  screen_geom_edge_add(screen, area->v2, sv2);
157  screen_geom_edge_add(screen, sv2, area->v3);
158  screen_geom_edge_add(screen, sv1, sv2);
159 
160  if (fac > 0.5f) {
161  /* new areas: right */
162  newa = screen_addarea(screen, sv1, sv2, area->v3, area->v4, area->spacetype);
163 
164  /* area left */
165  area->v3 = sv2;
166  area->v4 = sv1;
167  }
168  else {
169  /* new areas: left */
170  newa = screen_addarea(screen, area->v1, area->v2, sv2, sv1, area->spacetype);
171 
172  /* area right */
173  area->v1 = sv1;
174  area->v2 = sv2;
175  }
176 
177  ED_area_data_copy(newa, area, true);
178  }
179 
180  /* remove double vertices en edges */
181  if (merge) {
183  }
186 
187  return newa;
188 }
189 
190 bScreen *screen_add(Main *bmain, const char *name, const rcti *rect)
191 {
192  bScreen *screen = BKE_libblock_alloc(bmain, ID_SCR, name, 0);
193  screen->do_refresh = true;
195 
196  ScrVert *sv1 = screen_geom_vertex_add(screen, rect->xmin, rect->ymin);
197  ScrVert *sv2 = screen_geom_vertex_add(screen, rect->xmin, rect->ymax - 1);
198  ScrVert *sv3 = screen_geom_vertex_add(screen, rect->xmax - 1, rect->ymax - 1);
199  ScrVert *sv4 = screen_geom_vertex_add(screen, rect->xmax - 1, rect->ymin);
200 
201  screen_geom_edge_add(screen, sv1, sv2);
202  screen_geom_edge_add(screen, sv2, sv3);
203  screen_geom_edge_add(screen, sv3, sv4);
204  screen_geom_edge_add(screen, sv4, sv1);
205 
206  /* dummy type, no spacedata */
207  screen_addarea(screen, sv1, sv2, sv3, sv4, SPACE_EMPTY);
208 
209  return screen;
210 }
211 
213 {
214  /* free contents of 'to', is from blenkernel screen.c */
216 
217  to->flag = from->flag;
218 
219  BLI_duplicatelist(&to->vertbase, &from->vertbase);
220  BLI_duplicatelist(&to->edgebase, &from->edgebase);
221  BLI_duplicatelist(&to->areabase, &from->areabase);
223 
224  ScrVert *s2 = to->vertbase.first;
225  for (ScrVert *s1 = from->vertbase.first; s1; s1 = s1->next, s2 = s2->next) {
226  s1->newv = s2;
227  }
228 
229  LISTBASE_FOREACH (ScrEdge *, se, &to->edgebase) {
230  se->v1 = se->v1->newv;
231  se->v2 = se->v2->newv;
232  BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
233  }
234 
235  ScrArea *from_area = from->areabase.first;
237  area->v1 = area->v1->newv;
238  area->v2 = area->v2->newv;
239  area->v3 = area->v3->newv;
240  area->v4 = area->v4->newv;
241 
242  BLI_listbase_clear(&area->spacedata);
243  BLI_listbase_clear(&area->regionbase);
244  BLI_listbase_clear(&area->actionzones);
245  BLI_listbase_clear(&area->handlers);
246 
247  ED_area_data_copy(area, from_area, true);
248 
249  from_area = from_area->next;
250  }
251 
252  /* put at zero (needed?) */
253  LISTBASE_FOREACH (ScrVert *, s1, &from->vertbase) {
254  s1->newv = NULL;
255  }
256 }
257 
258 void screen_new_activate_prepare(const wmWindow *win, bScreen *screen_new)
259 {
260  screen_new->winid = win->winid;
261  screen_new->do_refresh = true;
262  screen_new->do_draw = true;
263 }
264 
266 {
267  if (sa_a == NULL || sa_b == NULL || sa_a == sa_b) {
268  return SCREEN_DIR_NONE;
269  }
270 
271  const vec2s *sa_bl = &sa_a->v1->vec;
272  const vec2s *sa_tl = &sa_a->v2->vec;
273  const vec2s *sa_tr = &sa_a->v3->vec;
274  const vec2s *sa_br = &sa_a->v4->vec;
275 
276  const vec2s *sb_bl = &sa_b->v1->vec;
277  const vec2s *sb_tl = &sa_b->v2->vec;
278  const vec2s *sb_tr = &sa_b->v3->vec;
279  const vec2s *sb_br = &sa_b->v4->vec;
280 
281  if (sa_bl->x == sb_br->x && sa_tl->x == sb_tr->x) { /* sa_a to right of sa_b = W */
282  if ((MIN2(sa_tl->y, sb_tr->y) - MAX2(sa_bl->y, sb_br->y)) > AREAJOINTOLERANCEY) {
283  return 0;
284  }
285  }
286  else if (sa_tl->y == sb_bl->y && sa_tr->y == sb_br->y) { /* sa_a to bottom of sa_b = N */
287  if ((MIN2(sa_tr->x, sb_br->x) - MAX2(sa_tl->x, sb_bl->x)) > AREAJOINTOLERANCEX) {
288  return 1;
289  }
290  }
291  else if (sa_tr->x == sb_tl->x && sa_br->x == sb_bl->x) { /* sa_a to left of sa_b = E */
292  if ((MIN2(sa_tr->y, sb_tl->y) - MAX2(sa_br->y, sb_bl->y)) > AREAJOINTOLERANCEY) {
293  return 2;
294  }
295  }
296  else if (sa_bl->y == sb_tl->y && sa_br->y == sb_tr->y) { /* sa_a on top of sa_b = S */
297  if ((MIN2(sa_br->x, sb_tr->x) - MAX2(sa_bl->x, sb_tl->x)) > AREAJOINTOLERANCEX) {
298  return 3;
299  }
300  }
301 
302  return -1;
303 }
304 
306  ScrArea *sa_a, ScrArea *sa_b, const eScreenDir dir, int *r_offset1, int *r_offset2)
307 {
308  if (sa_a == NULL || sa_b == NULL) {
309  *r_offset1 = INT_MAX;
310  *r_offset2 = INT_MAX;
311  }
312  else if (dir == SCREEN_DIR_W) { /* West: sa on right and sa_b to the left. */
313  *r_offset1 = sa_b->v3->vec.y - sa_a->v2->vec.y;
314  *r_offset2 = sa_b->v4->vec.y - sa_a->v1->vec.y;
315  }
316  else if (dir == SCREEN_DIR_N) { /* North: sa below and sa_b above. */
317  *r_offset1 = sa_a->v2->vec.x - sa_b->v1->vec.x;
318  *r_offset2 = sa_a->v3->vec.x - sa_b->v4->vec.x;
319  }
320  else if (dir == SCREEN_DIR_E) { /* East: sa on left and sa_b to the right. */
321  *r_offset1 = sa_b->v2->vec.y - sa_a->v3->vec.y;
322  *r_offset2 = sa_b->v1->vec.y - sa_a->v4->vec.y;
323  }
324  else if (dir == SCREEN_DIR_S) { /* South: sa above and sa_b below. */
325  *r_offset1 = sa_a->v1->vec.x - sa_b->v2->vec.x;
326  *r_offset2 = sa_a->v4->vec.x - sa_b->v3->vec.x;
327  }
328  else {
329  BLI_assert(dir == SCREEN_DIR_NONE);
330  *r_offset1 = INT_MAX;
331  *r_offset2 = INT_MAX;
332  }
333 }
334 
335 /* Screen verts with horizontal position equal to from_x are moved to to_x. */
336 static void screen_verts_halign(const wmWindow *win,
337  const bScreen *screen,
338  const short from_x,
339  const short to_x)
340 {
341  ED_screen_verts_iter(win, screen, v1)
342  {
343  if (v1->vec.x == from_x) {
344  v1->vec.x = to_x;
345  }
346  }
347 }
348 
349 /* Screen verts with vertical position equal to from_y are moved to to_y. */
350 static void screen_verts_valign(const wmWindow *win,
351  const bScreen *screen,
352  const short from_y,
353  const short to_y)
354 {
355  ED_screen_verts_iter(win, screen, v1)
356  {
357  if (v1->vec.y == from_y) {
358  v1->vec.y = to_y;
359  }
360  }
361 }
362 
363 /* Adjust all screen edges to allow joining two areas. 'dir' value is like area_getorientation().
364  */
365 static void screen_areas_align(
366  bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2, const eScreenDir dir)
367 {
368  wmWindow *win = CTX_wm_window(C);
369 
370  if (SCREEN_DIR_IS_HORIZONTAL(dir)) {
371  /* horizontal join, use average for new top and bottom. */
372  int top = (sa1->v2->vec.y + sa2->v2->vec.y) / 2;
373  int bottom = (sa1->v4->vec.y + sa2->v4->vec.y) / 2;
374 
375  /* Move edges exactly matching source top and bottom. */
376  screen_verts_valign(win, screen, sa1->v2->vec.y, top);
377  screen_verts_valign(win, screen, sa1->v4->vec.y, bottom);
378 
379  /* Move edges exactly matching target top and bottom. */
380  screen_verts_valign(win, screen, sa2->v2->vec.y, top);
381  screen_verts_valign(win, screen, sa2->v4->vec.y, bottom);
382  }
383  else {
384  /* Vertical join, use averages for new left and right. */
385  int left = (sa1->v1->vec.x + sa2->v1->vec.x) / 2;
386  int right = (sa1->v3->vec.x + sa2->v3->vec.x) / 2;
387 
388  /* Move edges exactly matching source left and right. */
389  screen_verts_halign(win, screen, sa1->v1->vec.x, left);
390  screen_verts_halign(win, screen, sa1->v3->vec.x, right);
391 
392  /* Move edges exactly matching target left and right */
393  screen_verts_halign(win, screen, sa2->v1->vec.x, left);
394  screen_verts_halign(win, screen, sa2->v3->vec.x, right);
395  }
396 }
397 
398 /* Simple join of two areas without any splitting. Will return false if not possible. */
399 static bool screen_area_join_aligned(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
400 {
401  const eScreenDir dir = area_getorientation(sa1, sa2);
402  if (dir == SCREEN_DIR_NONE) {
403  return false;
404  }
405 
406  int offset1;
407  int offset2;
408  area_getoffsets(sa1, sa2, dir, &offset1, &offset2);
409 
411  if ((abs(offset1) >= tolerance) || (abs(offset2) >= tolerance)) {
412  return false;
413  }
414 
415  /* Align areas if they are not. */
416  screen_areas_align(C, screen, sa1, sa2, dir);
417 
418  if (dir == SCREEN_DIR_W) { /* sa1 to right of sa2 = West. */
419  sa1->v1 = sa2->v1; /* BL */
420  sa1->v2 = sa2->v2; /* TL */
421  screen_geom_edge_add(screen, sa1->v2, sa1->v3);
422  screen_geom_edge_add(screen, sa1->v1, sa1->v4);
423  }
424  else if (dir == SCREEN_DIR_N) { /* sa1 to bottom of sa2 = North. */
425  sa1->v2 = sa2->v2; /* TL */
426  sa1->v3 = sa2->v3; /* TR */
427  screen_geom_edge_add(screen, sa1->v1, sa1->v2);
428  screen_geom_edge_add(screen, sa1->v3, sa1->v4);
429  }
430  else if (dir == SCREEN_DIR_E) { /* sa1 to left of sa2 = East. */
431  sa1->v3 = sa2->v3; /* TR */
432  sa1->v4 = sa2->v4; /* BR */
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_S) { /* sa1 on top of sa2 = South. */
437  sa1->v1 = sa2->v1; /* BL */
438  sa1->v4 = sa2->v4; /* BR */
439  screen_geom_edge_add(screen, sa1->v1, sa1->v2);
440  screen_geom_edge_add(screen, sa1->v3, sa1->v4);
441  }
442 
443  screen_delarea(C, screen, sa2);
445  /* Update preview thumbnail */
446  BKE_icon_changed(screen->id.icon_id);
447 
448  return true;
449 }
450 
451 /* Slice off and return new area. "Reverse" gives right/bottom, rather than left/top. */
453  bContext *C, bScreen *screen, ScrArea **area, int size, eScreenDir dir, bool reverse)
454 {
455  const bool vertical = SCREEN_DIR_IS_VERTICAL(dir);
456  if (abs(size) < (vertical ? AREAJOINTOLERANCEX : AREAJOINTOLERANCEY)) {
457  return NULL;
458  }
459 
460  /* Measurement with ScrVerts because winx and winy might not be correct at this time. */
461  float fac = abs(size) / (float)(vertical ? ((*area)->v3->vec.x - (*area)->v1->vec.x) :
462  ((*area)->v3->vec.y - (*area)->v1->vec.y));
463  fac = (reverse == vertical) ? 1.0f - fac : fac;
464  ScrArea *newsa = area_split(
465  CTX_wm_window(C), screen, *area, vertical ? SCREEN_AXIS_V : SCREEN_AXIS_H, fac, true);
466 
467  /* area_split always returns smallest of the two areas, so might have to swap. */
468  if (((fac > 0.5f) == vertical) != reverse) {
469  ScrArea *temp = *area;
470  *area = newsa;
471  newsa = temp;
472  }
473 
474  return newsa;
475 }
476 
477 /* Join any two neighboring areas. Might create new areas, kept if over min_remainder. */
479  bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2, bool close_all_remainders)
480 {
481  const eScreenDir dir = area_getorientation(sa1, sa2);
482  if (dir == SCREEN_DIR_NONE) {
483  return false;
484  }
485 
486  int offset1;
487  int offset2;
488  area_getoffsets(sa1, sa2, dir, &offset1, &offset2);
489 
490  /* Split Left/Top into new area if overhanging. */
491  ScrArea *side1 = screen_area_trim(C, screen, (offset1 > 0) ? &sa2 : &sa1, offset1, dir, false);
492 
493  /* Split Right/Bottom into new area if overhanging. */
494  ScrArea *side2 = screen_area_trim(C, screen, (offset2 > 0) ? &sa1 : &sa2, offset2, dir, true);
495 
496  /* The two areas now line up, so join them. */
497  screen_area_join_aligned(C, screen, sa1, sa2);
498 
499  if (close_all_remainders || offset1 < 0 || offset2 > 0) {
500  /* Close both if trimming `sa1`. */
501  screen_area_close(C, screen, side1);
502  screen_area_close(C, screen, side2);
503  }
504 
505  BKE_icon_changed(screen->id.icon_id);
506  return true;
507 }
508 
509 int screen_area_join(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
510 {
511  return screen_area_join_ex(C, screen, sa1, sa2, false);
512 }
513 
514 bool screen_area_close(struct bContext *C, bScreen *screen, ScrArea *area)
515 {
516  if (area == NULL) {
517  return false;
518  }
519 
520  ScrArea *sa2 = NULL;
521  float best_alignment = 0.0f;
522 
523  LISTBASE_FOREACH (ScrArea *, neighbor, &screen->areabase) {
524  const eScreenDir dir = area_getorientation(area, neighbor);
525  /* Must at least partially share an edge and not be a global area. */
526  if ((dir != SCREEN_DIR_NONE) && (neighbor->global == NULL)) {
527  /* Winx/Winy might not be updated yet, so get lengths from verts. */
528  const bool vertical = SCREEN_DIR_IS_VERTICAL(dir);
529  const int area_length = vertical ? (area->v3->vec.x - area->v1->vec.x) :
530  (area->v3->vec.y - area->v1->vec.y);
531  const int ar_length = vertical ? (neighbor->v3->vec.x - neighbor->v1->vec.x) :
532  (neighbor->v3->vec.y - neighbor->v1->vec.y);
533  /* Calculate the ratio of the lengths of the shared edges. */
534  float alignment = MIN2(area_length, ar_length) / (float)MAX2(area_length, ar_length);
535  if (alignment > best_alignment) {
536  best_alignment = alignment;
537  sa2 = neighbor;
538  }
539  }
540  }
541 
542  /* Join from neighbor into this area to close it. */
543  return screen_area_join_ex(C, screen, sa2, area, true);
544 }
545 
547 {
548  SpaceType *stype = BKE_spacetype_from_id(space_type);
549  SpaceLink *slink = stype->create(area, scene);
550 
551  area->regionbase = slink->regionbase;
552 
553  BLI_addhead(&area->spacedata, slink);
555 }
556 
557 /* ****************** EXPORTED API TO OTHER MODULES *************************** */
558 
559 /* screen sets cursor based on active region */
560 static void region_cursor_set_ex(wmWindow *win, ScrArea *area, ARegion *region, bool swin_changed)
561 {
562  BLI_assert(WM_window_get_active_screen(win)->active_region == region);
563  if (win->tag_cursor_refresh || swin_changed || (region->type && region->type->event_cursor)) {
564  win->tag_cursor_refresh = false;
565  ED_region_cursor_set(win, area, region);
566  }
567 }
568 
569 static void region_cursor_set(wmWindow *win, bool swin_changed)
570 {
571  bScreen *screen = WM_window_get_active_screen(win);
572 
573  ED_screen_areas_iter (win, screen, area) {
574  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
575  if (region == screen->active_region) {
576  region_cursor_set_ex(win, area, region, swin_changed);
577  return;
578  }
579  }
580  }
581 }
582 
584 {
585  wmWindow *win = CTX_wm_window(C);
586  bScreen *screen = CTX_wm_screen(C);
587 
588  /* generic notes */
589  switch (note->category) {
590  case NC_WM:
591  if (note->data == ND_FILEREAD) {
592  screen->do_draw = true;
593  }
594  break;
595  case NC_WINDOW:
596  screen->do_draw = true;
597  break;
598  case NC_SCREEN:
599  if (note->action == NA_EDITED) {
600  screen->do_draw = screen->do_refresh = true;
601  }
602  break;
603  case NC_SCENE:
604  if (note->data == ND_MODE) {
605  region_cursor_set(win, true);
606  }
607  break;
608  }
609 }
610 
612 {
613  bScreen *screen = WM_window_get_active_screen(win);
614 
615  /* Exception for background mode, we only need the screen context. */
616  if (!G.background) {
617 
618  /* Called even when creating the ghost window fails in #WM_window_open. */
619  if (win->ghostwin) {
620  /* Header size depends on DPI, let's verify. */
621  WM_window_set_dpi(win);
622  }
623 
625 
626  screen_geom_vertices_scale(win, screen);
627 
628  ED_screen_areas_iter (win, screen, area) {
629  /* Set space-type and region callbacks, calls init() */
630  /* Sets sub-windows for regions, adds handlers. */
631  ED_area_init(wm, win, area);
632  }
633 
634  /* wake up animtimer */
635  if (screen->animtimer) {
636  WM_event_timer_sleep(wm, win, screen->animtimer, false);
637  }
638  }
639 
640  if (G.debug & G_DEBUG_EVENTS) {
641  printf("%s: set screen\n", __func__);
642  }
643  screen->do_refresh = false;
644  /* prevent multiwin errors */
645  screen->winid = win->winid;
646 
647  screen->context = ed_screen_context;
648 }
649 
651 {
652  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
653  if (BKE_workspace_active_get(win->workspace_hook) == NULL) {
654  BKE_workspace_active_set(win->workspace_hook, bmain->workspaces.first);
655  }
656 
657  ED_screen_refresh(wm, win);
658  if (win->eventstate) {
659  ED_screen_set_active_region(NULL, win, win->eventstate->xy);
660  }
661  }
662 
663  if (U.uiflag & USER_HEADER_FROM_PREF) {
664  LISTBASE_FOREACH (bScreen *, screen, &bmain->screens) {
666  }
667  }
668 }
669 
671 {
672  if (screen->do_refresh) {
673  ED_screen_refresh(wm, win);
674  }
675 }
676 
678 {
679  ED_region_exit(C, region);
680  BKE_area_region_free(area->type, region);
681  BLI_freelinkN(&area->regionbase, region);
682 }
683 
684 /* *********** exit calls are for closing running stuff ******** */
685 
687 {
689  wmWindow *win = CTX_wm_window(C);
690  ARegion *prevar = CTX_wm_region(C);
691 
692  if (region->type && region->type->exit) {
693  region->type->exit(wm, region);
694  }
695 
696  CTX_wm_region_set(C, region);
697 
700  WM_draw_region_free(region, true);
701 
702  MEM_SAFE_FREE(region->headerstr);
703 
704  if (region->regiontimer) {
705  WM_event_remove_timer(wm, win, region->regiontimer);
706  region->regiontimer = NULL;
707  }
708 
710 
711  CTX_wm_region_set(C, prevar);
712 }
713 
715 {
717  wmWindow *win = CTX_wm_window(C);
718  ScrArea *prevsa = CTX_wm_area(C);
719 
720  if (area->type && area->type->exit) {
721  area->type->exit(wm, area);
722  }
723 
725 
726  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
727  ED_region_exit(C, region);
728  }
729 
730  WM_event_remove_handlers(C, &area->handlers);
732 
733  CTX_wm_area_set(C, prevsa);
734 }
735 
736 void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
737 {
739  wmWindow *prevwin = CTX_wm_window(C);
740 
741  CTX_wm_window_set(C, window);
742 
743  if (screen->animtimer) {
744  WM_event_remove_timer(wm, window, screen->animtimer);
745 
748  Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
749  BKE_sound_stop_scene(scene_eval);
750  }
751  screen->animtimer = NULL;
752  screen->scrubbing = false;
753 
754  screen->active_region = NULL;
755 
756  LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
757  ED_region_exit(C, region);
758  }
759  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
760  ED_area_exit(C, area);
761  }
762  /* Don't use ED_screen_areas_iter here, it skips hidden areas. */
764  ED_area_exit(C, area);
765  }
766 
767  /* mark it available for use for other windows */
768  screen->winid = 0;
769 
770  if (!WM_window_is_temp_screen(prevwin)) {
771  /* use previous window if possible */
772  CTX_wm_window_set(C, prevwin);
773  }
774  else {
775  /* none otherwise */
777  }
778 }
779 
780 /* *********************************** */
781 
782 /* case when on area-edge or in azones, or outside window */
783 static void screen_cursor_set(wmWindow *win, const int xy[2])
784 {
785  const bScreen *screen = WM_window_get_active_screen(win);
786  AZone *az = NULL;
787  ScrArea *area = NULL;
788 
789  LISTBASE_FOREACH (ScrArea *, area_iter, &screen->areabase) {
790  az = ED_area_actionzone_find_xy(area_iter, xy);
791  /* Scrollers use default cursor and their zones extend outside of their
792  * areas. Ignore here so we can always detect screen edges - #110085. */
793  if (az && az->type != AZONE_REGION_SCROLL) {
794  area = area_iter;
795  break;
796  }
797  }
798 
799  if (area) {
800  if (az->type == AZONE_AREA) {
802  }
803  else if (az->type == AZONE_REGION) {
806  }
807  else {
809  }
810  }
811  }
812  else {
813  ScrEdge *actedge = screen_geom_find_active_scredge(win, screen, xy[0], xy[1]);
814 
815  if (actedge) {
816  if (screen_geom_edge_is_horizontal(actedge)) {
818  }
819  else {
821  }
822  }
823  else {
825  }
826  }
827 }
828 
830 {
831  bScreen *screen = WM_window_get_active_screen(win);
832  if (screen == NULL) {
833  return;
834  }
835 
836  ScrArea *area = NULL;
837  ARegion *region_prev = screen->active_region;
838 
839  ED_screen_areas_iter (win, screen, area_iter) {
840  if (xy[0] > (area_iter->totrct.xmin + BORDERPADDING) &&
841  xy[0] < (area_iter->totrct.xmax - BORDERPADDING)) {
842  if (xy[1] > (area_iter->totrct.ymin + BORDERPADDING) &&
843  xy[1] < (area_iter->totrct.ymax - BORDERPADDING)) {
844  if (ED_area_azones_update(area_iter, xy) == NULL) {
845  area = area_iter;
846  break;
847  }
848  }
849  }
850  }
851  if (area) {
852  /* Make overlap active when mouse over. */
853  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
854  if (ED_region_contains_xy(region, xy)) {
855  screen->active_region = region;
856  break;
857  }
858  }
859  }
860  else {
861  screen->active_region = NULL;
862  }
863 
864  /* Check for redraw headers. */
865  if (region_prev != screen->active_region) {
866 
867  ED_screen_areas_iter (win, screen, area_iter) {
868  bool do_draw = false;
869 
870  LISTBASE_FOREACH (ARegion *, region, &area_iter->regionbase) {
871  /* Call old area's deactivate if assigned. */
872  if (region == region_prev && area_iter->type->deactivate) {
873  area_iter->type->deactivate(area_iter);
874  }
875 
876  if (region == region_prev && region != screen->active_region) {
877  wmGizmoMap *gzmap = region_prev->gizmo_map;
878  if (gzmap) {
879  if (WM_gizmo_highlight_set(gzmap, NULL)) {
880  ED_region_tag_redraw_no_rebuild(region_prev);
881  }
882  }
883  }
884 
885  if (ELEM(region, region_prev, screen->active_region)) {
886  do_draw = true;
887  }
888  }
889 
890  if (do_draw) {
891  LISTBASE_FOREACH (ARegion *, region, &area_iter->regionbase) {
892  if (ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER)) {
894  }
895  }
896  }
897  }
898 
899  /* Ensure test-motion values are never shared between regions. */
900  const bool use_cycle = !WM_cursor_test_motion_and_update((const int[2]){-1, -1});
901  UNUSED_VARS(use_cycle);
902  }
903 
904  /* Cursors, for time being set always on edges,
905  * otherwise the active region doesn't switch. */
906  if (screen->active_region == NULL) {
907  screen_cursor_set(win, xy);
908  }
909  else {
910  /* Notifier invokes freeing the buttons... causing a bit too much redraws. */
911  region_cursor_set_ex(win, area, screen->active_region, region_prev != screen->active_region);
912 
913  if (region_prev != screen->active_region) {
914  /* This used to be a notifier, but needs to be done immediate
915  * because it can undo setting the right button as active due
916  * to delayed notifier handling. */
917  if (C) {
919  }
920  }
921  }
922 }
923 
925 {
926  wmWindow *win = CTX_wm_window(C);
927  bScreen *screen = CTX_wm_screen(C);
929 
930  if (win && screen && area) {
932 
933  if (az && az->type == AZONE_REGION) {
934  return 1;
935  }
936 
937  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
938  if (region == screen->active_region) {
939  return 1;
940  }
941  }
942  }
943  return 0;
944 }
945 
951  const rcti *rect,
952  eSpace_Type space_type)
953 {
954  ScrVert *bottom_left = screen_geom_vertex_add_ex(area_map, rect->xmin, rect->ymin);
955  ScrVert *top_left = screen_geom_vertex_add_ex(area_map, rect->xmin, rect->ymax);
956  ScrVert *top_right = screen_geom_vertex_add_ex(area_map, rect->xmax, rect->ymax);
957  ScrVert *bottom_right = screen_geom_vertex_add_ex(area_map, rect->xmax, rect->ymin);
958 
959  screen_geom_edge_add_ex(area_map, bottom_left, top_left);
960  screen_geom_edge_add_ex(area_map, top_left, top_right);
961  screen_geom_edge_add_ex(area_map, top_right, bottom_right);
962  screen_geom_edge_add_ex(area_map, bottom_right, bottom_left);
963 
964  return screen_addarea_ex(area_map, bottom_left, top_left, top_right, bottom_right, space_type);
965 }
966 
967 static void screen_area_set_geometry_rect(ScrArea *area, const rcti *rect)
968 {
969  area->v1->vec.x = rect->xmin;
970  area->v1->vec.y = rect->ymin;
971  area->v2->vec.x = rect->xmin;
972  area->v2->vec.y = rect->ymax;
973  area->v3->vec.x = rect->xmax;
974  area->v3->vec.y = rect->ymax;
975  area->v4->vec.x = rect->xmax;
976  area->v4->vec.y = rect->ymin;
977 }
978 
980  bScreen *screen,
981  const eSpace_Type space_type,
982  GlobalAreaAlign align,
983  const rcti *rect,
984  const short height_cur,
985  const short height_min,
986  const short height_max)
987 {
988  /* Full-screens shouldn't have global areas. Don't touch them. */
989  if (screen->state == SCREENFULL) {
990  return;
991  }
992 
993  ScrArea *area = NULL;
994  LISTBASE_FOREACH (ScrArea *, area_iter, &win->global_areas.areabase) {
995  if (area_iter->spacetype == space_type) {
996  area = area_iter;
997  break;
998  }
999  }
1000 
1001  if (area) {
1003  }
1004  else {
1005  area = screen_area_create_with_geometry(&win->global_areas, rect, space_type);
1007 
1008  /* Data specific to global areas. */
1009  area->global = MEM_callocN(sizeof(*area->global), __func__);
1010  area->global->size_max = height_max;
1011  area->global->size_min = height_min;
1012  area->global->align = align;
1013  }
1014 
1015  if (area->global->cur_fixed_height != height_cur) {
1016  /* Refresh layout if size changes. */
1017  area->global->cur_fixed_height = height_cur;
1018  screen->do_refresh = true;
1019  }
1020 }
1021 
1023 {
1024  return (int)ceilf(ED_area_headersize() / UI_DPI_FAC);
1025 }
1026 
1028 {
1029  const short size = screen_global_header_size();
1030  rcti rect;
1031 
1032  BLI_rcti_init(&rect, 0, WM_window_pixels_x(win) - 1, 0, WM_window_pixels_y(win) - 1);
1033  rect.ymin = rect.ymax - size;
1034 
1036  win, screen, SPACE_TOPBAR, GLOBAL_AREA_ALIGN_TOP, &rect, size, size, size);
1037 }
1038 
1040 {
1041  const short size_min = 1;
1042  const short size_max = 0.8f * screen_global_header_size();
1043  const short size = (screen->flag & SCREEN_COLLAPSE_STATUSBAR) ? size_min : size_max;
1044  rcti rect;
1045 
1046  BLI_rcti_init(&rect, 0, WM_window_pixels_x(win) - 1, 0, WM_window_pixels_y(win) - 1);
1047  rect.ymax = rect.ymin + size_max;
1048 
1050  win, screen, SPACE_STATUSBAR, GLOBAL_AREA_ALIGN_BOTTOM, &rect, size, size_min, size_max);
1051 }
1052 
1054 {
1055  /* Update screen flags from height in window, this is weak and perhaps
1056  * global areas should just become part of the screen instead. */
1058 
1059  screen->flag &= ~SCREEN_COLLAPSE_STATUSBAR;
1060 
1062  if (area->global->cur_fixed_height == area->global->size_min) {
1063  if (area->spacetype == SPACE_STATUSBAR) {
1064  screen->flag |= SCREEN_COLLAPSE_STATUSBAR;
1065  }
1066  }
1067  }
1068 }
1069 
1071 {
1072  /* Don't create global area for child and temporary windows. */
1074  if ((win->parent != NULL) || screen->temp) {
1075  if (win->global_areas.areabase.first) {
1076  screen->do_refresh = true;
1078  }
1079  return;
1080  }
1081 
1082  screen_global_topbar_area_refresh(win, screen);
1084 }
1085 
1086 /* -------------------------------------------------------------------- */
1087 /* Screen changing */
1088 
1090  bScreen *screen_old, bScreen *screen_new, Main *bmain, bContext *C, wmWindow *win)
1091 {
1092  UNUSED_VARS_NDEBUG(bmain);
1093  BLI_assert(BLI_findindex(&bmain->screens, screen_new) != -1);
1094 
1095  if (screen_old != screen_new) {
1096  wmTimer *wt = screen_old->animtimer;
1097 
1098  /* remove handlers referencing areas in old screen */
1099  LISTBASE_FOREACH (ScrArea *, area, &screen_old->areabase) {
1101  }
1102 
1103  /* we put timer to sleep, so screen_exit has to think there's no timer */
1104  screen_old->animtimer = NULL;
1105  if (wt) {
1106  WM_event_timer_sleep(CTX_wm_manager(C), win, wt, true);
1107  }
1108  ED_screen_exit(C, win, screen_old);
1109 
1110  /* Same scene, "transfer" playback to new screen. */
1111  if (wt) {
1112  screen_new->animtimer = wt;
1113  }
1114  }
1115 }
1116 
1118 {
1121  WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, screen);
1122 
1123  CTX_wm_window_set(C, win); /* stores C->wm.screen... hrmf */
1124 
1126 
1127  BKE_screen_view3d_scene_sync(screen, scene); /* sync new screen with scene data */
1130 
1131  /* Makes button highlights work. */
1133 }
1134 
1136 {
1137  Main *bmain = CTX_data_main(C);
1138  wmWindow *win = CTX_wm_window(C);
1140  WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, screen);
1141  bScreen *screen_old = CTX_wm_screen(C);
1142 
1143  /* Get the actual layout/screen to be activated (guaranteed to be unused, even if that means
1144  * having to duplicate an existing one). */
1146  bmain, workspace, layout, layout, win);
1147  bScreen *screen_new = BKE_workspace_layout_screen_get(layout_new);
1148 
1149  screen_change_prepare(screen_old, screen_new, bmain, C, win);
1150 
1151  if (screen_old != screen_new) {
1152  WM_window_set_active_screen(win, workspace, screen_new);
1153  screen_change_update(C, win, screen_new);
1154 
1155  return true;
1156  }
1157 
1158  return false;
1159 }
1160 
1162  ViewLayer *view_layer,
1163  ScrArea *area,
1164  View3D *v3d)
1165 {
1166  /* fix any cameras that are used in the 3d view but not in the scene */
1168 
1169  if (!v3d->camera || !BKE_view_layer_base_find(view_layer, v3d->camera)) {
1170  v3d->camera = BKE_view_layer_camera_find(view_layer);
1171  // XXX if (screen == curscreen) handle_view3d_lock();
1172  if (!v3d->camera) {
1173  ListBase *regionbase;
1174 
1175  /* regionbase is in different place depending if space is active */
1176  if (v3d == area->spacedata.first) {
1177  regionbase = &area->regionbase;
1178  }
1179  else {
1180  regionbase = &v3d->regionbase;
1181  }
1182 
1183  LISTBASE_FOREACH (ARegion *, region, regionbase) {
1184  if (region->regiontype == RGN_TYPE_WINDOW) {
1185  RegionView3D *rv3d = region->regiondata;
1186  if (rv3d->persp == RV3D_CAMOB) {
1187  rv3d->persp = RV3D_PERSP;
1188  }
1189  }
1190  }
1191  }
1192  }
1193 }
1194 
1196  wmWindow *win,
1197  Scene *scene,
1198  const bool refresh_toolsystem)
1199 {
1200 #if 0
1201  ViewLayer *view_layer_old = WM_window_get_active_view_layer(win);
1202 #endif
1203 
1204  /* Switch scene. */
1205  win->scene = scene;
1206  if (CTX_wm_window(C) == win) {
1208  }
1209 
1210  /* Ensure the view layer name is updated. */
1212  ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1213 
1214 #if 0
1215  /* Mode Syncing. */
1216  if (view_layer_old) {
1217  WorkSpace *workspace = CTX_wm_workspace(C);
1218  Object *obact_new = OBACT(view_layer);
1219  UNUSED_VARS(obact_new);
1220  eObjectMode object_mode_old = workspace->object_mode;
1221  Object *obact_old = OBACT(view_layer_old);
1222  UNUSED_VARS(obact_old, object_mode_old);
1223  }
1224 #endif
1225 
1226  /* Update 3D view cameras. */
1227  const bScreen *screen = WM_window_get_active_screen(win);
1228  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1229  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1230  if (sl->spacetype == SPACE_VIEW3D) {
1231  View3D *v3d = (View3D *)sl;
1232  screen_set_3dview_camera(scene, view_layer, area, v3d);
1233  }
1234  }
1235  }
1236 
1237  if (refresh_toolsystem) {
1239  }
1240 }
1241 
1243 {
1244  bScreen *newscreen = NULL;
1245  ScrArea *newsa = NULL;
1246  SpaceLink *newsl;
1247 
1248  if (!area || area->full == NULL) {
1249  newscreen = ED_screen_state_maximized_create(C);
1250  newsa = newscreen->areabase.first;
1251  BLI_assert(newsa->spacetype == SPACE_EMPTY);
1252  }
1253 
1254  if (!newsa) {
1255  newsa = area;
1256  }
1257 
1258  BLI_assert(newsa);
1259  newsl = newsa->spacedata.first;
1260 
1261  /* Tag the active space before changing, so we can identify it when user wants to go back. */
1262  if (newsl && (newsl->link_flag & SPACE_FLAG_TYPE_TEMPORARY) == 0) {
1264  }
1265 
1266  ED_area_newspace(C, newsa, type, (newsl && newsl->link_flag & SPACE_FLAG_TYPE_TEMPORARY));
1267 
1268  if (newscreen) {
1269  ED_screen_change(C, newscreen);
1270  }
1271 
1272  return newsa;
1273 }
1274 
1276 {
1277  BLI_assert(area->full);
1278 
1279  if (area->flag & AREA_FLAG_STACKED_FULLSCREEN) {
1280  /* stacked fullscreen -> only go back to previous area and don't toggle out of fullscreen */
1282  }
1283  else {
1285  }
1286 }
1287 
1289 {
1290  SpaceLink *sl = area->spacedata.first;
1291 
1292  /* In case nether functions below run. */
1294 
1297  }
1298 
1299  if (area->full) {
1301  }
1302 }
1303 
1305 {
1306  wmWindow *win = CTX_wm_window(C);
1307  SpaceLink *sl = area->spacedata.first;
1308  bScreen *screen = CTX_wm_screen(C);
1309  short state = (screen ? screen->state : SCREENMAXIMIZED);
1310 
1311  /* if fullscreen area has a temporary space (such as a file browser or fullscreen render
1312  * overlaid on top of an existing setup) then return to the previous space */
1313 
1314  if (sl->next) {
1317  }
1318  else {
1320  }
1321  /* WARNING: 'area' may be freed */
1322  }
1323  /* otherwise just tile the area again */
1324  else {
1326  }
1327 }
1328 
1339  wmWindow *win,
1340  ScrArea *toggle_area,
1341  int state)
1342 {
1343  Main *bmain = CTX_data_main(C);
1344  WorkSpace *workspace = WM_window_get_active_workspace(win);
1345 
1346  /* change from SCREENNORMAL to new state */
1347  WorkSpaceLayout *layout_new;
1348  ScrArea *newa;
1349  char newname[MAX_ID_NAME - 2];
1350 
1352 
1353  bScreen *oldscreen = WM_window_get_active_screen(win);
1354 
1355  oldscreen->state = state;
1356  BLI_snprintf(newname, sizeof(newname), "%s-%s", oldscreen->id.name + 2, "nonnormal");
1357 
1358  layout_new = ED_workspace_layout_add(bmain, workspace, win, newname);
1359 
1360  bScreen *screen = BKE_workspace_layout_screen_get(layout_new);
1361  screen->state = state;
1362  screen->redraws_flag = oldscreen->redraws_flag;
1363  screen->temp = oldscreen->temp;
1364  screen->flag = oldscreen->flag;
1365 
1366  /* timer */
1367  screen->animtimer = oldscreen->animtimer;
1368  oldscreen->animtimer = NULL;
1369 
1370  newa = (ScrArea *)screen->areabase.first;
1371 
1372  /* swap area */
1373  if (toggle_area) {
1374  ED_area_data_swap(newa, toggle_area);
1375  newa->flag = toggle_area->flag; /* mostly for AREA_FLAG_WASFULLSCREEN */
1376  }
1377 
1378  if (state == SCREENFULL) {
1379  /* temporarily hide global areas */
1380  LISTBASE_FOREACH (ScrArea *, glob_area, &win->global_areas.areabase) {
1381  glob_area->global->flag |= GLOBAL_AREA_IS_HIDDEN;
1382  }
1383  /* temporarily hide the side panels/header */
1384  LISTBASE_FOREACH (ARegion *, region, &newa->regionbase) {
1385  region->flagfullscreen = region->flag;
1386 
1387  if (ELEM(region->regiontype,
1388  RGN_TYPE_UI,
1394  RGN_TYPE_EXECUTE)) {
1395  region->flag |= RGN_FLAG_HIDDEN;
1396  }
1397  }
1398  }
1399 
1400  if (toggle_area) {
1401  toggle_area->full = oldscreen;
1402  }
1403  newa->full = oldscreen;
1404 
1405  ED_area_tag_refresh(newa);
1406 
1407  return screen;
1408 }
1409 
1411 {
1413 }
1414 
1416 {
1418  WorkSpace *workspace = WM_window_get_active_workspace(win);
1419 
1420  if (area) {
1421  /* ensure we don't have a button active anymore, can crash when
1422  * switching screens with tooltip open because region and tooltip
1423  * are no longer in the same screen */
1424  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1425  UI_blocklist_free(C, region);
1426  if (region->regiontimer) {
1427  WM_event_remove_timer(wm, NULL, region->regiontimer);
1428  region->regiontimer = NULL;
1429  }
1430  }
1431 
1432  /* prevent hanging status prints */
1435  }
1436  bScreen *screen;
1437  if (area && area->full) {
1438  WorkSpaceLayout *layout_old = WM_window_get_active_layout(win);
1439  /* restoring back to SCREENNORMAL */
1440  screen = area->full; /* the old screen to restore */
1441  bScreen *oldscreen = WM_window_get_active_screen(win); /* the one disappearing */
1442 
1443  BLI_assert(BKE_workspace_layout_screen_get(layout_old) != screen);
1445 
1446  screen->state = SCREENNORMAL;
1447  screen->flag = oldscreen->flag;
1448 
1449  /* Find old area we may have swapped dummy space data to. It's swapped back here. */
1450  ScrArea *fullsa = NULL;
1451  LISTBASE_FOREACH (ScrArea *, old, &screen->areabase) {
1452  /* area to restore from is always first */
1453  if (old->full && !fullsa) {
1454  fullsa = old;
1455  }
1456 
1457  /* clear full screen state */
1458  old->full = NULL;
1459  }
1460 
1461  area->full = NULL;
1462 
1463  if (state == SCREENFULL) {
1464  /* unhide global areas */
1465  LISTBASE_FOREACH (ScrArea *, glob_area, &win->global_areas.areabase) {
1466  glob_area->global->flag &= ~GLOBAL_AREA_IS_HIDDEN;
1467  }
1468  /* restore the old side panels/header visibility */
1469  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1470  region->flag = region->flagfullscreen;
1471  }
1472  }
1473 
1474  if (fullsa) {
1475  ED_area_data_swap(fullsa, area);
1476  ED_area_tag_refresh(fullsa);
1477  }
1478 
1479  /* animtimer back */
1480  screen->animtimer = oldscreen->animtimer;
1481  oldscreen->animtimer = NULL;
1482 
1483  ED_screen_change(C, screen);
1484 
1485  BKE_workspace_layout_remove(CTX_data_main(C), workspace, layout_old);
1486 
1487  /* After we've restored back to SCREENNORMAL, we have to wait with
1488  * screen handling as it uses the area coords which aren't updated yet.
1489  * Without doing so, the screen handling gets wrong area coords,
1490  * which in worst case can lead to crashes (see T43139) */
1491  screen->skip_handling = true;
1492  }
1493  else {
1494  ScrArea *toggle_area = area;
1495 
1496  /* use random area when we have no active one, e.g. when the
1497  * mouse is outside of the window and we open a file browser */
1498  if (!toggle_area || toggle_area->global) {
1499  bScreen *oldscreen = WM_window_get_active_screen(win);
1500  toggle_area = oldscreen->areabase.first;
1501  }
1502 
1503  screen = screen_state_to_nonnormal(C, win, toggle_area, state);
1504 
1505  ED_screen_change(C, screen);
1506  }
1507 
1508  BLI_assert(CTX_wm_screen(C) == screen);
1509  BLI_assert(CTX_wm_area(C) == NULL); /* May have been freed. */
1510 
1511  /* Setting the area is only needed for Python scripts that call
1512  * operators in succession before returning to the main event loop.
1513  * Without this, scripts can't run any operators that require
1514  * an area after toggling full-screen for example (see: T89526).
1515  * NOTE: an old comment stated this was "bad code",
1516  * however it doesn't cause problems so leave as-is. */
1517  CTX_wm_area_set(C, screen->areabase.first);
1518 
1519  return screen->areabase.first;
1520 }
1521 
1523  const char *title,
1524  int x,
1525  int y,
1526  int sizex,
1527  int sizey,
1528  eSpace_Type space_type,
1529  int display_type,
1530  bool dialog)
1531 {
1532  ScrArea *area = NULL;
1533 
1534  switch (display_type) {
1536  if (WM_window_open(C,
1537  title,
1538  x,
1539  y,
1540  sizex,
1541  sizey,
1542  (int)space_type,
1543  false,
1544  dialog,
1545  true,
1547  area = CTX_wm_area(C);
1548  }
1549  break;
1551  ScrArea *ctx_area = CTX_wm_area(C);
1552 
1553  if (ctx_area != NULL && ctx_area->full) {
1554  area = ctx_area;
1555  ED_area_newspace(C, ctx_area, space_type, true);
1557  ((SpaceLink *)area->spacedata.first)->link_flag |= SPACE_FLAG_TYPE_TEMPORARY;
1558  }
1559  else {
1560  area = ED_screen_full_newspace(C, ctx_area, (int)space_type);
1561  ((SpaceLink *)area->spacedata.first)->link_flag |= SPACE_FLAG_TYPE_TEMPORARY;
1562  }
1563  break;
1564  }
1565  }
1566 
1567  return area;
1568 }
1569 
1571 {
1572  wmTimer *animtimer = CTX_wm_screen(C)->animtimer;
1574 
1575  /* is anim playback running? */
1576  if (animtimer && (U.uiflag & USER_SHOW_FPS)) {
1578 
1579  /* if there isn't any info, init it first */
1580  if (fpsi == NULL) {
1581  fpsi = scene->fps_info = MEM_callocN(sizeof(ScreenFrameRateInfo),
1582  "refresh_viewport_fps fps_info");
1583  }
1584 
1585  /* update the values */
1586  fpsi->redrawtime = fpsi->lredrawtime;
1587  fpsi->lredrawtime = animtimer->ltime;
1588  }
1589  else {
1590  /* playback stopped or shouldn't be running */
1592  }
1593 }
1594 
1595 void ED_screen_animation_timer(bContext *C, int redraws, int sync, int enable)
1596 {
1597  bScreen *screen = CTX_wm_screen(C);
1599  wmWindow *win = CTX_wm_window(C);
1601  bScreen *stopscreen = ED_screen_animation_playing(wm);
1602 
1603  if (stopscreen) {
1604  WM_event_remove_timer(wm, win, stopscreen->animtimer);
1605  stopscreen->animtimer = NULL;
1606  }
1607 
1608  if (enable) {
1609  ScreenAnimData *sad = MEM_callocN(sizeof(ScreenAnimData), "ScreenAnimData");
1610 
1611  screen->animtimer = WM_event_add_timer(wm, win, TIMER0, (1.0 / FPS));
1612 
1613  sad->region = CTX_wm_region(C);
1614  /* If start-frame is larger than current frame, we put current-frame on start-frame.
1615  * NOTE(ton): first frame then is not drawn! */
1616  if (PRVRANGEON) {
1617  if (scene->r.psfra > scene->r.cfra) {
1618  sad->sfra = scene->r.cfra;
1619  scene->r.cfra = scene->r.psfra;
1620  }
1621  else {
1622  sad->sfra = scene->r.cfra;
1623  }
1624  }
1625  else {
1626  if (scene->r.sfra > scene->r.cfra) {
1627  sad->sfra = scene->r.cfra;
1628  scene->r.cfra = scene->r.sfra;
1629  }
1630  else {
1631  sad->sfra = scene->r.cfra;
1632  }
1633  }
1634  sad->redraws = redraws;
1635  sad->flag |= (enable < 0) ? ANIMPLAY_FLAG_REVERSE : 0;
1636  sad->flag |= (sync == 0) ? ANIMPLAY_FLAG_NO_SYNC : (sync == 1) ? ANIMPLAY_FLAG_SYNC : 0;
1637 
1638  ScrArea *area = CTX_wm_area(C);
1639 
1640  char spacetype = -1;
1641 
1642  if (area) {
1643  spacetype = area->spacetype;
1644  }
1645 
1646  sad->from_anim_edit = (ELEM(spacetype, SPACE_GRAPH, SPACE_ACTION, SPACE_NLA));
1647 
1648  screen->animtimer->customdata = sad;
1649  }
1650 
1651  /* Seek audio to ensure playback in preview range with AV sync. */
1653 
1654  /* Notifier caught by top header, for button. */
1656 }
1657 
1658 /* helper for screen_animation_play() - only to be used for TimeLine */
1660 {
1661  ARegion *region_top_left = NULL;
1662  int min = 10000;
1663 
1664  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1665  if (area->spacetype == SPACE_VIEW3D) {
1666  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1667  if (region->regiontype == RGN_TYPE_WINDOW) {
1668  if (region->winrct.xmin - region->winrct.ymin < min) {
1669  region_top_left = region;
1670  min = region->winrct.xmin - region->winrct.ymin;
1671  }
1672  }
1673  }
1674  }
1675  }
1676 
1677  return region_top_left;
1678 }
1679 
1680 void ED_screen_animation_timer_update(bScreen *screen, int redraws)
1681 {
1682  if (screen && screen->animtimer) {
1683  wmTimer *wt = screen->animtimer;
1684  ScreenAnimData *sad = wt->customdata;
1685 
1686  sad->redraws = redraws;
1687  sad->region = NULL;
1688  if (redraws & TIME_REGION) {
1689  sad->region = time_top_left_3dwindow(screen);
1690  }
1691  }
1692 }
1693 
1695 {
1697 
1698  DEG_time_tag_update(bmain);
1699 
1700 #ifdef DURIAN_CAMERA_SWITCH
1701  void *camera = BKE_scene_camera_switch_find(scene);
1702  if (camera && scene->camera != camera) {
1703  scene->camera = camera;
1704  /* are there cameras in the views that are not in the scene? */
1705  LISTBASE_FOREACH (bScreen *, screen, &bmain->screens) {
1707  }
1709  }
1710 #endif
1711 
1712  ED_clip_update_frame(bmain, scene->r.cfra);
1713 
1714  /* this function applies the changes too */
1716 }
1717 
1718 bool ED_screen_stereo3d_required(const bScreen *screen, const Scene *scene)
1719 {
1720  const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
1721 
1722  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1723  switch (area->spacetype) {
1724  case SPACE_VIEW3D: {
1725  View3D *v3d;
1726 
1727  if (!is_multiview) {
1728  continue;
1729  }
1730 
1731  v3d = area->spacedata.first;
1732  if (v3d->camera && v3d->stereo3d_camera == STEREO_3D_ID) {
1733  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1734  if (region->regiondata && region->regiontype == RGN_TYPE_WINDOW) {
1735  RegionView3D *rv3d = region->regiondata;
1736  if (rv3d->persp == RV3D_CAMOB) {
1737  return true;
1738  }
1739  }
1740  }
1741  }
1742  break;
1743  }
1744  case SPACE_IMAGE: {
1745  SpaceImage *sima;
1746 
1747  /* images should always show in stereo, even if
1748  * the file doesn't have views enabled */
1749  sima = area->spacedata.first;
1750  if (sima->image && BKE_image_is_stereo(sima->image) &&
1751  (sima->iuser.flag & IMA_SHOW_STEREO)) {
1752  return true;
1753  }
1754  break;
1755  }
1756  case SPACE_NODE: {
1757  SpaceNode *snode;
1758 
1759  if (!is_multiview) {
1760  continue;
1761  }
1762 
1763  snode = area->spacedata.first;
1764  if ((snode->flag & SNODE_BACKDRAW) && ED_node_is_compositor(snode)) {
1765  return true;
1766  }
1767  break;
1768  }
1769  case SPACE_SEQ: {
1770  SpaceSeq *sseq;
1771 
1772  if (!is_multiview) {
1773  continue;
1774  }
1775 
1776  sseq = area->spacedata.first;
1778  return true;
1779  }
1780 
1781  if (sseq->draw_flag & SEQ_DRAW_BACKDROP) {
1782  return true;
1783  }
1784 
1785  break;
1786  }
1787  }
1788  }
1789 
1790  return false;
1791 }
1792 
1794  const wmWindowManager *wm,
1795  struct wmWindow **r_window)
1796 {
1797  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
1798  if (WM_window_get_active_screen(win) == screen) {
1799  if (r_window) {
1800  *r_window = win;
1801  }
1802  return WM_window_get_active_scene(win);
1803  }
1804  }
1805 
1806  /* Can by NULL when accessing a screen that isn't active. */
1807  return NULL;
1808 }
1809 
1811  const SpaceLink *sl,
1812  const bool only_visible)
1813 {
1814  if (only_visible) {
1815  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1816  if (area->spacedata.first == sl) {
1817  return area;
1818  }
1819  }
1820  }
1821  else {
1822  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1823  if (BLI_findindex(&area->spacedata, sl) != -1) {
1824  return area;
1825  }
1826  }
1827  }
1828  return NULL;
1829 }
1830 
1832 {
1833  return ED_screen_scene_find_with_window(screen, wm, NULL);
1834 }
1835 
1837 {
1838  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
1839  if (WM_window_get_active_screen(win) == screen) {
1840  return win;
1841  }
1842  }
1843  return NULL;
1844 }
typedef float(TangentPoint)[2]
struct WorkSpace * CTX_wm_workspace(const bContext *C)
Definition: context.c:728
struct ScrArea * CTX_wm_area(const bContext *C)
Definition: context.c:738
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
void CTX_wm_region_set(bContext *C, struct ARegion *region)
Definition: context.c:1009
void CTX_data_scene_set(bContext *C, struct Scene *scene)
Definition: context.c:1271
struct wmWindowManager * CTX_wm_manager(const bContext *C)
Definition: context.c:713
struct bScreen * CTX_wm_screen(const bContext *C)
Definition: context.c:733
void CTX_wm_window_set(bContext *C, struct wmWindow *win)
Definition: context.c:966
struct ARegion * CTX_wm_region(const bContext *C)
Definition: context.c:749
struct Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
Definition: context.c:1505
void CTX_wm_area_set(bContext *C, struct ScrArea *area)
Definition: context.c:997
struct Main * CTX_data_main(const bContext *C)
Definition: context.c:1074
struct wmWindow * CTX_wm_window(const bContext *C)
Definition: context.c:723
@ G_DEBUG_EVENTS
Definition: BKE_global.h:177
void BKE_icon_changed(int icon_id)
Definition: icons.cc:637
bool BKE_image_is_stereo(const struct Image *ima)
struct Object * BKE_view_layer_camera_find(struct ViewLayer *view_layer)
Definition: layer.c:311
struct Base * BKE_view_layer_base_find(struct ViewLayer *view_layer, struct Object *ob)
Definition: layer.c:379
void * BKE_libblock_alloc(struct Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition: lib_id.c:1050
void BKE_scene_graph_update_for_newframe(struct Depsgraph *depsgraph)
Definition: scene.cc:2728
void BKE_screen_area_free(struct ScrArea *area)
Definition: screen.c:670
void BKE_screen_free_data(struct bScreen *screen)
Definition: screen.c:697
void BKE_screen_view3d_sync(struct View3D *v3d, struct Scene *scene)
Definition: screen.c:976
void BKE_screen_area_map_free(struct ScrAreaMap *area_map) ATTR_NONNULL()
Definition: screen.c:686
void BKE_screen_remove_double_scredges(struct bScreen *screen)
Definition: screen.c:777
void BKE_screen_remove_unused_scredges(struct bScreen *screen)
Definition: screen.c:793
void BKE_area_region_free(struct SpaceType *st, struct ARegion *region)
Definition: screen.c:626
void BKE_screen_view3d_scene_sync(struct bScreen *screen, struct Scene *scene)
Definition: screen.c:994
void BKE_screen_sort_scrvert(struct ScrVert **v1, struct ScrVert **v2)
Definition: screen.c:716
struct SpaceType * BKE_spacetype_from_id(int spaceid)
Definition: screen.c:353
void BKE_screen_header_alignment_reset(struct bScreen *screen)
Definition: screen.c:1047
void BKE_screen_remove_double_scrverts(struct bScreen *screen)
Definition: screen.c:725
void BKE_sound_stop_scene(struct Scene *scene)
void BKE_workspace_layout_remove(struct Main *bmain, struct WorkSpace *workspace, struct WorkSpaceLayout *layout) ATTR_NONNULL()
Definition: workspace.c:383
struct WorkSpace * BKE_workspace_active_get(struct WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition: workspace.c:516
struct bScreen * BKE_workspace_active_screen_get(const struct WorkSpaceInstanceHook *hook) GETTER_ATTRS
void BKE_workspace_active_set(struct WorkSpaceInstanceHook *hook, struct WorkSpace *workspace) SETTER_ATTRS
Definition: workspace.c:520
struct bScreen * BKE_workspace_layout_screen_get(const struct WorkSpaceLayout *layout) GETTER_ATTRS
struct WorkSpaceLayout * BKE_workspace_layout_find(const struct WorkSpace *workspace, const struct bScreen *screen) ATTR_NONNULL() ATTR_WARN_UNUSED_RESULT
#define BLI_assert(a)
Definition: BLI_assert.h:46
void BLI_addhead(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:60
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void BLI_freelinkN(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:239
void void void void void BLI_duplicatelist(struct ListBase *dst, const struct ListBase *src) ATTR_NONNULL(1
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
Definition: rct.c:417
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define UNUSED_VARS(...)
#define UNUSED_VARS_NDEBUG(...)
#define MAX2(a, b)
#define ELEM(...)
#define MIN2(a, b)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
void DEG_time_tag_update(struct Main *bmain)
void DEG_id_tag_update(struct ID *id, int flag)
struct Scene * DEG_get_input_scene(const Depsgraph *graph)
struct ID * DEG_get_evaluated_id(const struct Depsgraph *depsgraph, struct ID *id)
@ ID_RECALC_COPY_ON_WRITE
Definition: DNA_ID.h:834
@ ID_RECALC_FRAME_CHANGE
Definition: DNA_ID.h:841
#define MAX_ID_NAME
Definition: DNA_ID.h:337
@ ID_SCR
Definition: DNA_ID_enums.h:60
#define IMA_SHOW_STEREO
eObjectMode
Object is a sort of wrapper for general info.
#define R_MULTIVIEW
#define OBACT(_view_layer)
@ STEREO_3D_ID
#define FPS
#define PRVRANGEON
@ AREA_FLAG_STACKED_FULLSCREEN
@ RGN_FLAG_HIDDEN
@ SCREENFULL
@ SCREENMAXIMIZED
@ SCREENNORMAL
#define AREAMAP_FROM_SCREEN(screen)
@ GLOBAL_AREA_IS_HIDDEN
@ RGN_TYPE_TOOL_HEADER
@ RGN_TYPE_EXECUTE
@ RGN_TYPE_UI
@ RGN_TYPE_WINDOW
@ RGN_TYPE_NAV_BAR
@ RGN_TYPE_FOOTER
@ RGN_TYPE_HEADER
@ RGN_TYPE_TOOLS
@ SCREEN_COLLAPSE_STATUSBAR
@ TIME_REGION
@ TIME_ALL_3D_WIN
@ TIME_ALL_ANIM_WIN
GlobalAreaAlign
@ GLOBAL_AREA_ALIGN_BOTTOM
@ GLOBAL_AREA_ALIGN_TOP
@ SNODE_BACKDRAW
eSpace_Type
@ SPACE_ACTION
@ SPACE_STATUSBAR
@ SPACE_TOPBAR
@ SPACE_NODE
@ SPACE_NLA
@ SPACE_SEQ
@ SPACE_EMPTY
@ SPACE_IMAGE
@ SPACE_GRAPH
@ SPACE_VIEW3D
@ SPACE_FLAG_TYPE_WAS_ACTIVE
@ SPACE_FLAG_TYPE_TEMPORARY
@ SEQ_VIEW_SEQUENCE_PREVIEW
@ SEQ_VIEW_PREVIEW
@ SEQ_DRAW_BACKDROP
@ USER_SHOW_FPS
@ USER_HEADER_FROM_PREF
@ USER_TEMP_SPACE_DISPLAY_FULLSCREEN
@ USER_TEMP_SPACE_DISPLAY_WINDOW
#define RV3D_CAMOB
#define RV3D_PERSP
void ED_clip_update_frame(const struct Main *mainp, int cfra)
bool ED_node_is_compositor(struct SpaceNode *snode)
Definition: node_edit.cc:466
void ED_area_tag_redraw(ScrArea *area)
Definition: area.c:729
struct WorkSpaceLayout * ED_workspace_layout_add(struct Main *bmain, struct WorkSpace *workspace, struct wmWindow *win, const char *name) ATTR_NONNULL()
void ED_region_cursor_set(struct wmWindow *win, struct ScrArea *area, struct ARegion *region)
Definition: area.c:2067
#define ED_screen_verts_iter(win, screen, vert_name)
Definition: ED_screen.h:270
#define ED_screen_areas_iter(win, screen, area_name)
Definition: ED_screen.h:267
void ED_area_status_text(ScrArea *area, const char *str)
Definition: area.c:792
void ED_area_prevspace(struct bContext *C, ScrArea *area)
Definition: area.c:2567
struct WorkSpaceLayout * ED_workspace_screen_change_ensure_unused_layout(struct Main *bmain, struct WorkSpace *workspace, struct WorkSpaceLayout *layout_new, const struct WorkSpaceLayout *layout_fallback_base, struct wmWindow *win) ATTR_NONNULL()
int ED_area_headersize(void)
Definition: area.c:3422
void ED_region_tag_redraw_no_rebuild(struct ARegion *region)
Definition: area.c:674
struct AZone * ED_area_azones_update(ScrArea *area, const int mouse_xy[2])
Definition: screen_ops.c:974
bScreen * ED_screen_animation_playing(const struct wmWindowManager *wm)
void ED_area_tag_refresh(ScrArea *area)
Definition: area.c:758
void ED_area_newspace(struct bContext *C, ScrArea *area, int type, bool skip_region_exit)
Definition: area.c:2427
void ED_area_init(struct wmWindowManager *wm, struct wmWindow *win, struct ScrArea *area)
Definition: area.c:1902
bool ED_region_contains_xy(const struct ARegion *region, const int event_xy[2])
void ED_workspace_status_text(struct bContext *C, const char *str)
Definition: area.c:816
@ AZONE_REGION
@ AZONE_REGION_SCROLL
@ AZONE_AREA
@ ANIMPLAY_FLAG_NO_SYNC
@ ANIMPLAY_FLAG_REVERSE
@ ANIMPLAY_FLAG_SYNC
@ AE_LEFT_TO_TOPRIGHT
@ AE_RIGHT_TO_TOPLEFT
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint y
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble right
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble top
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble bottom
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera
#define C
Definition: RandGen.cpp:25
void UI_blocklist_free(const struct bContext *C, struct ARegion *region)
#define UI_DPI_FAC
Definition: UI_interface.h:305
void UI_screen_free_active_but_highlight(const struct bContext *C, struct bScreen *screen)
@ WIN_ALIGN_LOCATION_CENTER
Definition: WM_api.h:218
#define NC_WINDOW
Definition: WM_types.h:325
#define ND_FILEREAD
Definition: WM_types.h:360
#define NC_WM
Definition: WM_types.h:324
#define NC_SCREEN
Definition: WM_types.h:327
#define ND_MODE
Definition: WM_types.h:393
#define ND_ANIMPLAY
Definition: WM_types.h:372
#define NC_SCENE
Definition: WM_types.h:328
#define NA_EDITED
Definition: WM_types.h:523
#define ND_LAYOUTSET
Definition: WM_types.h:374
void ED_area_data_copy(ScrArea *area_dst, ScrArea *area_src, const bool do_free)
Definition: area.c:2122
void ED_area_data_swap(ScrArea *area_dst, ScrArea *area_src)
Definition: area.c:2155
__forceinline BoundBox merge(const BoundBox &bbox, const float3 &pt)
Definition: boundbox.h:161
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
unsigned int U
Definition: btGjkEpa3.h:78
StackEntry * from
Scene scene
const Depsgraph * depsgraph
const int state
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
static int left
#define G(x, y, z)
#define ceilf(x)
Definition: metal/compat.h:225
static void area(int d1, int d2, int e1, int e2, float weights[2])
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
Definition: abc_util.cc:92
T abs(const T &a)
int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
static ScrArea * screen_addarea(bScreen *screen, ScrVert *left_bottom, ScrVert *left_top, ScrVert *right_top, ScrVert *right_bottom, const eSpace_Type space_type)
Definition: screen_edit.c:70
Scene * ED_screen_scene_find_with_window(const bScreen *screen, const wmWindowManager *wm, struct wmWindow **r_window)
Definition: screen_edit.c:1793
Scene * ED_screen_scene_find(const bScreen *screen, const wmWindowManager *wm)
Definition: screen_edit.c:1831
static bScreen * screen_state_to_nonnormal(bContext *C, wmWindow *win, ScrArea *toggle_area, int state)
Definition: screen_edit.c:1338
void ED_screen_global_areas_sync(wmWindow *win)
Definition: screen_edit.c:1053
int ED_screen_area_active(const bContext *C)
Definition: screen_edit.c:924
bool ED_screen_stereo3d_required(const bScreen *screen, const Scene *scene)
Definition: screen_edit.c:1718
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)
Definition: screen_edit.c:979
static void screen_set_3dview_camera(Scene *scene, ViewLayer *view_layer, ScrArea *area, View3D *v3d)
Definition: screen_edit.c:1161
ScrArea * ED_screen_area_find_with_spacedata(const bScreen *screen, const SpaceLink *sl, const bool only_visible)
Definition: screen_edit.c:1810
ScrArea * ED_screen_temp_space_open(bContext *C, const char *title, int x, int y, int sizex, int sizey, eSpace_Type space_type, int display_type, bool dialog)
Definition: screen_edit.c:1522
static void screen_area_set_geometry_rect(ScrArea *area, const rcti *rect)
Definition: screen_edit.c:967
void screen_change_prepare(bScreen *screen_old, bScreen *screen_new, Main *bmain, bContext *C, wmWindow *win)
Definition: screen_edit.c:1089
static int screen_global_header_size(void)
Definition: screen_edit.c:1022
void screen_new_activate_prepare(const wmWindow *win, bScreen *screen_new)
Definition: screen_edit.c:258
bool screen_area_close(struct bContext *C, bScreen *screen, ScrArea *area)
Definition: screen_edit.c:514
void area_getoffsets(ScrArea *sa_a, ScrArea *sa_b, const eScreenDir dir, int *r_offset1, int *r_offset2)
Definition: screen_edit.c:305
static void region_cursor_set(wmWindow *win, bool swin_changed)
Definition: screen_edit.c:569
void ED_screen_full_restore(bContext *C, ScrArea *area)
Definition: screen_edit.c:1304
static void screen_verts_halign(const wmWindow *win, const bScreen *screen, const short from_x, const short to_x)
Definition: screen_edit.c:336
void ED_refresh_viewport_fps(bContext *C)
Definition: screen_edit.c:1570
ScrArea * ED_screen_full_newspace(bContext *C, ScrArea *area, int type)
Definition: screen_edit.c:1242
bScreen * ED_screen_state_maximized_create(bContext *C)
Definition: screen_edit.c:1410
static ScrArea * screen_area_trim(bContext *C, bScreen *screen, ScrArea **area, int size, eScreenDir dir, bool reverse)
Definition: screen_edit.c:452
eScreenDir area_getorientation(ScrArea *sa_a, ScrArea *sa_b)
Definition: screen_edit.c:265
static void screen_global_statusbar_area_refresh(wmWindow *win, bScreen *screen)
Definition: screen_edit.c:1039
int screen_area_join(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
Definition: screen_edit.c:509
wmWindow * ED_screen_window_find(const bScreen *screen, const wmWindowManager *wm)
Definition: screen_edit.c:1836
void ED_screen_do_listen(bContext *C, wmNotifier *note)
Definition: screen_edit.c:583
static bool screen_area_join_ex(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2, bool close_all_remainders)
Definition: screen_edit.c:478
static void screen_delarea(bContext *C, bScreen *screen, ScrArea *area)
Definition: screen_edit.c:81
ScrArea * area_split(const wmWindow *win, bScreen *screen, ScrArea *area, const eScreenAxis dir_axis, const float fac, const bool merge)
Definition: screen_edit.c:92
void ED_screen_global_areas_refresh(wmWindow *win)
Definition: screen_edit.c:1070
void ED_screen_refresh(wmWindowManager *wm, wmWindow *win)
Definition: screen_edit.c:611
bool ED_screen_change(bContext *C, bScreen *screen)
Change the active screen.
Definition: screen_edit.c:1135
void ED_screen_animation_timer(bContext *C, int redraws, int sync, int enable)
Definition: screen_edit.c:1595
void ED_screen_restore_temp_type(bContext *C, ScrArea *area)
Definition: screen_edit.c:1288
static bool screen_area_join_aligned(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2)
Definition: screen_edit.c:399
void screen_change_update(bContext *C, wmWindow *win, bScreen *screen)
Definition: screen_edit.c:1117
ScrArea * ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *area, const short state)
Definition: screen_edit.c:1415
static void screen_areas_align(bContext *C, bScreen *screen, ScrArea *sa1, ScrArea *sa2, const eScreenDir dir)
Definition: screen_edit.c:365
static void screen_verts_valign(const wmWindow *win, const bScreen *screen, const short from_y, const short to_y)
Definition: screen_edit.c:350
void ED_screen_exit(bContext *C, wmWindow *window, bScreen *screen)
Definition: screen_edit.c:736
void ED_screen_ensure_updated(wmWindowManager *wm, wmWindow *win, bScreen *screen)
Definition: screen_edit.c:670
void ED_area_exit(bContext *C, ScrArea *area)
Definition: screen_edit.c:714
static void screen_global_topbar_area_refresh(wmWindow *win, bScreen *screen)
Definition: screen_edit.c:1027
void ED_screens_init(Main *bmain, wmWindowManager *wm)
Definition: screen_edit.c:650
void ED_screen_animation_timer_update(bScreen *screen, int redraws)
Definition: screen_edit.c:1680
void ED_screen_set_active_region(bContext *C, wmWindow *win, const int xy[2])
Definition: screen_edit.c:829
void screen_area_spacelink_add(Scene *scene, ScrArea *area, eSpace_Type space_type)
Definition: screen_edit.c:546
void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
Definition: screen_edit.c:1694
static void screen_cursor_set(wmWindow *win, const int xy[2])
Definition: screen_edit.c:783
void screen_data_copy(bScreen *to, bScreen *from)
Definition: screen_edit.c:212
void ED_screen_scene_change(bContext *C, wmWindow *win, Scene *scene, const bool refresh_toolsystem)
Definition: screen_edit.c:1195
bScreen * screen_add(Main *bmain, const char *name, const rcti *rect)
Definition: screen_edit.c:190
static ScrArea * screen_area_create_with_geometry(ScrAreaMap *area_map, const rcti *rect, eSpace_Type space_type)
Definition: screen_edit.c:950
static ARegion * time_top_left_3dwindow(bScreen *screen)
Definition: screen_edit.c:1659
void ED_region_remove(bContext *C, ScrArea *area, ARegion *region)
Definition: screen_edit.c:677
void ED_region_exit(bContext *C, ARegion *region)
Definition: screen_edit.c:686
static void region_cursor_set_ex(wmWindow *win, ScrArea *area, ARegion *region, bool swin_changed)
Definition: screen_edit.c:560
void ED_screen_full_prevspace(bContext *C, ScrArea *area)
Definition: screen_edit.c:1275
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)
Definition: screen_edit.c:51
bool screen_geom_edge_is_horizontal(ScrEdge *se)
ScrEdge * screen_geom_find_active_scredge(const wmWindow *win, const bScreen *screen, const int mx, const int my)
ScrEdge * screen_geom_edge_add(bScreen *screen, ScrVert *v1, ScrVert *v2)
ScrVert * screen_geom_vertex_add(bScreen *screen, short x, short y)
ScrEdge * screen_geom_edge_add_ex(ScrAreaMap *area_map, ScrVert *v1, ScrVert *v2)
ScrVert * screen_geom_vertex_add_ex(ScrAreaMap *area_map, short x, short y)
void screen_geom_vertices_scale(const wmWindow *win, bScreen *screen)
Main screen-layout calculation function.
short screen_geom_find_area_split_point(const ScrArea *area, const rcti *window_rect, const eScreenAxis dir_axis, float fac)
#define SCREEN_DIR_IS_HORIZONTAL(dir)
Definition: screen_intern.h:30
#define BORDERPADDING
Definition: screen_intern.h:51
struct AZone * ED_area_actionzone_find_xy(ScrArea *area, const int xy[2])
Definition: screen_ops.c:969
eScreenAxis
Definition: screen_intern.h:32
@ SCREEN_AXIS_V
Definition: screen_intern.h:36
@ SCREEN_AXIS_H
Definition: screen_intern.h:34
#define SCREEN_DIR_IS_VERTICAL(dir)
Definition: screen_intern.h:29
#define AREAJOINTOLERANCEX
Definition: screen_intern.h:45
eScreenDir
Definition: screen_intern.h:16
@ SCREEN_DIR_W
Definition: screen_intern.h:20
@ SCREEN_DIR_N
Definition: screen_intern.h:22
@ SCREEN_DIR_E
Definition: screen_intern.h:24
@ SCREEN_DIR_S
Definition: screen_intern.h:26
@ SCREEN_DIR_NONE
Definition: screen_intern.h:18
#define AREAJOINTOLERANCEY
Definition: screen_intern.h:46
#define min(a, b)
Definition: sort.c:35
void(* exit)(struct wmWindowManager *wm, struct ARegion *region)
Definition: BKE_screen.h:149
short event_cursor
Definition: BKE_screen.h:215
struct wmTimer * regiontimer
char * headerstr
ListBase handlers
struct wmGizmoMap * gizmo_map
struct ARegionType * type
AZEdge edge
int icon_id
Definition: DNA_ID.h:389
char name[66]
Definition: DNA_ID.h:378
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
ListBase screens
Definition: BKE_main.h:183
ListBase workspaces
Definition: BKE_main.h:203
void * fps_info
struct RenderData r
struct Object * camera
ListBase areabase
ScrVert * v2
ScrVert * v3
ListBase spacedata
bScreen * full
ScrVert * v1
struct ScrArea * next
ListBase regionbase
ScrGlobalAreaData * global
ScrVert * v4
struct ScrVert * next
ARegion * region
struct ImageUser iuser
struct Image * image
struct SpaceLink *(* create)(const struct ScrArea *area, const struct Scene *scene)
Definition: BKE_screen.h:71
struct Object * camera
char stereo3d_camera
ListBase regionbase
Wrapper for bScreen.
char do_refresh
ListBase edgebase
void * context
short redraws_flag
ListBase regionbase
char skip_handling
ListBase vertbase
struct wmTimer * animtimer
char scrubbing
ListBase areabase
struct ARegion * active_region
int ymin
Definition: DNA_vec_types.h:64
int ymax
Definition: DNA_vec_types.h:64
int xmin
Definition: DNA_vec_types.h:63
int xmax
Definition: DNA_vec_types.h:63
short y
Definition: DNA_vec_types.h:18
short x
Definition: DNA_vec_types.h:18
int xy[2]
Definition: WM_types.h:682
unsigned int data
Definition: WM_types.h:308
unsigned int action
Definition: WM_types.h:308
unsigned int category
Definition: WM_types.h:308
double ltime
Definition: WM_types.h:877
void * customdata
Definition: WM_types.h:869
struct wmMsgBus * message_bus
struct wmWindow * parent
struct wmEvent * eventstate
struct Scene * scene
ScrAreaMap global_areas
struct WorkSpaceInstanceHook * workspace_hook
void WM_cursor_set(wmWindow *win, int curs)
Definition: wm_cursors.c:126
@ WM_CURSOR_DEFAULT
Definition: wm_cursors.h:18
@ WM_CURSOR_Y_MOVE
Definition: wm_cursors.h:39
@ WM_CURSOR_EDIT
Definition: wm_cursors.h:22
@ WM_CURSOR_X_MOVE
Definition: wm_cursors.h:38
void WM_draw_region_free(ARegion *region, bool hide)
Definition: wm_draw.c:1360
int xy[2]
Definition: wm_draw.c:135
bool WM_cursor_test_motion_and_update(const int mval[2])
void WM_event_remove_area_handler(ListBase *handlers, void *area)
void WM_event_modal_handler_region_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
void WM_event_modal_handler_area_replace(wmWindow *win, const ScrArea *old_area, ScrArea *new_area)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void WM_event_remove_handlers(bContext *C, ListBase *handlers)
void WM_event_add_mousemove(wmWindow *win)
@ TIMER0
bool WM_gizmo_highlight_set(wmGizmoMap *gzmap, wmGizmo *gz)
Definition: wm_gizmo.c:402
void WM_msgbus_clear_by_owner(struct wmMsgBus *mbus, void *owner)
void WM_toolsystem_refresh_screen_window(wmWindow *win)
void WM_event_remove_timer(wmWindowManager *wm, wmWindow *UNUSED(win), wmTimer *timer)
Definition: wm_window.c:1682
void WM_window_ensure_active_view_layer(wmWindow *win)
Definition: wm_window.c:2255
int WM_window_pixels_y(const wmWindow *win)
Definition: wm_window.c:2082
WorkSpaceLayout * WM_window_get_active_layout(const wmWindow *win)
Definition: wm_window.c:2290
void WM_window_set_active_screen(wmWindow *win, WorkSpace *workspace, bScreen *screen)
Definition: wm_window.c:2306
void WM_window_set_dpi(const wmWindow *win)
Definition: wm_window.c:447
void WM_event_timer_sleep(wmWindowManager *wm, wmWindow *UNUSED(win), wmTimer *timer, bool do_sleep)
Definition: wm_window.c:1614
bScreen * WM_window_get_active_screen(const wmWindow *win)
Definition: wm_window.c:2300
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
Definition: wm_window.c:2217
WorkSpace * WM_window_get_active_workspace(const wmWindow *win)
Definition: wm_window.c:2266
bool WM_window_is_temp_screen(const wmWindow *win)
Definition: wm_window.c:2311
void WM_window_rect_calc(const wmWindow *win, rcti *r_rect)
Definition: wm_window.c:2089
int WM_window_pixels_x(const wmWindow *win)
Definition: wm_window.c:2076
wmWindow * WM_window_open(bContext *C, const char *title, int x, int y, int sizex, int sizey, int space_type, bool toplevel, bool dialog, bool temp, eWindowAlignment alignment)
Definition: wm_window.c:721
Scene * WM_window_get_active_scene(const wmWindow *win)
Definition: wm_window.c:2183
wmTimer * WM_event_add_timer(wmWindowManager *wm, wmWindow *win, int event_type, double timestep)
Definition: wm_window.c:1630