ClangFormat: apply to source, most of intern
[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   return NULL;
106 }
107
108 ARegionType *BKE_regiontype_from_id_or_first(SpaceType *st, int regionid)
109 {
110   ARegionType *art;
111
112   for (art = st->regiontypes.first; art; art = art->next)
113     if (art->regionid == regionid)
114       return art;
115
116   printf(
117       "Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
118   return st->regiontypes.first;
119 }
120
121 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
122 {
123   ARegionType *art;
124
125   for (art = st->regiontypes.first; art; art = art->next) {
126     if (art->regionid == regionid) {
127       return art;
128     }
129   }
130   return NULL;
131 }
132
133 const ListBase *BKE_spacetypes_list(void)
134 {
135   return &spacetypes;
136 }
137
138 void BKE_spacetype_register(SpaceType *st)
139 {
140   SpaceType *stype;
141
142   /* sanity check */
143   stype = BKE_spacetype_from_id(st->spaceid);
144   if (stype) {
145     printf("error: redefinition of spacetype %s\n", stype->name);
146     spacetype_free(stype);
147     MEM_freeN(stype);
148   }
149
150   BLI_addtail(&spacetypes, st);
151 }
152
153 bool BKE_spacetype_exists(int spaceid)
154 {
155   return BKE_spacetype_from_id(spaceid) != NULL;
156 }
157
158 /* ***************** Space handling ********************** */
159
160 void BKE_spacedata_freelist(ListBase *lb)
161 {
162   SpaceLink *sl;
163   ARegion *ar;
164
165   for (sl = lb->first; sl; sl = sl->next) {
166     SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
167
168     /* free regions for pushed spaces */
169     for (ar = sl->regionbase.first; ar; ar = ar->next)
170       BKE_area_region_free(st, ar);
171
172     BLI_freelistN(&sl->regionbase);
173
174     if (st && st->free)
175       st->free(sl);
176   }
177
178   BLI_freelistN(lb);
179 }
180
181 static void panel_list_copy(ListBase *newlb, const ListBase *lb)
182 {
183   BLI_listbase_clear(newlb);
184   BLI_duplicatelist(newlb, lb);
185
186   /* copy panel pointers */
187   Panel *newpa = newlb->first;
188   Panel *pa = lb->first;
189   for (; newpa; newpa = newpa->next, pa = pa->next) {
190     newpa->activedata = NULL;
191
192     Panel *newpatab = newlb->first;
193     Panel *patab = lb->first;
194     while (newpatab) {
195       if (newpa->paneltab == patab) {
196         newpa->paneltab = newpatab;
197         break;
198       }
199       newpatab = newpatab->next;
200       patab = patab->next;
201     }
202
203     panel_list_copy(&newpa->children, &pa->children);
204   }
205 }
206
207 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
208 {
209   ARegion *newar = MEM_dupallocN(ar);
210
211   newar->prev = newar->next = NULL;
212   BLI_listbase_clear(&newar->handlers);
213   BLI_listbase_clear(&newar->uiblocks);
214   BLI_listbase_clear(&newar->panels_category);
215   BLI_listbase_clear(&newar->panels_category_active);
216   BLI_listbase_clear(&newar->ui_lists);
217   newar->visible = 0;
218   newar->gizmo_map = NULL;
219   newar->regiontimer = NULL;
220   newar->headerstr = NULL;
221   newar->draw_buffer = NULL;
222
223   /* use optional regiondata callback */
224   if (ar->regiondata) {
225     ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
226
227     if (art && art->duplicate) {
228       newar->regiondata = art->duplicate(ar->regiondata);
229     }
230     else if (ar->flag & RGN_FLAG_TEMP_REGIONDATA) {
231       newar->regiondata = NULL;
232     }
233     else {
234       newar->regiondata = MEM_dupallocN(ar->regiondata);
235     }
236   }
237
238   if (ar->v2d.tab_offset)
239     newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
240
241   panel_list_copy(&newar->panels, &ar->panels);
242
243   BLI_listbase_clear(&newar->ui_previews);
244   BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
245
246   return newar;
247 }
248
249 /* from lb2 to lb1, lb1 is supposed to be freed */
250 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
251 {
252   ARegion *ar;
253
254   /* to be sure */
255   BLI_listbase_clear(lb1);
256
257   for (ar = lb2->first; ar; ar = ar->next) {
258     ARegion *arnew = BKE_area_region_copy(st, ar);
259     BLI_addtail(lb1, arnew);
260   }
261 }
262
263 /* lb1 should be empty */
264 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
265 {
266   SpaceLink *sl;
267
268   BLI_listbase_clear(lb1); /* to be sure */
269
270   for (sl = lb2->first; sl; sl = sl->next) {
271     SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
272
273     if (st && st->duplicate) {
274       SpaceLink *slnew = st->duplicate(sl);
275
276       BLI_addtail(lb1, slnew);
277
278       region_copylist(st, &slnew->regionbase, &sl->regionbase);
279     }
280   }
281 }
282
283 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
284 /* lock can become bitflag too */
285 /* should be replaced in future by better local data handling for threads */
286 void BKE_spacedata_draw_locks(int set)
287 {
288   SpaceType *st;
289
290   for (st = spacetypes.first; st; st = st->next) {
291     ARegionType *art;
292
293     for (art = st->regiontypes.first; art; art = art->next) {
294       if (set)
295         art->do_lock = art->lock;
296       else
297         art->do_lock = false;
298     }
299   }
300 }
301
302 /**
303  * Version of #BKE_area_find_region_type that also works if \a slink is not the active space of \a sa.
304  */
305 ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *sa, int region_type)
306 {
307   const bool is_slink_active = slink == sa->spacedata.first;
308   const ListBase *regionbase = (is_slink_active) ? &sa->regionbase : &slink->regionbase;
309   ARegion *ar = NULL;
310
311   BLI_assert(BLI_findindex(&sa->spacedata, slink) != -1);
312   for (ar = regionbase->first; ar; ar = ar->next) {
313     if (ar->regiontype == region_type) {
314       break;
315     }
316   }
317
318   /* Should really unit test this instead. */
319   BLI_assert(!is_slink_active || ar == BKE_area_find_region_type(sa, region_type));
320
321   return ar;
322 }
323
324 static void (*spacedata_id_remap_cb)(struct ScrArea *sa,
325                                      struct SpaceLink *sl,
326                                      ID *old_id,
327                                      ID *new_id) = NULL;
328
329 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
330 {
331   spacedata_id_remap_cb = func;
332 }
333
334 /* UNUSED!!! */
335 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
336 {
337   if (spacedata_id_remap_cb) {
338     spacedata_id_remap_cb(sa, sl, id, NULL);
339   }
340 }
341
342 /**
343  * Avoid bad-level calls to #WM_gizmomap_tag_refresh.
344  */
345 static void (*region_refresh_tag_gizmomap_callback)(struct wmGizmoMap *) = NULL;
346
347 void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(struct wmGizmoMap *))
348 {
349   region_refresh_tag_gizmomap_callback = callback;
350 }
351
352 void BKE_screen_gizmo_tag_refresh(struct bScreen *sc)
353 {
354   if (region_refresh_tag_gizmomap_callback == NULL) {
355     return;
356   }
357
358   ScrArea *sa;
359   ARegion *ar;
360   for (sa = sc->areabase.first; sa; sa = sa->next) {
361     for (ar = sa->regionbase.first; ar; ar = ar->next) {
362       if (ar->gizmo_map != NULL) {
363         region_refresh_tag_gizmomap_callback(ar->gizmo_map);
364       }
365     }
366   }
367 }
368
369 /**
370  * Avoid bad-level calls to #WM_gizmomap_delete.
371  */
372 static void (*region_free_gizmomap_callback)(struct wmGizmoMap *) = NULL;
373
374 void BKE_region_callback_free_gizmomap_set(void (*callback)(struct wmGizmoMap *))
375 {
376   region_free_gizmomap_callback = callback;
377 }
378
379 void BKE_area_region_panels_free(ListBase *lb)
380 {
381   Panel *pa, *pa_next;
382   for (pa = lb->first; pa; pa = pa_next) {
383     pa_next = pa->next;
384     if (pa->activedata) {
385       MEM_freeN(pa->activedata);
386     }
387     BKE_area_region_panels_free(&pa->children);
388   }
389
390   BLI_freelistN(lb);
391 }
392
393 /* not region itself */
394 void BKE_area_region_free(SpaceType *st, ARegion *ar)
395 {
396   uiList *uilst;
397
398   if (st) {
399     ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
400
401     if (art && art->free)
402       art->free(ar);
403
404     if (ar->regiondata)
405       printf("regiondata free error\n");
406   }
407   else if (ar->type && ar->type->free)
408     ar->type->free(ar);
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       MEM_freeN(uilst->properties);
431     }
432   }
433
434   if (ar->gizmo_map != NULL) {
435     region_free_gizmomap_callback(ar->gizmo_map);
436   }
437
438   BLI_freelistN(&ar->ui_lists);
439   BLI_freelistN(&ar->ui_previews);
440   BLI_freelistN(&ar->panels_category);
441   BLI_freelistN(&ar->panels_category_active);
442 }
443
444 /* not area itself */
445 void BKE_screen_area_free(ScrArea *sa)
446 {
447   SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
448   ARegion *ar;
449
450   for (ar = sa->regionbase.first; ar; ar = ar->next)
451     BKE_area_region_free(st, ar);
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   BLI_freelistN(&sc->regionbase);
484
485   BKE_screen_area_map_free(AREAMAP_FROM_SCREEN(sc));
486
487   BKE_previewimg_free(&sc->preview);
488
489   /* Region and timer are freed by the window manager. */
490   MEM_SAFE_FREE(sc->tool_tip);
491 }
492
493 /* ***************** Screen edges & verts ***************** */
494
495 ScrEdge *BKE_screen_find_edge(bScreen *sc, ScrVert *v1, ScrVert *v2)
496 {
497   ScrEdge *se;
498
499   BKE_screen_sort_scrvert(&v1, &v2);
500   for (se = sc->edgebase.first; se; se = se->next) {
501     if (se->v1 == v1 && se->v2 == v2) {
502       return se;
503     }
504   }
505
506   return NULL;
507 }
508
509 void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2)
510 {
511   ScrVert *tmp;
512
513   if (*v1 > *v2) {
514     tmp = *v1;
515     *v1 = *v2;
516     *v2 = tmp;
517   }
518 }
519
520 void BKE_screen_remove_double_scrverts(bScreen *sc)
521 {
522   ScrVert *v1, *verg;
523   ScrEdge *se;
524   ScrArea *sa;
525
526   verg = sc->vertbase.first;
527   while (verg) {
528     if (verg->newv == NULL) { /* !!! */
529       v1 = verg->next;
530       while (v1) {
531         if (v1->newv == NULL) { /* !?! */
532           if (v1->vec.x == verg->vec.x && v1->vec.y == verg->vec.y) {
533             /* printf("doublevert\n"); */
534             v1->newv = verg;
535           }
536         }
537         v1 = v1->next;
538       }
539     }
540     verg = verg->next;
541   }
542
543   /* replace pointers in edges and faces */
544   se = sc->edgebase.first;
545   while (se) {
546     if (se->v1->newv)
547       se->v1 = se->v1->newv;
548     if (se->v2->newv)
549       se->v2 = se->v2->newv;
550     /* edges changed: so.... */
551     BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
552     se = se->next;
553   }
554   sa = sc->areabase.first;
555   while (sa) {
556     if (sa->v1->newv)
557       sa->v1 = sa->v1->newv;
558     if (sa->v2->newv)
559       sa->v2 = sa->v2->newv;
560     if (sa->v3->newv)
561       sa->v3 = sa->v3->newv;
562     if (sa->v4->newv)
563       sa->v4 = sa->v4->newv;
564     sa = sa->next;
565   }
566
567   /* remove */
568   verg = sc->vertbase.first;
569   while (verg) {
570     v1 = verg->next;
571     if (verg->newv) {
572       BLI_remlink(&sc->vertbase, verg);
573       MEM_freeN(verg);
574     }
575     verg = v1;
576   }
577 }
578
579 void BKE_screen_remove_double_scredges(bScreen *sc)
580 {
581   ScrEdge *verg, *se, *sn;
582
583   /* compare */
584   verg = sc->edgebase.first;
585   while (verg) {
586     se = verg->next;
587     while (se) {
588       sn = se->next;
589       if (verg->v1 == se->v1 && verg->v2 == se->v2) {
590         BLI_remlink(&sc->edgebase, se);
591         MEM_freeN(se);
592       }
593       se = sn;
594     }
595     verg = verg->next;
596   }
597 }
598
599 void BKE_screen_remove_unused_scredges(bScreen *sc)
600 {
601   ScrEdge *se, *sen;
602   ScrArea *sa;
603   int a = 0;
604
605   /* sets flags when edge is used in area */
606   sa = sc->areabase.first;
607   while (sa) {
608     se = BKE_screen_find_edge(sc, sa->v1, sa->v2);
609     if (se == NULL)
610       printf("error: area %d edge 1 doesn't exist\n", a);
611     else
612       se->flag = 1;
613     se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
614     if (se == NULL)
615       printf("error: area %d edge 2 doesn't exist\n", a);
616     else
617       se->flag = 1;
618     se = BKE_screen_find_edge(sc, sa->v3, sa->v4);
619     if (se == NULL)
620       printf("error: area %d edge 3 doesn't exist\n", a);
621     else
622       se->flag = 1;
623     se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
624     if (se == NULL)
625       printf("error: area %d edge 4 doesn't exist\n", a);
626     else
627       se->flag = 1;
628     sa = sa->next;
629     a++;
630   }
631   se = sc->edgebase.first;
632   while (se) {
633     sen = se->next;
634     if (se->flag == 0) {
635       BLI_remlink(&sc->edgebase, se);
636       MEM_freeN(se);
637     }
638     else {
639       se->flag = 0;
640     }
641     se = sen;
642   }
643 }
644
645 void BKE_screen_remove_unused_scrverts(bScreen *sc)
646 {
647   ScrVert *sv, *svn;
648   ScrEdge *se;
649
650   /* we assume edges are ok */
651
652   se = sc->edgebase.first;
653   while (se) {
654     se->v1->flag = 1;
655     se->v2->flag = 1;
656     se = se->next;
657   }
658
659   sv = sc->vertbase.first;
660   while (sv) {
661     svn = sv->next;
662     if (sv->flag == 0) {
663       BLI_remlink(&sc->vertbase, sv);
664       MEM_freeN(sv);
665     }
666     else {
667       sv->flag = 0;
668     }
669     sv = svn;
670   }
671 }
672
673 /* ***************** Utilities ********************** */
674
675 /**
676  * Find a region of type \a region_type in the currently active space of \a sa.
677  *
678  * \note This does _not_ work if the region to look up is not in the active
679  *       space. Use #BKE_spacedata_find_region_type if that may be the case.
680  */
681 ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
682 {
683   if (sa) {
684     for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
685       if (ar->regiontype == region_type)
686         return ar;
687     }
688   }
689
690   return NULL;
691 }
692
693 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
694 {
695   if (sa) {
696     ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
697     if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
698       return ar;
699     }
700
701     /* fallback to any */
702     return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
703   }
704   return NULL;
705 }
706
707 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
708 {
709   ARegion *ar_found = NULL;
710   if (sa) {
711     ARegion *ar;
712     for (ar = sa->regionbase.first; ar; ar = ar->next) {
713       if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
714         if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
715           ar_found = ar;
716           break;
717         }
718       }
719     }
720   }
721   return ar_found;
722 }
723
724 /**
725  * \note, ideally we can get the area from the context,
726  * there are a few places however where this isn't practical.
727  */
728 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
729 {
730   ScrArea *sa;
731
732   for (sa = sc->areabase.first; sa; sa = sa->next) {
733     if (BLI_findindex(&sa->spacedata, sl) != -1) {
734       break;
735     }
736   }
737
738   return sa;
739 }
740
741 /**
742  * \note Using this function is generally a last resort, you really want to be
743  * using the context when you can - campbell
744  */
745 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
746 {
747   ScrArea *sa, *big = NULL;
748   int size, maxsize = 0;
749
750   for (sa = sc->areabase.first; sa; sa = sa->next) {
751     if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
752       if (min <= sa->winx && min <= sa->winy) {
753         size = sa->winx * sa->winy;
754         if (size > maxsize) {
755           maxsize = size;
756           big = sa;
757         }
758       }
759     }
760   }
761
762   return big;
763 }
764
765 ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap,
766                                           const int spacetype,
767                                           int x,
768                                           int y)
769 {
770   for (ScrArea *sa = areamap->areabase.first; sa; sa = sa->next) {
771     if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
772       if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
773         return sa;
774       }
775       break;
776     }
777   }
778   return NULL;
779 }
780 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
781 {
782   return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
783 }
784
785 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
786 {
787   if (v3d->scenelock && v3d->localvd == NULL) {
788     v3d->camera = scene->camera;
789
790     if (v3d->camera == NULL) {
791       ARegion *ar;
792
793       for (ar = v3d->regionbase.first; ar; ar = ar->next) {
794         if (ar->regiontype == RGN_TYPE_WINDOW) {
795           RegionView3D *rv3d = ar->regiondata;
796           if (rv3d->persp == RV3D_CAMOB)
797             rv3d->persp = RV3D_PERSP;
798         }
799       }
800     }
801   }
802 }
803
804 void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
805 {
806   /* are there cameras in the views that are not in the scene? */
807   ScrArea *sa;
808   for (sa = sc->areabase.first; sa; sa = sa->next) {
809     SpaceLink *sl;
810     for (sl = sa->spacedata.first; sl; sl = sl->next) {
811       if (sl->spacetype == SPACE_VIEW3D) {
812         View3D *v3d = (View3D *)sl;
813         BKE_screen_view3d_sync(v3d, scene);
814       }
815     }
816   }
817 }
818
819 void BKE_screen_view3d_shading_init(View3DShading *shading)
820 {
821   memset(shading, 0, sizeof(*shading));
822
823   shading->type = OB_SOLID;
824   shading->prev_type = OB_SOLID;
825   shading->flag = V3D_SHADING_SPECULAR_HIGHLIGHT | V3D_SHADING_XRAY_BONE;
826   shading->light = V3D_LIGHTING_STUDIO;
827   shading->shadow_intensity = 0.5f;
828   shading->xray_alpha = 0.5f;
829   shading->xray_alpha_wire = 0.5f;
830   shading->cavity_valley_factor = 1.0f;
831   shading->cavity_ridge_factor = 1.0f;
832   shading->curvature_ridge_factor = 1.0f;
833   shading->curvature_valley_factor = 1.0f;
834   copy_v3_fl(shading->single_color, 0.8f);
835   copy_v3_fl(shading->background_color, 0.05f);
836 }
837
838 /* magic zoom calculation, no idea what
839  * it signifies, if you find out, tell me! -zr
840  */
841
842 /* simple, its magic dude!
843  * well, to be honest, this gives a natural feeling zooming
844  * with multiple keypad presses (ton)
845  */
846 float BKE_screen_view3d_zoom_to_fac(float camzoom)
847 {
848   return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
849 }
850
851 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
852 {
853   return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
854 }
855
856 bool BKE_screen_is_fullscreen_area(const bScreen *screen)
857 {
858   return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
859 }
860
861 bool BKE_screen_is_used(const bScreen *screen)
862 {
863   return (screen->winid != 0);
864 }
865
866 void BKE_screen_header_alignment_reset(bScreen *screen)
867 {
868   int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
869   for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
870     for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
871       if (ar->regiontype == RGN_TYPE_HEADER) {
872         if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
873           ar->alignment = RGN_ALIGN_TOP;
874           continue;
875         }
876         ar->alignment = alignment;
877       }
878       if (ar->regiontype == RGN_TYPE_FOOTER) {
879         if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
880           ar->alignment = RGN_ALIGN_BOTTOM;
881           continue;
882         }
883         ar->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_TOP : RGN_ALIGN_BOTTOM;
884       }
885     }
886   }
887   screen->do_refresh = true;
888 }