DNA: rename SpaceButs -> SpaceProperties
[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 \ingroup bke
21  */
22
23 #ifdef WIN32
24 #  include "BLI_winstuff.h"
25 #endif
26
27 #include <string.h>
28 #include <stdio.h>
29 #include <math.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_scene_types.h"
34 #include "DNA_screen_types.h"
35 #include "DNA_space_types.h"
36 #include "DNA_view3d_types.h"
37 #include "DNA_workspace_types.h"
38
39 #include "BLI_math_vector.h"
40 #include "BLI_listbase.h"
41 #include "BLI_rect.h"
42 #include "BLI_utildefines.h"
43
44 #include "BKE_icons.h"
45 #include "BKE_idprop.h"
46 #include "BKE_screen.h"
47 #include "BKE_workspace.h"
48
49 /* ************ Spacetype/regiontype handling ************** */
50
51 /* keep global; this has to be accessible outside of windowmanager */
52 static ListBase spacetypes = {NULL, NULL};
53
54 /* not SpaceType itself */
55 static void spacetype_free(SpaceType *st)
56 {
57         ARegionType *art;
58         PanelType *pt;
59         HeaderType *ht;
60
61         for (art = st->regiontypes.first; art; art = art->next) {
62                 BLI_freelistN(&art->drawcalls);
63
64                 for (pt = art->paneltypes.first; pt; pt = pt->next) {
65                         if (pt->ext.free) {
66                                 pt->ext.free(pt->ext.data);
67                         }
68
69                         BLI_freelistN(&pt->children);
70                 }
71
72                 for (ht = art->headertypes.first; ht; ht = ht->next) {
73                         if (ht->ext.free) {
74                                 ht->ext.free(ht->ext.data);
75                         }
76                 }
77
78                 BLI_freelistN(&art->paneltypes);
79                 BLI_freelistN(&art->headertypes);
80         }
81
82         BLI_freelistN(&st->regiontypes);
83 }
84
85 void BKE_spacetypes_free(void)
86 {
87         SpaceType *st;
88
89         for (st = spacetypes.first; st; st = st->next) {
90                 spacetype_free(st);
91         }
92
93         BLI_freelistN(&spacetypes);
94 }
95
96 SpaceType *BKE_spacetype_from_id(int spaceid)
97 {
98         SpaceType *st;
99
100         for (st = spacetypes.first; st; st = st->next) {
101                 if (st->spaceid == spaceid)
102                         return st;
103         }
104         return NULL;
105 }
106
107 ARegionType *BKE_regiontype_from_id_or_first(SpaceType *st, int regionid)
108 {
109         ARegionType *art;
110
111         for (art = st->regiontypes.first; art; art = art->next)
112                 if (art->regionid == regionid)
113                         return art;
114
115         printf("Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
116         return st->regiontypes.first;
117 }
118
119 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
120 {
121         ARegionType *art;
122
123         for (art = st->regiontypes.first; art; art = art->next) {
124                 if (art->regionid == regionid) {
125                         return art;
126                 }
127         }
128         return NULL;
129 }
130
131
132 const ListBase *BKE_spacetypes_list(void)
133 {
134         return &spacetypes;
135 }
136
137 void BKE_spacetype_register(SpaceType *st)
138 {
139         SpaceType *stype;
140
141         /* sanity check */
142         stype = BKE_spacetype_from_id(st->spaceid);
143         if (stype) {
144                 printf("error: redefinition of spacetype %s\n", stype->name);
145                 spacetype_free(stype);
146                 MEM_freeN(stype);
147         }
148
149         BLI_addtail(&spacetypes, st);
150 }
151
152 bool BKE_spacetype_exists(int spaceid)
153 {
154         return BKE_spacetype_from_id(spaceid) != NULL;
155 }
156
157 /* ***************** Space handling ********************** */
158
159 void BKE_spacedata_freelist(ListBase *lb)
160 {
161         SpaceLink *sl;
162         ARegion *ar;
163
164         for (sl = lb->first; sl; sl = sl->next) {
165                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
166
167                 /* free regions for pushed spaces */
168                 for (ar = sl->regionbase.first; ar; ar = ar->next)
169                         BKE_area_region_free(st, ar);
170
171                 BLI_freelistN(&sl->regionbase);
172
173                 if (st && st->free)
174                         st->free(sl);
175         }
176
177         BLI_freelistN(lb);
178 }
179
180 static void panel_list_copy(ListBase *newlb, const ListBase *lb)
181 {
182         BLI_listbase_clear(newlb);
183         BLI_duplicatelist(newlb, lb);
184
185         /* copy panel pointers */
186         Panel *newpa = newlb->first;
187         Panel *pa = lb->first;
188         for (; newpa; newpa = newpa->next, pa = pa->next) {
189                 newpa->activedata = NULL;
190
191                 Panel *newpatab = newlb->first;
192                 Panel *patab = lb->first;
193                 while (newpatab) {
194                         if (newpa->paneltab == patab) {
195                                 newpa->paneltab = newpatab;
196                                 break;
197                         }
198                         newpatab = newpatab->next;
199                         patab = patab->next;
200                 }
201
202                 panel_list_copy(&newpa->children, &pa->children);
203         }
204 }
205
206 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
207 {
208         ARegion *newar = MEM_dupallocN(ar);
209
210         newar->prev = newar->next = NULL;
211         BLI_listbase_clear(&newar->handlers);
212         BLI_listbase_clear(&newar->uiblocks);
213         BLI_listbase_clear(&newar->panels_category);
214         BLI_listbase_clear(&newar->panels_category_active);
215         BLI_listbase_clear(&newar->ui_lists);
216         newar->visible = 0;
217         newar->gizmo_map = NULL;
218         newar->regiontimer = NULL;
219         newar->headerstr = NULL;
220         newar->draw_buffer = NULL;
221
222         /* use optional regiondata callback */
223         if (ar->regiondata) {
224                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
225
226                 if (art && art->duplicate) {
227                         newar->regiondata = art->duplicate(ar->regiondata);
228                 }
229                 else if (ar->flag & RGN_FLAG_TEMP_REGIONDATA) {
230                         newar->regiondata = NULL;
231                 }
232                 else {
233                         newar->regiondata = MEM_dupallocN(ar->regiondata);
234                 }
235         }
236
237         if (ar->v2d.tab_offset)
238                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
239
240         panel_list_copy(&newar->panels, &ar->panels);
241
242         BLI_listbase_clear(&newar->ui_previews);
243         BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
244
245         return newar;
246 }
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
264 /* lb1 should be empty */
265 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
266 {
267         SpaceLink *sl;
268
269         BLI_listbase_clear(lb1);  /* to be sure */
270
271         for (sl = lb2->first; sl; sl = sl->next) {
272                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
273
274                 if (st && st->duplicate) {
275                         SpaceLink *slnew = st->duplicate(sl);
276
277                         BLI_addtail(lb1, slnew);
278
279                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
280                 }
281         }
282 }
283
284 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
285 /* lock can become bitflag too */
286 /* should be replaced in future by better local data handling for threads */
287 void BKE_spacedata_draw_locks(int set)
288 {
289         SpaceType *st;
290
291         for (st = spacetypes.first; st; st = st->next) {
292                 ARegionType *art;
293
294                 for (art = st->regiontypes.first; art; art = art->next) {
295                         if (set)
296                                 art->do_lock = art->lock;
297                         else
298                                 art->do_lock = false;
299                 }
300         }
301 }
302
303 /**
304  * Version of #BKE_area_find_region_type that also works if \a slink is not the active space of \a sa.
305  */
306 ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *sa, int region_type)
307 {
308         const bool is_slink_active = slink == sa->spacedata.first;
309         const ListBase *regionbase = (is_slink_active) ?
310                                    &sa->regionbase : &slink->regionbase;
311         ARegion *ar = NULL;
312
313         BLI_assert(BLI_findindex(&sa->spacedata, slink) != -1);
314         for (ar = regionbase->first; ar; ar = ar->next) {
315                 if (ar->regiontype == region_type) {
316                         break;
317                 }
318         }
319
320         /* Should really unit test this instead. */
321         BLI_assert(!is_slink_active || ar == BKE_area_find_region_type(sa, region_type));
322
323         return ar;
324 }
325
326
327 static void (*spacedata_id_remap_cb)(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, 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) se->v1 = se->v1->newv;
547                 if (se->v2->newv) se->v2 = se->v2->newv;
548                 /* edges changed: so.... */
549                 BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
550                 se = se->next;
551         }
552         sa = sc->areabase.first;
553         while (sa) {
554                 if (sa->v1->newv) sa->v1 = sa->v1->newv;
555                 if (sa->v2->newv) sa->v2 = sa->v2->newv;
556                 if (sa->v3->newv) sa->v3 = sa->v3->newv;
557                 if (sa->v4->newv) sa->v4 = sa->v4->newv;
558                 sa = sa->next;
559         }
560
561         /* remove */
562         verg = sc->vertbase.first;
563         while (verg) {
564                 v1 = verg->next;
565                 if (verg->newv) {
566                         BLI_remlink(&sc->vertbase, verg);
567                         MEM_freeN(verg);
568                 }
569                 verg = v1;
570         }
571
572 }
573
574 void BKE_screen_remove_double_scredges(bScreen *sc)
575 {
576         ScrEdge *verg, *se, *sn;
577
578         /* compare */
579         verg = sc->edgebase.first;
580         while (verg) {
581                 se = verg->next;
582                 while (se) {
583                         sn = se->next;
584                         if (verg->v1 == se->v1 && verg->v2 == se->v2) {
585                                 BLI_remlink(&sc->edgebase, se);
586                                 MEM_freeN(se);
587                         }
588                         se = sn;
589                 }
590                 verg = verg->next;
591         }
592 }
593
594 void BKE_screen_remove_unused_scredges(bScreen *sc)
595 {
596         ScrEdge *se, *sen;
597         ScrArea *sa;
598         int a = 0;
599
600         /* sets flags when edge is used in area */
601         sa = sc->areabase.first;
602         while (sa) {
603                 se = BKE_screen_find_edge(sc, sa->v1, sa->v2);
604                 if (se == NULL) printf("error: area %d edge 1 doesn't exist\n", a);
605                 else se->flag = 1;
606                 se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
607                 if (se == NULL) printf("error: area %d edge 2 doesn't exist\n", a);
608                 else se->flag = 1;
609                 se = BKE_screen_find_edge(sc, sa->v3, sa->v4);
610                 if (se == NULL) printf("error: area %d edge 3 doesn't exist\n", a);
611                 else se->flag = 1;
612                 se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
613                 if (se == NULL) printf("error: area %d edge 4 doesn't exist\n", a);
614                 else se->flag = 1;
615                 sa = sa->next;
616                 a++;
617         }
618         se = sc->edgebase.first;
619         while (se) {
620                 sen = se->next;
621                 if (se->flag == 0) {
622                         BLI_remlink(&sc->edgebase, se);
623                         MEM_freeN(se);
624                 }
625                 else {
626                         se->flag = 0;
627                 }
628                 se = sen;
629         }
630 }
631
632 void BKE_screen_remove_unused_scrverts(bScreen *sc)
633 {
634         ScrVert *sv, *svn;
635         ScrEdge *se;
636
637         /* we assume edges are ok */
638
639         se = sc->edgebase.first;
640         while (se) {
641                 se->v1->flag = 1;
642                 se->v2->flag = 1;
643                 se = se->next;
644         }
645
646         sv = sc->vertbase.first;
647         while (sv) {
648                 svn = sv->next;
649                 if (sv->flag == 0) {
650                         BLI_remlink(&sc->vertbase, sv);
651                         MEM_freeN(sv);
652                 }
653                 else {
654                         sv->flag = 0;
655                 }
656                 sv = svn;
657         }
658 }
659
660 /* ***************** Utilities ********************** */
661
662 /**
663  * Find a region of type \a region_type in the currently active space of \a sa.
664  *
665  * \note This does _not_ work if the region to look up is not in the active
666  *       space. Use #BKE_spacedata_find_region_type if that may be the case.
667  */
668 ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
669 {
670         if (sa) {
671                 for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
672                         if (ar->regiontype == region_type)
673                                 return ar;
674                 }
675         }
676
677         return NULL;
678 }
679
680 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
681 {
682         if (sa) {
683                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
684                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
685                         return ar;
686                 }
687
688                 /* fallback to any */
689                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
690         }
691         return NULL;
692 }
693
694 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
695 {
696         ARegion *ar_found = NULL;
697         if (sa) {
698                 ARegion *ar;
699                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
700                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
701                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
702                                         ar_found = ar;
703                                         break;
704                                 }
705                         }
706                 }
707         }
708         return ar_found;
709 }
710
711 /**
712  * \note, ideally we can get the area from the context,
713  * there are a few places however where this isn't practical.
714  */
715 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
716 {
717         ScrArea *sa;
718
719         for (sa = sc->areabase.first; sa; sa = sa->next) {
720                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
721                         break;
722                 }
723         }
724
725         return sa;
726 }
727
728 /**
729  * \note Using this function is generally a last resort, you really want to be
730  * using the context when you can - campbell
731  */
732 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
733 {
734         ScrArea *sa, *big = NULL;
735         int size, maxsize = 0;
736
737         for (sa = sc->areabase.first; sa; sa = sa->next) {
738                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
739                         if (min <= sa->winx && min <= sa->winy) {
740                                 size = sa->winx * sa->winy;
741                                 if (size > maxsize) {
742                                         maxsize = size;
743                                         big = sa;
744                                 }
745                         }
746                 }
747         }
748
749         return big;
750 }
751
752 ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap, const int spacetype, int x, int y)
753 {
754         for (ScrArea *sa = areamap->areabase.first; sa; sa = sa->next) {
755                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
756                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
757                                 return sa;
758                         }
759                         break;
760                 }
761         }
762         return NULL;
763 }
764 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
765 {
766         return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
767 }
768
769 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
770 {
771         if (v3d->scenelock && v3d->localvd == NULL) {
772                 v3d->camera = scene->camera;
773
774                 if (v3d->camera == NULL) {
775                         ARegion *ar;
776
777                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
778                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
779                                         RegionView3D *rv3d = ar->regiondata;
780                                         if (rv3d->persp == RV3D_CAMOB)
781                                                 rv3d->persp = RV3D_PERSP;
782                                 }
783                         }
784                 }
785         }
786 }
787
788 void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
789 {
790         /* are there cameras in the views that are not in the scene? */
791         ScrArea *sa;
792         for (sa = sc->areabase.first; sa; sa = sa->next) {
793                 SpaceLink *sl;
794                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
795                         if (sl->spacetype == SPACE_VIEW3D) {
796                                 View3D *v3d = (View3D *) sl;
797                                 BKE_screen_view3d_sync(v3d, scene);
798                         }
799                 }
800         }
801 }
802
803 void BKE_screen_view3d_shading_init(View3DShading *shading)
804 {
805         memset(shading, 0, sizeof(*shading));
806
807         shading->type = OB_SOLID;
808         shading->prev_type = OB_SOLID;
809         shading->flag = V3D_SHADING_SPECULAR_HIGHLIGHT | V3D_SHADING_XRAY_BONE;
810         shading->light = V3D_LIGHTING_STUDIO;
811         shading->shadow_intensity = 0.5f;
812         shading->xray_alpha = 0.5f;
813         shading->xray_alpha_wire = 0.5f;
814         shading->cavity_valley_factor = 1.0f;
815         shading->cavity_ridge_factor = 1.0f;
816         shading->curvature_ridge_factor = 1.0f;
817         shading->curvature_valley_factor = 1.0f;
818         copy_v3_fl(shading->single_color, 0.8f);
819         copy_v3_fl(shading->background_color, 0.05f);
820 }
821
822 /* magic zoom calculation, no idea what
823  * it signifies, if you find out, tell me! -zr
824  */
825
826 /* simple, its magic dude!
827  * well, to be honest, this gives a natural feeling zooming
828  * with multiple keypad presses (ton)
829  */
830 float BKE_screen_view3d_zoom_to_fac(float camzoom)
831 {
832         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
833 }
834
835 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
836 {
837         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
838 }
839
840 bool BKE_screen_is_fullscreen_area(const bScreen *screen)
841 {
842         return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
843 }
844
845 bool BKE_screen_is_used(const bScreen *screen)
846 {
847         return (screen->winid != 0);
848 }
849
850 void BKE_screen_header_alignment_reset(bScreen *screen)
851 {
852         int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
853         for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
854                 for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
855                         if (ar->regiontype == RGN_TYPE_HEADER) {
856                                 if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
857                                         ar->alignment = RGN_ALIGN_TOP;
858                                         continue;
859                                 }
860                                 ar->alignment = alignment;
861                         }
862                 }
863         }
864         screen->do_refresh = true;
865 }