Cleanup: remove redundant preference check
[blender.git] / source / blender / blenkernel / intern / screen.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #ifdef WIN32
25 #  include "BLI_winstuff.h"
26 #endif
27
28 #include <string.h>
29 #include <stdio.h>
30 #include <math.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_scene_types.h"
35 #include "DNA_screen_types.h"
36 #include "DNA_space_types.h"
37 #include "DNA_view3d_types.h"
38 #include "DNA_workspace_types.h"
39
40 #include "BLI_math_vector.h"
41 #include "BLI_listbase.h"
42 #include "BLI_rect.h"
43 #include "BLI_utildefines.h"
44
45 #include "BKE_icons.h"
46 #include "BKE_idprop.h"
47 #include "BKE_screen.h"
48 #include "BKE_workspace.h"
49
50 /* ************ Spacetype/regiontype handling ************** */
51
52 /* keep global; this has to be accessible outside of windowmanager */
53 static ListBase spacetypes = {NULL, NULL};
54
55 /* not SpaceType itself */
56 static void spacetype_free(SpaceType *st)
57 {
58   ARegionType *art;
59   PanelType *pt;
60   HeaderType *ht;
61
62   for (art = st->regiontypes.first; art; art = art->next) {
63     BLI_freelistN(&art->drawcalls);
64
65     for (pt = art->paneltypes.first; pt; pt = pt->next) {
66       if (pt->ext.free) {
67         pt->ext.free(pt->ext.data);
68       }
69
70       BLI_freelistN(&pt->children);
71     }
72
73     for (ht = art->headertypes.first; ht; ht = ht->next) {
74       if (ht->ext.free) {
75         ht->ext.free(ht->ext.data);
76       }
77     }
78
79     BLI_freelistN(&art->paneltypes);
80     BLI_freelistN(&art->headertypes);
81   }
82
83   BLI_freelistN(&st->regiontypes);
84 }
85
86 void BKE_spacetypes_free(void)
87 {
88   SpaceType *st;
89
90   for (st = spacetypes.first; st; st = st->next) {
91     spacetype_free(st);
92   }
93
94   BLI_freelistN(&spacetypes);
95 }
96
97 SpaceType *BKE_spacetype_from_id(int spaceid)
98 {
99   SpaceType *st;
100
101   for (st = spacetypes.first; st; st = st->next) {
102     if (st->spaceid == spaceid) {
103       return st;
104     }
105   }
106   return NULL;
107 }
108
109 ARegionType *BKE_regiontype_from_id_or_first(SpaceType *st, int regionid)
110 {
111   ARegionType *art;
112
113   for (art = st->regiontypes.first; art; art = art->next) {
114     if (art->regionid == regionid) {
115       return art;
116     }
117   }
118
119   printf(
120       "Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
121   return st->regiontypes.first;
122 }
123
124 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
125 {
126   ARegionType *art;
127
128   for (art = st->regiontypes.first; art; art = art->next) {
129     if (art->regionid == regionid) {
130       return art;
131     }
132   }
133   return NULL;
134 }
135
136 const ListBase *BKE_spacetypes_list(void)
137 {
138   return &spacetypes;
139 }
140
141 void BKE_spacetype_register(SpaceType *st)
142 {
143   SpaceType *stype;
144
145   /* sanity check */
146   stype = BKE_spacetype_from_id(st->spaceid);
147   if (stype) {
148     printf("error: redefinition of spacetype %s\n", stype->name);
149     spacetype_free(stype);
150     MEM_freeN(stype);
151   }
152
153   BLI_addtail(&spacetypes, st);
154 }
155
156 bool BKE_spacetype_exists(int spaceid)
157 {
158   return BKE_spacetype_from_id(spaceid) != NULL;
159 }
160
161 /* ***************** Space handling ********************** */
162
163 void BKE_spacedata_freelist(ListBase *lb)
164 {
165   SpaceLink *sl;
166   ARegion *ar;
167
168   for (sl = lb->first; sl; sl = sl->next) {
169     SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
170
171     /* free regions for pushed spaces */
172     for (ar = sl->regionbase.first; ar; ar = ar->next) {
173       BKE_area_region_free(st, ar);
174     }
175
176     BLI_freelistN(&sl->regionbase);
177
178     if (st && st->free) {
179       st->free(sl);
180     }
181   }
182
183   BLI_freelistN(lb);
184 }
185
186 static void panel_list_copy(ListBase *newlb, const ListBase *lb)
187 {
188   BLI_listbase_clear(newlb);
189   BLI_duplicatelist(newlb, lb);
190
191   /* copy panel pointers */
192   Panel *newpa = newlb->first;
193   Panel *pa = lb->first;
194   for (; newpa; newpa = newpa->next, pa = pa->next) {
195     newpa->activedata = NULL;
196     panel_list_copy(&newpa->children, &pa->children);
197   }
198 }
199
200 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
201 {
202   ARegion *newar = MEM_dupallocN(ar);
203
204   newar->prev = newar->next = NULL;
205   BLI_listbase_clear(&newar->handlers);
206   BLI_listbase_clear(&newar->uiblocks);
207   BLI_listbase_clear(&newar->panels_category);
208   BLI_listbase_clear(&newar->panels_category_active);
209   BLI_listbase_clear(&newar->ui_lists);
210   newar->visible = 0;
211   newar->gizmo_map = NULL;
212   newar->regiontimer = NULL;
213   newar->headerstr = NULL;
214   newar->draw_buffer = NULL;
215
216   /* use optional regiondata callback */
217   if (ar->regiondata) {
218     ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
219
220     if (art && art->duplicate) {
221       newar->regiondata = art->duplicate(ar->regiondata);
222     }
223     else if (ar->flag & RGN_FLAG_TEMP_REGIONDATA) {
224       newar->regiondata = NULL;
225     }
226     else {
227       newar->regiondata = MEM_dupallocN(ar->regiondata);
228     }
229   }
230
231   if (ar->v2d.tab_offset) {
232     newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
233   }
234
235   panel_list_copy(&newar->panels, &ar->panels);
236
237   BLI_listbase_clear(&newar->ui_previews);
238   BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
239
240   return newar;
241 }
242
243 /* from lb2 to lb1, lb1 is supposed to be freed */
244 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
245 {
246   ARegion *ar;
247
248   /* to be sure */
249   BLI_listbase_clear(lb1);
250
251   for (ar = lb2->first; ar; ar = ar->next) {
252     ARegion *arnew = BKE_area_region_copy(st, ar);
253     BLI_addtail(lb1, arnew);
254   }
255 }
256
257 /* lb1 should be empty */
258 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
259 {
260   SpaceLink *sl;
261
262   BLI_listbase_clear(lb1); /* to be sure */
263
264   for (sl = lb2->first; sl; sl = sl->next) {
265     SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
266
267     if (st && st->duplicate) {
268       SpaceLink *slnew = st->duplicate(sl);
269
270       BLI_addtail(lb1, slnew);
271
272       region_copylist(st, &slnew->regionbase, &sl->regionbase);
273     }
274   }
275 }
276
277 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
278 /* lock can become bitflag too */
279 /* should be replaced in future by better local data handling for threads */
280 void BKE_spacedata_draw_locks(int set)
281 {
282   SpaceType *st;
283
284   for (st = spacetypes.first; st; st = st->next) {
285     ARegionType *art;
286
287     for (art = st->regiontypes.first; art; art = art->next) {
288       if (set) {
289         art->do_lock = art->lock;
290       }
291       else {
292         art->do_lock = false;
293       }
294     }
295   }
296 }
297
298 /**
299  * Version of #BKE_area_find_region_type that also works if \a slink
300  * is not the active space of \a sa.
301  */
302 ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *sa, int region_type)
303 {
304   const bool is_slink_active = slink == sa->spacedata.first;
305   const ListBase *regionbase = (is_slink_active) ? &sa->regionbase : &slink->regionbase;
306   ARegion *ar = NULL;
307
308   BLI_assert(BLI_findindex(&sa->spacedata, slink) != -1);
309   for (ar = regionbase->first; ar; ar = ar->next) {
310     if (ar->regiontype == region_type) {
311       break;
312     }
313   }
314
315   /* Should really unit test this instead. */
316   BLI_assert(!is_slink_active || ar == BKE_area_find_region_type(sa, region_type));
317
318   return ar;
319 }
320
321 static void (*spacedata_id_remap_cb)(struct ScrArea *sa,
322                                      struct SpaceLink *sl,
323                                      ID *old_id,
324                                      ID *new_id) = NULL;
325
326 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
327 {
328   spacedata_id_remap_cb = func;
329 }
330
331 /* UNUSED!!! */
332 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
333 {
334   if (spacedata_id_remap_cb) {
335     spacedata_id_remap_cb(sa, sl, id, NULL);
336   }
337 }
338
339 /**
340  * Avoid bad-level calls to #WM_gizmomap_tag_refresh.
341  */
342 static void (*region_refresh_tag_gizmomap_callback)(struct wmGizmoMap *) = NULL;
343
344 void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(struct wmGizmoMap *))
345 {
346   region_refresh_tag_gizmomap_callback = callback;
347 }
348
349 void BKE_screen_gizmo_tag_refresh(struct bScreen *sc)
350 {
351   if (region_refresh_tag_gizmomap_callback == NULL) {
352     return;
353   }
354
355   ScrArea *sa;
356   ARegion *ar;
357   for (sa = sc->areabase.first; sa; sa = sa->next) {
358     for (ar = sa->regionbase.first; ar; ar = ar->next) {
359       if (ar->gizmo_map != NULL) {
360         region_refresh_tag_gizmomap_callback(ar->gizmo_map);
361       }
362     }
363   }
364 }
365
366 /**
367  * Avoid bad-level calls to #WM_gizmomap_delete.
368  */
369 static void (*region_free_gizmomap_callback)(struct wmGizmoMap *) = NULL;
370
371 void BKE_region_callback_free_gizmomap_set(void (*callback)(struct wmGizmoMap *))
372 {
373   region_free_gizmomap_callback = callback;
374 }
375
376 void BKE_area_region_panels_free(ListBase *lb)
377 {
378   Panel *pa, *pa_next;
379   for (pa = lb->first; pa; pa = pa_next) {
380     pa_next = pa->next;
381     if (pa->activedata) {
382       MEM_freeN(pa->activedata);
383     }
384     BKE_area_region_panels_free(&pa->children);
385   }
386
387   BLI_freelistN(lb);
388 }
389
390 /* not region itself */
391 void BKE_area_region_free(SpaceType *st, ARegion *ar)
392 {
393   uiList *uilst;
394
395   if (st) {
396     ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
397
398     if (art && art->free) {
399       art->free(ar);
400     }
401
402     if (ar->regiondata) {
403       printf("regiondata free error\n");
404     }
405   }
406   else if (ar->type && ar->type->free) {
407     ar->type->free(ar);
408   }
409
410   if (ar->v2d.tab_offset) {
411     MEM_freeN(ar->v2d.tab_offset);
412     ar->v2d.tab_offset = NULL;
413   }
414
415   BKE_area_region_panels_free(&ar->panels);
416
417   for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
418     if (uilst->dyn_data) {
419       uiListDyn *dyn_data = uilst->dyn_data;
420       if (dyn_data->items_filter_flags) {
421         MEM_freeN(dyn_data->items_filter_flags);
422       }
423       if (dyn_data->items_filter_neworder) {
424         MEM_freeN(dyn_data->items_filter_neworder);
425       }
426       MEM_freeN(dyn_data);
427     }
428     if (uilst->properties) {
429       IDP_FreeProperty(uilst->properties);
430     }
431   }
432
433   if (ar->gizmo_map != NULL) {
434     region_free_gizmomap_callback(ar->gizmo_map);
435   }
436
437   BLI_freelistN(&ar->ui_lists);
438   BLI_freelistN(&ar->ui_previews);
439   BLI_freelistN(&ar->panels_category);
440   BLI_freelistN(&ar->panels_category_active);
441 }
442
443 /* not area itself */
444 void BKE_screen_area_free(ScrArea *sa)
445 {
446   SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
447   ARegion *ar;
448
449   for (ar = sa->regionbase.first; ar; ar = ar->next) {
450     BKE_area_region_free(st, ar);
451   }
452
453   MEM_SAFE_FREE(sa->global);
454   BLI_freelistN(&sa->regionbase);
455
456   BKE_spacedata_freelist(&sa->spacedata);
457
458   BLI_freelistN(&sa->actionzones);
459 }
460
461 void BKE_screen_area_map_free(ScrAreaMap *area_map)
462 {
463   for (ScrArea *area = area_map->areabase.first, *area_next; area; area = area_next) {
464     area_next = area->next;
465     BKE_screen_area_free(area);
466   }
467
468   BLI_freelistN(&area_map->vertbase);
469   BLI_freelistN(&area_map->edgebase);
470   BLI_freelistN(&area_map->areabase);
471 }
472
473 /** Free (or release) any data used by this screen (does not free the screen itself). */
474 void BKE_screen_free(bScreen *sc)
475 {
476   ARegion *ar;
477
478   /* No animdata here. */
479
480   for (ar = sc->regionbase.first; ar; ar = ar->next) {
481     BKE_area_region_free(NULL, ar);
482   }
483
484   BLI_freelistN(&sc->regionbase);
485
486   BKE_screen_area_map_free(AREAMAP_FROM_SCREEN(sc));
487
488   BKE_previewimg_free(&sc->preview);
489
490   /* Region and timer are freed by the window manager. */
491   MEM_SAFE_FREE(sc->tool_tip);
492 }
493
494 /* ***************** Screen edges & verts ***************** */
495
496 ScrEdge *BKE_screen_find_edge(bScreen *sc, ScrVert *v1, ScrVert *v2)
497 {
498   ScrEdge *se;
499
500   BKE_screen_sort_scrvert(&v1, &v2);
501   for (se = sc->edgebase.first; se; se = se->next) {
502     if (se->v1 == v1 && se->v2 == v2) {
503       return se;
504     }
505   }
506
507   return NULL;
508 }
509
510 void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2)
511 {
512   ScrVert *tmp;
513
514   if (*v1 > *v2) {
515     tmp = *v1;
516     *v1 = *v2;
517     *v2 = tmp;
518   }
519 }
520
521 void BKE_screen_remove_double_scrverts(bScreen *sc)
522 {
523   ScrVert *v1, *verg;
524   ScrEdge *se;
525   ScrArea *sa;
526
527   verg = sc->vertbase.first;
528   while (verg) {
529     if (verg->newv == NULL) { /* !!! */
530       v1 = verg->next;
531       while (v1) {
532         if (v1->newv == NULL) { /* !?! */
533           if (v1->vec.x == verg->vec.x && v1->vec.y == verg->vec.y) {
534             /* printf("doublevert\n"); */
535             v1->newv = verg;
536           }
537         }
538         v1 = v1->next;
539       }
540     }
541     verg = verg->next;
542   }
543
544   /* replace pointers in edges and faces */
545   se = sc->edgebase.first;
546   while (se) {
547     if (se->v1->newv) {
548       se->v1 = se->v1->newv;
549     }
550     if (se->v2->newv) {
551       se->v2 = se->v2->newv;
552     }
553     /* edges changed: so.... */
554     BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
555     se = se->next;
556   }
557   sa = sc->areabase.first;
558   while (sa) {
559     if (sa->v1->newv) {
560       sa->v1 = sa->v1->newv;
561     }
562     if (sa->v2->newv) {
563       sa->v2 = sa->v2->newv;
564     }
565     if (sa->v3->newv) {
566       sa->v3 = sa->v3->newv;
567     }
568     if (sa->v4->newv) {
569       sa->v4 = sa->v4->newv;
570     }
571     sa = sa->next;
572   }
573
574   /* remove */
575   verg = sc->vertbase.first;
576   while (verg) {
577     v1 = verg->next;
578     if (verg->newv) {
579       BLI_remlink(&sc->vertbase, verg);
580       MEM_freeN(verg);
581     }
582     verg = v1;
583   }
584 }
585
586 void BKE_screen_remove_double_scredges(bScreen *sc)
587 {
588   ScrEdge *verg, *se, *sn;
589
590   /* compare */
591   verg = sc->edgebase.first;
592   while (verg) {
593     se = verg->next;
594     while (se) {
595       sn = se->next;
596       if (verg->v1 == se->v1 && verg->v2 == se->v2) {
597         BLI_remlink(&sc->edgebase, se);
598         MEM_freeN(se);
599       }
600       se = sn;
601     }
602     verg = verg->next;
603   }
604 }
605
606 void BKE_screen_remove_unused_scredges(bScreen *sc)
607 {
608   ScrEdge *se, *sen;
609   ScrArea *sa;
610   int a = 0;
611
612   /* sets flags when edge is used in area */
613   sa = sc->areabase.first;
614   while (sa) {
615     se = BKE_screen_find_edge(sc, sa->v1, sa->v2);
616     if (se == NULL) {
617       printf("error: area %d edge 1 doesn't exist\n", a);
618     }
619     else {
620       se->flag = 1;
621     }
622     se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
623     if (se == NULL) {
624       printf("error: area %d edge 2 doesn't exist\n", a);
625     }
626     else {
627       se->flag = 1;
628     }
629     se = BKE_screen_find_edge(sc, sa->v3, sa->v4);
630     if (se == NULL) {
631       printf("error: area %d edge 3 doesn't exist\n", a);
632     }
633     else {
634       se->flag = 1;
635     }
636     se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
637     if (se == NULL) {
638       printf("error: area %d edge 4 doesn't exist\n", a);
639     }
640     else {
641       se->flag = 1;
642     }
643     sa = sa->next;
644     a++;
645   }
646   se = sc->edgebase.first;
647   while (se) {
648     sen = se->next;
649     if (se->flag == 0) {
650       BLI_remlink(&sc->edgebase, se);
651       MEM_freeN(se);
652     }
653     else {
654       se->flag = 0;
655     }
656     se = sen;
657   }
658 }
659
660 void BKE_screen_remove_unused_scrverts(bScreen *sc)
661 {
662   ScrVert *sv, *svn;
663   ScrEdge *se;
664
665   /* we assume edges are ok */
666
667   se = sc->edgebase.first;
668   while (se) {
669     se->v1->flag = 1;
670     se->v2->flag = 1;
671     se = se->next;
672   }
673
674   sv = sc->vertbase.first;
675   while (sv) {
676     svn = sv->next;
677     if (sv->flag == 0) {
678       BLI_remlink(&sc->vertbase, sv);
679       MEM_freeN(sv);
680     }
681     else {
682       sv->flag = 0;
683     }
684     sv = svn;
685   }
686 }
687
688 /* ***************** Utilities ********************** */
689
690 /**
691  * Find a region of type \a region_type in the currently active space of \a sa.
692  *
693  * \note This does _not_ work if the region to look up is not in the active
694  *       space. Use #BKE_spacedata_find_region_type if that may be the case.
695  */
696 ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
697 {
698   if (sa) {
699     for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
700       if (ar->regiontype == region_type) {
701         return ar;
702       }
703     }
704   }
705
706   return NULL;
707 }
708
709 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
710 {
711   if (sa) {
712     ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
713     if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
714       return ar;
715     }
716
717     /* fallback to any */
718     return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
719   }
720   return NULL;
721 }
722
723 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
724 {
725   ARegion *ar_found = NULL;
726   if (sa) {
727     ARegion *ar;
728     for (ar = sa->regionbase.first; ar; ar = ar->next) {
729       if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
730         if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
731           ar_found = ar;
732           break;
733         }
734       }
735     }
736   }
737   return ar_found;
738 }
739
740 /**
741  * \note This is only for screen level regions (typically menus/popups).
742  */
743 ARegion *BKE_screen_find_region_xy(bScreen *sc, const int regiontype, int x, int y)
744 {
745   ARegion *ar_found = NULL;
746   for (ARegion *ar = sc->regionbase.first; ar; ar = ar->next) {
747     if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
748       if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
749         ar_found = ar;
750         break;
751       }
752     }
753   }
754   return ar_found;
755 }
756
757 /**
758  * \note, ideally we can get the area from the context,
759  * there are a few places however where this isn't practical.
760  */
761 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
762 {
763   ScrArea *sa;
764
765   for (sa = sc->areabase.first; sa; sa = sa->next) {
766     if (BLI_findindex(&sa->spacedata, sl) != -1) {
767       break;
768     }
769   }
770
771   return sa;
772 }
773
774 /**
775  * \note Using this function is generally a last resort, you really want to be
776  * using the context when you can - campbell
777  */
778 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
779 {
780   ScrArea *sa, *big = NULL;
781   int size, maxsize = 0;
782
783   for (sa = sc->areabase.first; sa; sa = sa->next) {
784     if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
785       if (min <= sa->winx && min <= sa->winy) {
786         size = sa->winx * sa->winy;
787         if (size > maxsize) {
788           maxsize = size;
789           big = sa;
790         }
791       }
792     }
793   }
794
795   return big;
796 }
797
798 ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap,
799                                           const int spacetype,
800                                           int x,
801                                           int y)
802 {
803   for (ScrArea *sa = areamap->areabase.first; sa; sa = sa->next) {
804     if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
805       if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
806         return sa;
807       }
808       break;
809     }
810   }
811   return NULL;
812 }
813 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
814 {
815   return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
816 }
817
818 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
819 {
820   if (v3d->scenelock && v3d->localvd == NULL) {
821     v3d->camera = scene->camera;
822
823     if (v3d->camera == NULL) {
824       ARegion *ar;
825
826       for (ar = v3d->regionbase.first; ar; ar = ar->next) {
827         if (ar->regiontype == RGN_TYPE_WINDOW) {
828           RegionView3D *rv3d = ar->regiondata;
829           if (rv3d->persp == RV3D_CAMOB) {
830             rv3d->persp = RV3D_PERSP;
831           }
832         }
833       }
834     }
835   }
836 }
837
838 void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
839 {
840   /* are there cameras in the views that are not in the scene? */
841   ScrArea *sa;
842   for (sa = sc->areabase.first; sa; sa = sa->next) {
843     SpaceLink *sl;
844     for (sl = sa->spacedata.first; sl; sl = sl->next) {
845       if (sl->spacetype == SPACE_VIEW3D) {
846         View3D *v3d = (View3D *)sl;
847         BKE_screen_view3d_sync(v3d, scene);
848       }
849     }
850   }
851 }
852
853 void BKE_screen_view3d_shading_init(View3DShading *shading)
854 {
855   memset(shading, 0, sizeof(*shading));
856
857   shading->type = OB_SOLID;
858   shading->prev_type = OB_SOLID;
859   shading->flag = V3D_SHADING_SPECULAR_HIGHLIGHT | V3D_SHADING_XRAY_WIREFRAME;
860   shading->light = V3D_LIGHTING_STUDIO;
861   shading->shadow_intensity = 0.5f;
862   shading->xray_alpha = 0.5f;
863   shading->xray_alpha_wire = 0.0f;
864   shading->cavity_valley_factor = 1.0f;
865   shading->cavity_ridge_factor = 1.0f;
866   shading->cavity_type = V3D_SHADING_CAVITY_CURVATURE;
867   shading->curvature_ridge_factor = 1.0f;
868   shading->curvature_valley_factor = 1.0f;
869   copy_v3_fl(shading->single_color, 0.8f);
870   copy_v3_fl(shading->background_color, 0.05f);
871 }
872
873 /* magic zoom calculation, no idea what
874  * it signifies, if you find out, tell me! -zr
875  */
876
877 /* simple, its magic dude!
878  * well, to be honest, this gives a natural feeling zooming
879  * with multiple keypad presses (ton)
880  */
881 float BKE_screen_view3d_zoom_to_fac(float camzoom)
882 {
883   return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
884 }
885
886 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
887 {
888   return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
889 }
890
891 bool BKE_screen_is_fullscreen_area(const bScreen *screen)
892 {
893   return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
894 }
895
896 bool BKE_screen_is_used(const bScreen *screen)
897 {
898   return (screen->winid != 0);
899 }
900
901 void BKE_screen_header_alignment_reset(bScreen *screen)
902 {
903   int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
904   for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
905     for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
906       if (ELEM(ar->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER)) {
907         if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
908           ar->alignment = RGN_ALIGN_TOP;
909           continue;
910         }
911         ar->alignment = alignment;
912       }
913       if (ar->regiontype == RGN_TYPE_FOOTER) {
914         if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
915           ar->alignment = RGN_ALIGN_BOTTOM;
916           continue;
917         }
918         ar->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_TOP : RGN_ALIGN_BOTTOM;
919       }
920     }
921   }
922   screen->do_refresh = true;
923 }