Revert to master - those changes are globally valid, but remain incomplete,
[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         
184         /* use optional regiondata callback */
185         if (ar->regiondata) {
186                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
187
188                 if (art && art->duplicate)
189                         newar->regiondata = art->duplicate(ar->regiondata);
190                 else
191                         newar->regiondata = MEM_dupallocN(ar->regiondata);
192         }
193
194         if (ar->v2d.tab_offset)
195                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
196         
197         BLI_listbase_clear(&newar->panels);
198         BLI_duplicatelist(&newar->panels, &ar->panels);
199
200         BLI_listbase_clear(&newar->ui_previews);
201         BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
202
203         /* copy panel pointers */
204         for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
205                 patab = newar->panels.first;
206                 pa = ar->panels.first;
207                 while (patab) {
208                         if (newpa->paneltab == pa) {
209                                 newpa->paneltab = patab;
210                                 break;
211                         }
212                         patab = patab->next;
213                         pa = pa->next;
214                 }
215         }
216         
217         return newar;
218 }
219
220
221 /* from lb2 to lb1, lb1 is supposed to be freed */
222 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
223 {
224         ARegion *ar;
225         
226         /* to be sure */
227         BLI_listbase_clear(lb1);
228         
229         for (ar = lb2->first; ar; ar = ar->next) {
230                 ARegion *arnew = BKE_area_region_copy(st, ar);
231                 BLI_addtail(lb1, arnew);
232         }
233 }
234
235
236 /* lb1 should be empty */
237 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
238 {
239         SpaceLink *sl;
240         
241         BLI_listbase_clear(lb1);  /* to be sure */
242         
243         for (sl = lb2->first; sl; sl = sl->next) {
244                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
245                 
246                 if (st && st->duplicate) {
247                         SpaceLink *slnew = st->duplicate(sl);
248                         
249                         BLI_addtail(lb1, slnew);
250                         
251                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
252                 }
253         }
254 }
255
256 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
257 /* lock can become bitflag too */
258 /* should be replaced in future by better local data handling for threads */
259 void BKE_spacedata_draw_locks(int set)
260 {
261         SpaceType *st;
262         
263         for (st = spacetypes.first; st; st = st->next) {
264                 ARegionType *art;
265         
266                 for (art = st->regiontypes.first; art; art = art->next) {
267                         if (set) 
268                                 art->do_lock = art->lock;
269                         else 
270                                 art->do_lock = false;
271                 }
272         }
273 }
274
275 static void (*spacedata_id_unref_cb)(struct SpaceLink *sl, const struct ID *id) = NULL;
276
277 void BKE_spacedata_callback_id_unref_set(void (*func)(struct SpaceLink *sl, const struct ID *))
278 {
279         spacedata_id_unref_cb = func;
280 }
281
282 void BKE_spacedata_id_unref(struct SpaceLink *sl, const struct ID *id)
283 {
284         if (spacedata_id_unref_cb) {
285                 spacedata_id_unref_cb(sl, id);
286         }
287 }
288
289 /* not region itself */
290 void BKE_area_region_free(SpaceType *st, ARegion *ar)
291 {
292         uiList *uilst;
293
294         if (st) {
295                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
296                 
297                 if (art && art->free)
298                         art->free(ar);
299                 
300                 if (ar->regiondata)
301                         printf("regiondata free error\n");
302         }
303         else if (ar->type && ar->type->free)
304                 ar->type->free(ar);
305         
306         if (ar->v2d.tab_offset) {
307                 MEM_freeN(ar->v2d.tab_offset);
308                 ar->v2d.tab_offset = NULL;
309         }
310
311         if (!BLI_listbase_is_empty(&ar->panels)) {
312                 Panel *pa, *pa_next;
313                 for (pa = ar->panels.first; pa; pa = pa_next) {
314                         pa_next = pa->next;
315                         if (pa->activedata) {
316                                 MEM_freeN(pa->activedata);
317                         }
318                         MEM_freeN(pa);
319                 }
320         }
321
322         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
323                 if (uilst->dyn_data) {
324                         uiListDyn *dyn_data = uilst->dyn_data;
325                         if (dyn_data->items_filter_flags) {
326                                 MEM_freeN(dyn_data->items_filter_flags);
327                         }
328                         if (dyn_data->items_filter_neworder) {
329                                 MEM_freeN(dyn_data->items_filter_neworder);
330                         }
331                         MEM_freeN(dyn_data);
332                 }
333                 if (uilst->properties) {
334                         IDP_FreeProperty(uilst->properties);
335                         MEM_freeN(uilst->properties);
336                 }
337         }
338         BLI_freelistN(&ar->ui_lists);
339         BLI_freelistN(&ar->ui_previews);
340         BLI_freelistN(&ar->panels_category);
341         BLI_freelistN(&ar->panels_category_active);
342 }
343
344 /* not area itself */
345 void BKE_screen_area_free(ScrArea *sa)
346 {
347         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
348         ARegion *ar;
349         
350         for (ar = sa->regionbase.first; ar; ar = ar->next)
351                 BKE_area_region_free(st, ar);
352
353         BLI_freelistN(&sa->regionbase);
354         
355         BKE_spacedata_freelist(&sa->spacedata);
356         
357         BLI_freelistN(&sa->actionzones);
358 }
359
360 /* don't free screen itself */
361 void BKE_screen_free(bScreen *sc)
362 {
363         ScrArea *sa, *san;
364         ARegion *ar;
365         
366         for (ar = sc->regionbase.first; ar; ar = ar->next)
367                 BKE_area_region_free(NULL, ar);
368
369         BLI_freelistN(&sc->regionbase);
370         
371         for (sa = sc->areabase.first; sa; sa = san) {
372                 san = sa->next;
373                 BKE_screen_area_free(sa);
374         }
375         
376         BLI_freelistN(&sc->vertbase);
377         BLI_freelistN(&sc->edgebase);
378         BLI_freelistN(&sc->areabase);
379 }
380
381 /* for depsgraph */
382 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
383 {
384         ScrArea *sa;
385         unsigned int layer = 0;
386
387         if (screen) {
388                 /* get all used view3d layers */
389                 for (sa = screen->areabase.first; sa; sa = sa->next)
390                         if (sa->spacetype == SPACE_VIEW3D)
391                                 layer |= ((View3D *)sa->spacedata.first)->lay;
392         }
393
394         if (!layer)
395                 return scene->lay;
396
397         return layer;
398 }
399
400 /* ***************** Utilities ********************** */
401
402 /* Find a region of the specified type from the given area */
403 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
404 {
405         if (sa) {
406                 ARegion *ar;
407                 
408                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
409                         if (ar->regiontype == type)
410                                 return ar;
411                 }
412         }
413         return NULL;
414 }
415
416 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
417 {
418         if (sa) {
419                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
420                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
421                         return ar;
422                 }
423
424                 /* fallback to any */
425                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
426         }
427         return NULL;
428 }
429
430 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
431 {
432         ARegion *ar_found = NULL;
433         if (sa) {
434                 ARegion *ar;
435                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
436                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
437                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
438                                         ar_found = ar;
439                                         break;
440                                 }
441                         }
442                 }
443         }
444         return ar_found;
445 }
446
447 /**
448  * \note, ideally we can get the area from the context,
449  * there are a few places however where this isn't practical.
450  */
451 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
452 {
453         ScrArea *sa;
454
455         for (sa = sc->areabase.first; sa; sa = sa->next) {
456                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
457                         break;
458                 }
459         }
460
461         return sa;
462 }
463
464 /**
465  * \note Using this function is generally a last resort, you really want to be
466  * using the context when you can - campbell
467  */
468 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
469 {
470         ScrArea *sa, *big = NULL;
471         int size, maxsize = 0;
472
473         for (sa = sc->areabase.first; sa; sa = sa->next) {
474                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
475                         if (min <= sa->winx && min <= sa->winy) {
476                                 size = sa->winx * sa->winy;
477                                 if (size > maxsize) {
478                                         maxsize = size;
479                                         big = sa;
480                                 }
481                         }
482                 }
483         }
484
485         return big;
486 }
487
488 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
489 {
490         ScrArea *sa, *sa_found = NULL;
491
492         for (sa = sc->areabase.first; sa; sa = sa->next) {
493                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
494                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
495                                 sa_found = sa;
496                         }
497                         break;
498                 }
499         }
500         return sa_found;
501 }
502
503
504 /**
505  * Utility function to get the active layer to use when adding new objects.
506  */
507 unsigned int BKE_screen_view3d_layer_active_ex(const View3D *v3d, const Scene *scene, bool use_localvd)
508 {
509         unsigned int lay;
510         if ((v3d == NULL) || (v3d->scenelock && !v3d->localvd)) {
511                 lay = scene->layact;
512         }
513         else {
514                 lay = v3d->layact;
515         }
516
517         if (use_localvd) {
518                 if (v3d && v3d->localvd) {
519                         lay |= v3d->lay;
520                 }
521         }
522
523         return lay;
524 }
525 unsigned int BKE_screen_view3d_layer_active(const struct View3D *v3d, const struct Scene *scene)
526 {
527         return BKE_screen_view3d_layer_active_ex(v3d, scene, true);
528 }
529
530 /**
531  * Accumulate all visible layers on this screen.
532  */
533 unsigned int BKE_screen_view3d_layer_all(const bScreen *sc)
534 {
535         const ScrArea *sa;
536         unsigned int lay = 0;
537         for (sa = sc->areabase.first; sa; sa = sa->next) {
538                 if (sa->spacetype == SPACE_VIEW3D) {
539                         View3D *v3d = sa->spacedata.first;
540                         lay |= v3d->lay;
541                 }
542         }
543
544         return lay;
545 }
546
547 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
548 {
549         int bit;
550
551         if (v3d->scenelock && v3d->localvd == NULL) {
552                 v3d->lay = scene->lay;
553                 v3d->camera = scene->camera;
554
555                 if (v3d->camera == NULL) {
556                         ARegion *ar;
557
558                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
559                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
560                                         RegionView3D *rv3d = ar->regiondata;
561                                         if (rv3d->persp == RV3D_CAMOB)
562                                                 rv3d->persp = RV3D_PERSP;
563                                 }
564                         }
565                 }
566
567                 if ((v3d->lay & v3d->layact) == 0) {
568                         for (bit = 0; bit < 32; bit++) {
569                                 if (v3d->lay & (1u << bit)) {
570                                         v3d->layact = (1u << bit);
571                                         break;
572                                 }
573                         }
574                 }
575         }
576 }
577
578 void BKE_screen_view3d_scene_sync(bScreen *sc)
579 {
580         /* are there cameras in the views that are not in the scene? */
581         ScrArea *sa;
582         for (sa = sc->areabase.first; sa; sa = sa->next) {
583                 SpaceLink *sl;
584                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
585                         if (sl->spacetype == SPACE_VIEW3D) {
586                                 View3D *v3d = (View3D *) sl;
587                                 BKE_screen_view3d_sync(v3d, sc->scene);
588                         }
589                 }
590         }
591 }
592
593 void BKE_screen_view3d_main_sync(ListBase *screen_lb, Scene *scene)
594 {
595         bScreen *sc;
596         ScrArea *sa;
597         SpaceLink *sl;
598
599         /* from scene copy to the other views */
600         for (sc = screen_lb->first; sc; sc = sc->id.next) {
601                 if (sc->scene != scene)
602                         continue;
603
604                 for (sa = sc->areabase.first; sa; sa = sa->next)
605                         for (sl = sa->spacedata.first; sl; sl = sl->next)
606                                 if (sl->spacetype == SPACE_VIEW3D)
607                                         BKE_screen_view3d_sync((View3D *)sl, scene);
608         }
609 }
610
611 void BKE_screen_view3d_twmode_remove(View3D *v3d, const int i)
612 {
613         const int selected_index = (v3d->twmode - V3D_MANIP_CUSTOM);
614         if (selected_index == i) {
615                 v3d->twmode = V3D_MANIP_GLOBAL; /* fallback to global   */
616         }
617         else if (selected_index > i) {
618                 v3d->twmode--;
619         }
620 }
621
622 void BKE_screen_view3d_main_twmode_remove(ListBase *screen_lb, Scene *scene, const int i)
623 {
624         bScreen *sc;
625
626         for (sc = screen_lb->first; sc; sc = sc->id.next) {
627                 if (sc->scene == scene) {
628                         ScrArea *sa;
629                         for (sa = sc->areabase.first; sa; sa = sa->next) {
630                                 SpaceLink *sl;
631                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
632                                         if (sl->spacetype == SPACE_VIEW3D) {
633                                                 View3D *v3d = (View3D *)sl;
634                                                 BKE_screen_view3d_twmode_remove(v3d, i);
635                                         }
636                                 }
637                         }
638                 }
639         }
640 }
641
642 /* magic zoom calculation, no idea what
643  * it signifies, if you find out, tell me! -zr
644  */
645
646 /* simple, its magic dude!
647  * well, to be honest, this gives a natural feeling zooming
648  * with multiple keypad presses (ton)
649  */
650 float BKE_screen_view3d_zoom_to_fac(float camzoom)
651 {
652         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
653 }
654
655 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
656 {
657         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
658 }
659
660 void BKE_screen_gpu_fx_validate(GPUFXSettings *fx_settings)
661 {
662         /* currently we use DOF from the camera _only_,
663          * so we never allocate this, only copy from the Camera */
664 #if 0
665         if ((fx_settings->dof == NULL) &&
666             (fx_settings->fx_flag & GPU_FX_FLAG_DOF))
667         {
668                 GPUDOFSettings *fx_dof;
669                 fx_dof = fx_settings->dof = MEM_callocN(sizeof(GPUDOFSettings), __func__);
670         }
671 #endif
672
673         if ((fx_settings->ssao == NULL) &&
674             (fx_settings->fx_flag & GPU_FX_FLAG_SSAO))
675         {
676                 GPUSSAOSettings *fx_ssao;
677                 fx_ssao = fx_settings->ssao = MEM_callocN(sizeof(GPUSSAOSettings), __func__);
678
679                 GPU_fx_compositor_init_ssao_settings(fx_ssao);
680         }
681 }