Merge branch 'blender2.7'
[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("Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
117         return st->regiontypes.first;
118 }
119
120 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
121 {
122         ARegionType *art;
123
124         for (art = st->regiontypes.first; art; art = art->next) {
125                 if (art->regionid == regionid) {
126                         return art;
127                 }
128         }
129         return NULL;
130 }
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
250 /* from lb2 to lb1, lb1 is supposed to be freed */
251 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
252 {
253         ARegion *ar;
254
255         /* to be sure */
256         BLI_listbase_clear(lb1);
257
258         for (ar = lb2->first; ar; ar = ar->next) {
259                 ARegion *arnew = BKE_area_region_copy(st, ar);
260                 BLI_addtail(lb1, arnew);
261         }
262 }
263
264
265 /* lb1 should be empty */
266 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
267 {
268         SpaceLink *sl;
269
270         BLI_listbase_clear(lb1);  /* to be sure */
271
272         for (sl = lb2->first; sl; sl = sl->next) {
273                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
274
275                 if (st && st->duplicate) {
276                         SpaceLink *slnew = st->duplicate(sl);
277
278                         BLI_addtail(lb1, slnew);
279
280                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
281                 }
282         }
283 }
284
285 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
286 /* lock can become bitflag too */
287 /* should be replaced in future by better local data handling for threads */
288 void BKE_spacedata_draw_locks(int set)
289 {
290         SpaceType *st;
291
292         for (st = spacetypes.first; st; st = st->next) {
293                 ARegionType *art;
294
295                 for (art = st->regiontypes.first; art; art = art->next) {
296                         if (set)
297                                 art->do_lock = art->lock;
298                         else
299                                 art->do_lock = false;
300                 }
301         }
302 }
303
304 /**
305  * Version of #BKE_area_find_region_type that also works if \a slink is not the active space of \a sa.
306  */
307 ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *sa, int region_type)
308 {
309         const bool is_slink_active = slink == sa->spacedata.first;
310         const ListBase *regionbase = (is_slink_active) ?
311                                    &sa->regionbase : &slink->regionbase;
312         ARegion *ar = NULL;
313
314         BLI_assert(BLI_findindex(&sa->spacedata, slink) != -1);
315         for (ar = regionbase->first; ar; ar = ar->next) {
316                 if (ar->regiontype == region_type) {
317                         break;
318                 }
319         }
320
321         /* Should really unit test this instead. */
322         BLI_assert(!is_slink_active || ar == BKE_area_find_region_type(sa, region_type));
323
324         return ar;
325 }
326
327
328 static void (*spacedata_id_remap_cb)(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, ID *new_id) = NULL;
329
330 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
331 {
332         spacedata_id_remap_cb = func;
333 }
334
335 /* UNUSED!!! */
336 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
337 {
338         if (spacedata_id_remap_cb) {
339                 spacedata_id_remap_cb(sa, sl, id, NULL);
340         }
341 }
342
343 /**
344  * Avoid bad-level calls to #WM_gizmomap_tag_refresh.
345  */
346 static void (*region_refresh_tag_gizmomap_callback)(struct wmGizmoMap *) = NULL;
347
348 void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(struct wmGizmoMap *))
349 {
350         region_refresh_tag_gizmomap_callback = callback;
351 }
352
353 void BKE_screen_gizmo_tag_refresh(struct bScreen *sc)
354 {
355         if (region_refresh_tag_gizmomap_callback == NULL) {
356                 return;
357         }
358
359         ScrArea *sa;
360         ARegion *ar;
361         for (sa = sc->areabase.first; sa; sa = sa->next) {
362                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
363                         if (ar->gizmo_map != NULL) {
364                                 region_refresh_tag_gizmomap_callback(ar->gizmo_map);
365                         }
366                 }
367         }
368 }
369
370 /**
371  * Avoid bad-level calls to #WM_gizmomap_delete.
372  */
373 static void (*region_free_gizmomap_callback)(struct wmGizmoMap *) = NULL;
374
375 void BKE_region_callback_free_gizmomap_set(void (*callback)(struct wmGizmoMap *))
376 {
377         region_free_gizmomap_callback = callback;
378 }
379
380 void BKE_area_region_panels_free(ListBase *lb)
381 {
382         Panel *pa, *pa_next;
383         for (pa = lb->first; pa; pa = pa_next) {
384                 pa_next = pa->next;
385                 if (pa->activedata) {
386                         MEM_freeN(pa->activedata);
387                 }
388                 BKE_area_region_panels_free(&pa->children);
389         }
390
391         BLI_freelistN(lb);
392 }
393
394 /* not region itself */
395 void BKE_area_region_free(SpaceType *st, ARegion *ar)
396 {
397         uiList *uilst;
398
399         if (st) {
400                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
401
402                 if (art && art->free)
403                         art->free(ar);
404
405                 if (ar->regiondata)
406                         printf("regiondata free error\n");
407         }
408         else if (ar->type && ar->type->free)
409                 ar->type->free(ar);
410
411         if (ar->v2d.tab_offset) {
412                 MEM_freeN(ar->v2d.tab_offset);
413                 ar->v2d.tab_offset = NULL;
414         }
415
416         BKE_area_region_panels_free(&ar->panels);
417
418         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
419                 if (uilst->dyn_data) {
420                         uiListDyn *dyn_data = uilst->dyn_data;
421                         if (dyn_data->items_filter_flags) {
422                                 MEM_freeN(dyn_data->items_filter_flags);
423                         }
424                         if (dyn_data->items_filter_neworder) {
425                                 MEM_freeN(dyn_data->items_filter_neworder);
426                         }
427                         MEM_freeN(dyn_data);
428                 }
429                 if (uilst->properties) {
430                         IDP_FreeProperty(uilst->properties);
431                         MEM_freeN(uilst->properties);
432                 }
433         }
434
435         if (ar->gizmo_map != NULL) {
436                 region_free_gizmomap_callback(ar->gizmo_map);
437         }
438
439         BLI_freelistN(&ar->ui_lists);
440         BLI_freelistN(&ar->ui_previews);
441         BLI_freelistN(&ar->panels_category);
442         BLI_freelistN(&ar->panels_category_active);
443 }
444
445 /* not area itself */
446 void BKE_screen_area_free(ScrArea *sa)
447 {
448         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
449         ARegion *ar;
450
451         for (ar = sa->regionbase.first; ar; ar = ar->next)
452                 BKE_area_region_free(st, ar);
453
454         MEM_SAFE_FREE(sa->global);
455         BLI_freelistN(&sa->regionbase);
456
457         BKE_spacedata_freelist(&sa->spacedata);
458
459         BLI_freelistN(&sa->actionzones);
460 }
461
462 void BKE_screen_area_map_free(ScrAreaMap *area_map)
463 {
464         for (ScrArea *area = area_map->areabase.first, *area_next; area; area = area_next) {
465                 area_next = area->next;
466                 BKE_screen_area_free(area);
467         }
468
469         BLI_freelistN(&area_map->vertbase);
470         BLI_freelistN(&area_map->edgebase);
471         BLI_freelistN(&area_map->areabase);
472 }
473
474 /** Free (or release) any data used by this screen (does not free the screen itself). */
475 void BKE_screen_free(bScreen *sc)
476 {
477         ARegion *ar;
478
479         /* No animdata here. */
480
481         for (ar = sc->regionbase.first; ar; ar = ar->next)
482                 BKE_area_region_free(NULL, ar);
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) se->v1 = se->v1->newv;
548                 if (se->v2->newv) se->v2 = se->v2->newv;
549                 /* edges changed: so.... */
550                 BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
551                 se = se->next;
552         }
553         sa = sc->areabase.first;
554         while (sa) {
555                 if (sa->v1->newv) sa->v1 = sa->v1->newv;
556                 if (sa->v2->newv) sa->v2 = sa->v2->newv;
557                 if (sa->v3->newv) sa->v3 = sa->v3->newv;
558                 if (sa->v4->newv) sa->v4 = sa->v4->newv;
559                 sa = sa->next;
560         }
561
562         /* remove */
563         verg = sc->vertbase.first;
564         while (verg) {
565                 v1 = verg->next;
566                 if (verg->newv) {
567                         BLI_remlink(&sc->vertbase, verg);
568                         MEM_freeN(verg);
569                 }
570                 verg = v1;
571         }
572
573 }
574
575 void BKE_screen_remove_double_scredges(bScreen *sc)
576 {
577         ScrEdge *verg, *se, *sn;
578
579         /* compare */
580         verg = sc->edgebase.first;
581         while (verg) {
582                 se = verg->next;
583                 while (se) {
584                         sn = se->next;
585                         if (verg->v1 == se->v1 && verg->v2 == se->v2) {
586                                 BLI_remlink(&sc->edgebase, se);
587                                 MEM_freeN(se);
588                         }
589                         se = sn;
590                 }
591                 verg = verg->next;
592         }
593 }
594
595 void BKE_screen_remove_unused_scredges(bScreen *sc)
596 {
597         ScrEdge *se, *sen;
598         ScrArea *sa;
599         int a = 0;
600
601         /* sets flags when edge is used in area */
602         sa = sc->areabase.first;
603         while (sa) {
604                 se = BKE_screen_find_edge(sc, sa->v1, sa->v2);
605                 if (se == NULL) printf("error: area %d edge 1 doesn't exist\n", a);
606                 else se->flag = 1;
607                 se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
608                 if (se == NULL) printf("error: area %d edge 2 doesn't exist\n", a);
609                 else se->flag = 1;
610                 se = BKE_screen_find_edge(sc, sa->v3, sa->v4);
611                 if (se == NULL) printf("error: area %d edge 3 doesn't exist\n", a);
612                 else se->flag = 1;
613                 se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
614                 if (se == NULL) printf("error: area %d edge 4 doesn't exist\n", a);
615                 else se->flag = 1;
616                 sa = sa->next;
617                 a++;
618         }
619         se = sc->edgebase.first;
620         while (se) {
621                 sen = se->next;
622                 if (se->flag == 0) {
623                         BLI_remlink(&sc->edgebase, se);
624                         MEM_freeN(se);
625                 }
626                 else {
627                         se->flag = 0;
628                 }
629                 se = sen;
630         }
631 }
632
633 void BKE_screen_remove_unused_scrverts(bScreen *sc)
634 {
635         ScrVert *sv, *svn;
636         ScrEdge *se;
637
638         /* we assume edges are ok */
639
640         se = sc->edgebase.first;
641         while (se) {
642                 se->v1->flag = 1;
643                 se->v2->flag = 1;
644                 se = se->next;
645         }
646
647         sv = sc->vertbase.first;
648         while (sv) {
649                 svn = sv->next;
650                 if (sv->flag == 0) {
651                         BLI_remlink(&sc->vertbase, sv);
652                         MEM_freeN(sv);
653                 }
654                 else {
655                         sv->flag = 0;
656                 }
657                 sv = svn;
658         }
659 }
660
661 /* ***************** Utilities ********************** */
662
663 /**
664  * Find a region of type \a region_type in the currently active space of \a sa.
665  *
666  * \note This does _not_ work if the region to look up is not in the active
667  *       space. Use #BKE_spacedata_find_region_type if that may be the case.
668  */
669 ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
670 {
671         if (sa) {
672                 for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
673                         if (ar->regiontype == region_type)
674                                 return ar;
675                 }
676         }
677
678         return NULL;
679 }
680
681 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
682 {
683         if (sa) {
684                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
685                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
686                         return ar;
687                 }
688
689                 /* fallback to any */
690                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
691         }
692         return NULL;
693 }
694
695 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
696 {
697         ARegion *ar_found = NULL;
698         if (sa) {
699                 ARegion *ar;
700                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
701                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
702                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
703                                         ar_found = ar;
704                                         break;
705                                 }
706                         }
707                 }
708         }
709         return ar_found;
710 }
711
712 /**
713  * \note, ideally we can get the area from the context,
714  * there are a few places however where this isn't practical.
715  */
716 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
717 {
718         ScrArea *sa;
719
720         for (sa = sc->areabase.first; sa; sa = sa->next) {
721                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
722                         break;
723                 }
724         }
725
726         return sa;
727 }
728
729 /**
730  * \note Using this function is generally a last resort, you really want to be
731  * using the context when you can - campbell
732  */
733 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
734 {
735         ScrArea *sa, *big = NULL;
736         int size, maxsize = 0;
737
738         for (sa = sc->areabase.first; sa; sa = sa->next) {
739                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
740                         if (min <= sa->winx && min <= sa->winy) {
741                                 size = sa->winx * sa->winy;
742                                 if (size > maxsize) {
743                                         maxsize = size;
744                                         big = sa;
745                                 }
746                         }
747                 }
748         }
749
750         return big;
751 }
752
753 ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap, const int spacetype, int x, int y)
754 {
755         for (ScrArea *sa = areamap->areabase.first; sa; sa = sa->next) {
756                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
757                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
758                                 return sa;
759                         }
760                         break;
761                 }
762         }
763         return NULL;
764 }
765 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
766 {
767         return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
768 }
769
770 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
771 {
772         if (v3d->scenelock && v3d->localvd == NULL) {
773                 v3d->camera = scene->camera;
774
775                 if (v3d->camera == NULL) {
776                         ARegion *ar;
777
778                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
779                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
780                                         RegionView3D *rv3d = ar->regiondata;
781                                         if (rv3d->persp == RV3D_CAMOB)
782                                                 rv3d->persp = RV3D_PERSP;
783                                 }
784                         }
785                 }
786         }
787 }
788
789 void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
790 {
791         /* are there cameras in the views that are not in the scene? */
792         ScrArea *sa;
793         for (sa = sc->areabase.first; sa; sa = sa->next) {
794                 SpaceLink *sl;
795                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
796                         if (sl->spacetype == SPACE_VIEW3D) {
797                                 View3D *v3d = (View3D *) sl;
798                                 BKE_screen_view3d_sync(v3d, scene);
799                         }
800                 }
801         }
802 }
803
804 void BKE_screen_view3d_shading_init(View3DShading *shading)
805 {
806         memset(shading, 0, sizeof(*shading));
807
808         shading->type = OB_SOLID;
809         shading->prev_type = OB_SOLID;
810         shading->flag = V3D_SHADING_SPECULAR_HIGHLIGHT | V3D_SHADING_XRAY_BONE;
811         shading->light = V3D_LIGHTING_STUDIO;
812         shading->shadow_intensity = 0.5f;
813         shading->xray_alpha = 0.5f;
814         shading->xray_alpha_wire = 0.5f;
815         shading->cavity_valley_factor = 1.0f;
816         shading->cavity_ridge_factor = 1.0f;
817         shading->curvature_ridge_factor = 1.0f;
818         shading->curvature_valley_factor = 1.0f;
819         copy_v3_fl(shading->single_color, 0.8f);
820         copy_v3_fl(shading->background_color, 0.05f);
821 }
822
823 /* magic zoom calculation, no idea what
824  * it signifies, if you find out, tell me! -zr
825  */
826
827 /* simple, its magic dude!
828  * well, to be honest, this gives a natural feeling zooming
829  * with multiple keypad presses (ton)
830  */
831 float BKE_screen_view3d_zoom_to_fac(float camzoom)
832 {
833         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
834 }
835
836 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
837 {
838         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
839 }
840
841 bool BKE_screen_is_fullscreen_area(const bScreen *screen)
842 {
843         return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);
844 }
845
846 bool BKE_screen_is_used(const bScreen *screen)
847 {
848         return (screen->winid != 0);
849 }
850
851 void BKE_screen_header_alignment_reset(bScreen *screen)
852 {
853         int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
854         for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
855                 for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
856                         if (ar->regiontype == RGN_TYPE_HEADER) {
857                                 if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
858                                         ar->alignment = RGN_ALIGN_TOP;
859                                         continue;
860                                 }
861                                 ar->alignment = alignment;
862                         }
863                 }
864         }
865         screen->do_refresh = true;
866 }