2b1cf0a01df054eb88f45f2e0e71c64394b8187c
[blender.git] / source / blender / blenkernel / intern / screen.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/screen.c
29  *  \ingroup bke
30  */
31
32 #ifdef WIN32
33 #  include "BLI_winstuff.h"
34 #endif
35
36 #include <string.h>
37 #include <stdio.h>
38 #include <math.h>
39
40 #include "MEM_guardedalloc.h"
41
42 #include "GPU_compositing.h"
43
44 #include "DNA_scene_types.h"
45 #include "DNA_screen_types.h"
46 #include "DNA_space_types.h"
47 #include "DNA_view3d_types.h"
48
49 #include "BLI_listbase.h"
50 #include "BLI_utildefines.h"
51 #include "BLI_rect.h"
52
53 #include "BKE_idprop.h"
54 #include "BKE_screen.h"
55
56 /* ************ Spacetype/regiontype handling ************** */
57
58 /* keep global; this has to be accessible outside of windowmanager */
59 static ListBase spacetypes = {NULL, NULL};
60
61 /* not SpaceType itself */
62 static void spacetype_free(SpaceType *st)
63 {
64         ARegionType *art;
65         PanelType *pt;
66         HeaderType *ht;
67         
68         for (art = st->regiontypes.first; art; art = art->next) {
69                 BLI_freelistN(&art->drawcalls);
70
71                 for (pt = art->paneltypes.first; pt; pt = pt->next)
72                         if (pt->ext.free)
73                                 pt->ext.free(pt->ext.data);
74
75                 for (ht = art->headertypes.first; ht; ht = ht->next)
76                         if (ht->ext.free)
77                                 ht->ext.free(ht->ext.data);
78
79                 BLI_freelistN(&art->paneltypes);
80                 BLI_freelistN(&art->headertypes);
81         }
82         
83         BLI_freelistN(&st->regiontypes);
84         BLI_freelistN(&st->toolshelf);
85
86 }
87
88 void BKE_spacetypes_free(void)
89 {
90         SpaceType *st;
91         
92         for (st = spacetypes.first; st; st = st->next) {
93                 spacetype_free(st);
94         }
95         
96         BLI_freelistN(&spacetypes);
97 }
98
99 SpaceType *BKE_spacetype_from_id(int spaceid)
100 {
101         SpaceType *st;
102         
103         for (st = spacetypes.first; st; st = st->next) {
104                 if (st->spaceid == spaceid)
105                         return st;
106         }
107         return NULL;
108 }
109
110 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
111 {
112         ARegionType *art;
113         
114         for (art = st->regiontypes.first; art; art = art->next)
115                 if (art->regionid == regionid)
116                         return art;
117         
118         printf("Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
119         return st->regiontypes.first;
120 }
121
122
123 const ListBase *BKE_spacetypes_list(void)
124 {
125         return &spacetypes;
126 }
127
128 void BKE_spacetype_register(SpaceType *st)
129 {
130         SpaceType *stype;
131         
132         /* sanity check */
133         stype = BKE_spacetype_from_id(st->spaceid);
134         if (stype) {
135                 printf("error: redefinition of spacetype %s\n", stype->name);
136                 spacetype_free(stype);
137                 MEM_freeN(stype);
138         }
139         
140         BLI_addtail(&spacetypes, st);
141 }
142
143 bool BKE_spacetype_exists(int spaceid)
144 {
145         return BKE_spacetype_from_id(spaceid) != NULL;
146 }
147
148 /* ***************** Space handling ********************** */
149
150 void BKE_spacedata_freelist(ListBase *lb)
151 {
152         SpaceLink *sl;
153         ARegion *ar;
154         
155         for (sl = lb->first; sl; sl = sl->next) {
156                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
157                 
158                 /* free regions for pushed spaces */
159                 for (ar = sl->regionbase.first; ar; ar = ar->next)
160                         BKE_area_region_free(st, ar);
161
162                 BLI_freelistN(&sl->regionbase);
163                 
164                 if (st && st->free) 
165                         st->free(sl);
166         }
167         
168         BLI_freelistN(lb);
169 }
170
171 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
172 {
173         ARegion *newar = MEM_dupallocN(ar);
174         Panel *pa, *newpa, *patab;
175         
176         newar->prev = newar->next = NULL;
177         BLI_listbase_clear(&newar->handlers);
178         BLI_listbase_clear(&newar->uiblocks);
179         BLI_listbase_clear(&newar->panels_category);
180         BLI_listbase_clear(&newar->panels_category_active);
181         BLI_listbase_clear(&newar->ui_lists);
182         newar->swinid = 0;
183         newar->regiontimer = NULL;
184         newar->headerstr = NULL;
185         
186         /* use optional regiondata callback */
187         if (ar->regiondata) {
188                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
189
190                 if (art && art->duplicate)
191                         newar->regiondata = art->duplicate(ar->regiondata);
192                 else
193                         newar->regiondata = MEM_dupallocN(ar->regiondata);
194         }
195
196         if (ar->v2d.tab_offset)
197                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
198         
199         BLI_listbase_clear(&newar->panels);
200         BLI_duplicatelist(&newar->panels, &ar->panels);
201
202         BLI_listbase_clear(&newar->ui_previews);
203         BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
204
205         /* copy panel pointers */
206         for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
207                 patab = newar->panels.first;
208                 pa = ar->panels.first;
209                 while (patab) {
210                         if (newpa->paneltab == pa) {
211                                 newpa->paneltab = patab;
212                                 break;
213                         }
214                         patab = patab->next;
215                         pa = pa->next;
216                 }
217         }
218         
219         return newar;
220 }
221
222
223 /* from lb2 to lb1, lb1 is supposed to be freed */
224 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
225 {
226         ARegion *ar;
227         
228         /* to be sure */
229         BLI_listbase_clear(lb1);
230         
231         for (ar = lb2->first; ar; ar = ar->next) {
232                 ARegion *arnew = BKE_area_region_copy(st, ar);
233                 BLI_addtail(lb1, arnew);
234         }
235 }
236
237
238 /* lb1 should be empty */
239 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
240 {
241         SpaceLink *sl;
242         
243         BLI_listbase_clear(lb1);  /* to be sure */
244         
245         for (sl = lb2->first; sl; sl = sl->next) {
246                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
247                 
248                 if (st && st->duplicate) {
249                         SpaceLink *slnew = st->duplicate(sl);
250                         
251                         BLI_addtail(lb1, slnew);
252                         
253                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
254                 }
255         }
256 }
257
258 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
259 /* lock can become bitflag too */
260 /* should be replaced in future by better local data handling for threads */
261 void BKE_spacedata_draw_locks(int set)
262 {
263         SpaceType *st;
264         
265         for (st = spacetypes.first; st; st = st->next) {
266                 ARegionType *art;
267         
268                 for (art = st->regiontypes.first; art; art = art->next) {
269                         if (set) 
270                                 art->do_lock = art->lock;
271                         else 
272                                 art->do_lock = false;
273                 }
274         }
275 }
276
277 static void (*spacedata_id_remap_cb)(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, ID *new_id) = NULL;
278
279 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
280 {
281         spacedata_id_remap_cb = func;
282 }
283
284 /* UNUSED!!! */
285 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
286 {
287         if (spacedata_id_remap_cb) {
288                 spacedata_id_remap_cb(sa, sl, id, NULL);
289         }
290 }
291
292 /* not region itself */
293 void BKE_area_region_free(SpaceType *st, ARegion *ar)
294 {
295         uiList *uilst;
296
297         if (st) {
298                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
299                 
300                 if (art && art->free)
301                         art->free(ar);
302                 
303                 if (ar->regiondata)
304                         printf("regiondata free error\n");
305         }
306         else if (ar->type && ar->type->free)
307                 ar->type->free(ar);
308         
309         if (ar->v2d.tab_offset) {
310                 MEM_freeN(ar->v2d.tab_offset);
311                 ar->v2d.tab_offset = NULL;
312         }
313
314         if (!BLI_listbase_is_empty(&ar->panels)) {
315                 Panel *pa, *pa_next;
316                 for (pa = ar->panels.first; pa; pa = pa_next) {
317                         pa_next = pa->next;
318                         if (pa->activedata) {
319                                 MEM_freeN(pa->activedata);
320                         }
321                         MEM_freeN(pa);
322                 }
323         }
324
325         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
326                 if (uilst->dyn_data) {
327                         uiListDyn *dyn_data = uilst->dyn_data;
328                         if (dyn_data->items_filter_flags) {
329                                 MEM_freeN(dyn_data->items_filter_flags);
330                         }
331                         if (dyn_data->items_filter_neworder) {
332                                 MEM_freeN(dyn_data->items_filter_neworder);
333                         }
334                         MEM_freeN(dyn_data);
335                 }
336                 if (uilst->properties) {
337                         IDP_FreeProperty(uilst->properties);
338                         MEM_freeN(uilst->properties);
339                 }
340         }
341         BLI_freelistN(&ar->ui_lists);
342         BLI_freelistN(&ar->ui_previews);
343         BLI_freelistN(&ar->panels_category);
344         BLI_freelistN(&ar->panels_category_active);
345 }
346
347 /* not area itself */
348 void BKE_screen_area_free(ScrArea *sa)
349 {
350         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
351         ARegion *ar;
352         
353         for (ar = sa->regionbase.first; ar; ar = ar->next)
354                 BKE_area_region_free(st, ar);
355
356         BLI_freelistN(&sa->regionbase);
357         
358         BKE_spacedata_freelist(&sa->spacedata);
359         
360         BLI_freelistN(&sa->actionzones);
361 }
362
363 /** Free (or release) any data used by this screen (does not free the screen itself). */
364 void BKE_screen_free(bScreen *sc)
365 {
366         ScrArea *sa, *san;
367         ARegion *ar;
368
369         /* No animdata here. */
370         
371         for (ar = sc->regionbase.first; ar; ar = ar->next)
372                 BKE_area_region_free(NULL, ar);
373
374         BLI_freelistN(&sc->regionbase);
375         
376         for (sa = sc->areabase.first; sa; sa = san) {
377                 san = sa->next;
378                 BKE_screen_area_free(sa);
379         }
380         
381         BLI_freelistN(&sc->vertbase);
382         BLI_freelistN(&sc->edgebase);
383         BLI_freelistN(&sc->areabase);
384
385         /* Region and timer are freed by the window manager. */
386         MEM_SAFE_FREE(sc->tool_tip);
387 }
388
389 /* for depsgraph */
390 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
391 {
392         ScrArea *sa;
393         unsigned int layer = 0;
394
395         if (screen) {
396                 /* get all used view3d layers */
397                 for (sa = screen->areabase.first; sa; sa = sa->next)
398                         if (sa->spacetype == SPACE_VIEW3D)
399                                 layer |= ((View3D *)sa->spacedata.first)->lay;
400         }
401
402         if (!layer)
403                 return scene->lay;
404
405         return layer;
406 }
407
408 /* ***************** Utilities ********************** */
409
410 /* Find a region of the specified type from the given area */
411 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
412 {
413         if (sa) {
414                 ARegion *ar;
415                 
416                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
417                         if (ar->regiontype == type)
418                                 return ar;
419                 }
420         }
421         return NULL;
422 }
423
424 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
425 {
426         if (sa) {
427                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
428                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
429                         return ar;
430                 }
431
432                 /* fallback to any */
433                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
434         }
435         return NULL;
436 }
437
438 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
439 {
440         ARegion *ar_found = NULL;
441         if (sa) {
442                 ARegion *ar;
443                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
444                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
445                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
446                                         ar_found = ar;
447                                         break;
448                                 }
449                         }
450                 }
451         }
452         return ar_found;
453 }
454
455 /**
456  * \note, ideally we can get the area from the context,
457  * there are a few places however where this isn't practical.
458  */
459 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
460 {
461         ScrArea *sa;
462
463         for (sa = sc->areabase.first; sa; sa = sa->next) {
464                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
465                         break;
466                 }
467         }
468
469         return sa;
470 }
471
472 /**
473  * \note Using this function is generally a last resort, you really want to be
474  * using the context when you can - campbell
475  */
476 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
477 {
478         ScrArea *sa, *big = NULL;
479         int size, maxsize = 0;
480
481         for (sa = sc->areabase.first; sa; sa = sa->next) {
482                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
483                         if (min <= sa->winx && min <= sa->winy) {
484                                 size = sa->winx * sa->winy;
485                                 if (size > maxsize) {
486                                         maxsize = size;
487                                         big = sa;
488                                 }
489                         }
490                 }
491         }
492
493         return big;
494 }
495
496 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
497 {
498         ScrArea *sa, *sa_found = NULL;
499
500         for (sa = sc->areabase.first; sa; sa = sa->next) {
501                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
502                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
503                                 sa_found = sa;
504                         }
505                         break;
506                 }
507         }
508         return sa_found;
509 }
510
511
512 /**
513  * Utility function to get the active layer to use when adding new objects.
514  */
515 unsigned int BKE_screen_view3d_layer_active_ex(const View3D *v3d, const Scene *scene, bool use_localvd)
516 {
517         unsigned int lay;
518         if ((v3d == NULL) || (v3d->scenelock && !v3d->localvd)) {
519                 lay = scene->layact;
520         }
521         else {
522                 lay = v3d->layact;
523         }
524
525         if (use_localvd) {
526                 if (v3d && v3d->localvd) {
527                         lay |= v3d->lay;
528                 }
529         }
530
531         return lay;
532 }
533 unsigned int BKE_screen_view3d_layer_active(const struct View3D *v3d, const struct Scene *scene)
534 {
535         return BKE_screen_view3d_layer_active_ex(v3d, scene, true);
536 }
537
538 /**
539  * Accumulate all visible layers on this screen.
540  */
541 unsigned int BKE_screen_view3d_layer_all(const bScreen *sc)
542 {
543         const ScrArea *sa;
544         unsigned int lay = 0;
545         for (sa = sc->areabase.first; sa; sa = sa->next) {
546                 if (sa->spacetype == SPACE_VIEW3D) {
547                         View3D *v3d = sa->spacedata.first;
548                         lay |= v3d->lay;
549                 }
550         }
551
552         return lay;
553 }
554
555 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
556 {
557         int bit;
558
559         if (v3d->scenelock && v3d->localvd == NULL) {
560                 v3d->lay = scene->lay;
561                 v3d->camera = scene->camera;
562
563                 if (v3d->camera == NULL) {
564                         ARegion *ar;
565
566                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
567                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
568                                         RegionView3D *rv3d = ar->regiondata;
569                                         if (rv3d->persp == RV3D_CAMOB)
570                                                 rv3d->persp = RV3D_PERSP;
571                                 }
572                         }
573                 }
574
575                 if ((v3d->lay & v3d->layact) == 0) {
576                         for (bit = 0; bit < 32; bit++) {
577                                 if (v3d->lay & (1u << bit)) {
578                                         v3d->layact = (1u << bit);
579                                         break;
580                                 }
581                         }
582                 }
583         }
584 }
585
586 void BKE_screen_view3d_scene_sync(bScreen *sc)
587 {
588         /* are there cameras in the views that are not in the scene? */
589         ScrArea *sa;
590         for (sa = sc->areabase.first; sa; sa = sa->next) {
591                 SpaceLink *sl;
592                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
593                         if (sl->spacetype == SPACE_VIEW3D) {
594                                 View3D *v3d = (View3D *) sl;
595                                 BKE_screen_view3d_sync(v3d, sc->scene);
596                         }
597                 }
598         }
599 }
600
601 void BKE_screen_view3d_main_sync(ListBase *screen_lb, Scene *scene)
602 {
603         bScreen *sc;
604         ScrArea *sa;
605         SpaceLink *sl;
606
607         /* from scene copy to the other views */
608         for (sc = screen_lb->first; sc; sc = sc->id.next) {
609                 if (sc->scene != scene)
610                         continue;
611
612                 for (sa = sc->areabase.first; sa; sa = sa->next)
613                         for (sl = sa->spacedata.first; sl; sl = sl->next)
614                                 if (sl->spacetype == SPACE_VIEW3D)
615                                         BKE_screen_view3d_sync((View3D *)sl, scene);
616         }
617 }
618
619 void BKE_screen_view3d_twmode_remove(View3D *v3d, const int i)
620 {
621         const int selected_index = (v3d->twmode - V3D_MANIP_CUSTOM);
622         if (selected_index == i) {
623                 v3d->twmode = V3D_MANIP_GLOBAL; /* fallback to global */
624         }
625         else if (selected_index > i) {
626                 v3d->twmode--;
627         }
628 }
629
630 void BKE_screen_view3d_main_twmode_remove(ListBase *screen_lb, Scene *scene, const int i)
631 {
632         bScreen *sc;
633
634         for (sc = screen_lb->first; sc; sc = sc->id.next) {
635                 if (sc->scene == scene) {
636                         ScrArea *sa;
637                         for (sa = sc->areabase.first; sa; sa = sa->next) {
638                                 SpaceLink *sl;
639                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
640                                         if (sl->spacetype == SPACE_VIEW3D) {
641                                                 View3D *v3d = (View3D *)sl;
642                                                 BKE_screen_view3d_twmode_remove(v3d, i);
643                                         }
644                                 }
645                         }
646                 }
647         }
648 }
649
650 /* magic zoom calculation, no idea what
651  * it signifies, if you find out, tell me! -zr
652  */
653
654 /* simple, its magic dude!
655  * well, to be honest, this gives a natural feeling zooming
656  * with multiple keypad presses (ton)
657  */
658 float BKE_screen_view3d_zoom_to_fac(float camzoom)
659 {
660         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
661 }
662
663 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
664 {
665         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
666 }
667
668 void BKE_screen_gpu_fx_validate(GPUFXSettings *fx_settings)
669 {
670         /* currently we use DOF from the camera _only_,
671          * so we never allocate this, only copy from the Camera */
672 #if 0
673         if ((fx_settings->dof == NULL) &&
674             (fx_settings->fx_flag & GPU_FX_FLAG_DOF))
675         {
676                 GPUDOFSettings *fx_dof;
677                 fx_dof = fx_settings->dof = MEM_callocN(sizeof(GPUDOFSettings), __func__);
678         }
679 #endif
680
681         if ((fx_settings->ssao == NULL) &&
682             (fx_settings->fx_flag & GPU_FX_FLAG_SSAO))
683         {
684                 GPUSSAOSettings *fx_ssao;
685                 fx_ssao = fx_settings->ssao = MEM_callocN(sizeof(GPUSSAOSettings), __func__);
686
687                 GPU_fx_compositor_init_ssao_settings(fx_ssao);
688         }
689 }