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