efcbcacf9748d232e578dda99c9e83937f1a7959
[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 "DNA_scene_types.h"
43 #include "DNA_screen_types.h"
44 #include "DNA_space_types.h"
45 #include "DNA_view3d_types.h"
46
47 #include "BLI_listbase.h"
48 #include "BLI_utildefines.h"
49
50 #include "BKE_idprop.h"
51 #include "BKE_screen.h"
52
53 /* ************ Spacetype/regiontype handling ************** */
54
55 /* keep global; this has to be accessible outside of windowmanager */
56 static ListBase spacetypes = {NULL, NULL};
57
58 /* not SpaceType itself */
59 static void spacetype_free(SpaceType *st)
60 {
61         ARegionType *art;
62         PanelType *pt;
63         HeaderType *ht;
64         
65         for (art = st->regiontypes.first; art; art = art->next) {
66                 BLI_freelistN(&art->drawcalls);
67
68                 for (pt = art->paneltypes.first; pt; pt = pt->next)
69                         if (pt->ext.free)
70                                 pt->ext.free(pt->ext.data);
71
72                 for (ht = art->headertypes.first; ht; ht = ht->next)
73                         if (ht->ext.free)
74                                 ht->ext.free(ht->ext.data);
75
76                 BLI_freelistN(&art->paneltypes);
77                 BLI_freelistN(&art->headertypes);
78         }
79         
80         BLI_freelistN(&st->regiontypes);
81         BLI_freelistN(&st->toolshelf);
82
83 }
84
85 void BKE_spacetypes_free(void)
86 {
87         SpaceType *st;
88         
89         for (st = spacetypes.first; st; st = st->next) {
90                 spacetype_free(st);
91         }
92         
93         BLI_freelistN(&spacetypes);
94 }
95
96 SpaceType *BKE_spacetype_from_id(int spaceid)
97 {
98         SpaceType *st;
99         
100         for (st = spacetypes.first; st; st = st->next) {
101                 if (st->spaceid == spaceid)
102                         return st;
103         }
104         return NULL;
105 }
106
107 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
108 {
109         ARegionType *art;
110         
111         for (art = st->regiontypes.first; art; art = art->next)
112                 if (art->regionid == regionid)
113                         return art;
114         
115         printf("Error, region type missing in - name:\"%s\", id:%d\n", st->name, st->spaceid);
116         return st->regiontypes.first;
117 }
118
119
120 const ListBase *BKE_spacetypes_list(void)
121 {
122         return &spacetypes;
123 }
124
125 void BKE_spacetype_register(SpaceType *st)
126 {
127         SpaceType *stype;
128         
129         /* sanity check */
130         stype = BKE_spacetype_from_id(st->spaceid);
131         if (stype) {
132                 printf("error: redefinition of spacetype %s\n", stype->name);
133                 spacetype_free(stype);
134                 MEM_freeN(stype);
135         }
136         
137         BLI_addtail(&spacetypes, st);
138 }
139
140 int BKE_spacetype_exists(int spaceid)
141 {
142         return BKE_spacetype_from_id(spaceid) != NULL;
143 }
144
145 /* ***************** Space handling ********************** */
146
147 void BKE_spacedata_freelist(ListBase *lb)
148 {
149         SpaceLink *sl;
150         ARegion *ar;
151         
152         for (sl = lb->first; sl; sl = sl->next) {
153                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
154                 
155                 /* free regions for pushed spaces */
156                 for (ar = sl->regionbase.first; ar; ar = ar->next)
157                         BKE_area_region_free(st, ar);
158
159                 BLI_freelistN(&sl->regionbase);
160                 
161                 if (st && st->free) 
162                         st->free(sl);
163         }
164         
165         BLI_freelistN(lb);
166 }
167
168 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
169 {
170         ARegion *newar = MEM_dupallocN(ar);
171         Panel *pa, *newpa, *patab;
172         
173         newar->prev = newar->next = NULL;
174         newar->handlers.first = newar->handlers.last = NULL;
175         newar->uiblocks.first = newar->uiblocks.last = NULL;
176         newar->ui_lists.first = newar->ui_lists.last = NULL;
177         newar->swinid = 0;
178         
179         /* use optional regiondata callback */
180         if (ar->regiondata) {
181                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
182
183                 if (art && art->duplicate)
184                         newar->regiondata = art->duplicate(ar->regiondata);
185                 else
186                         newar->regiondata = MEM_dupallocN(ar->regiondata);
187         }
188
189         if (ar->v2d.tab_offset)
190                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
191         
192         newar->panels.first = newar->panels.last = NULL;
193         BLI_duplicatelist(&newar->panels, &ar->panels);
194         
195         /* copy panel pointers */
196         for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
197                 patab = newar->panels.first;
198                 pa = ar->panels.first;
199                 while (patab) {
200                         if (newpa->paneltab == pa) {
201                                 newpa->paneltab = patab;
202                                 break;
203                         }
204                         patab = patab->next;
205                         pa = pa->next;
206                 }
207         }
208         
209         return newar;
210 }
211
212
213 /* from lb2 to lb1, lb1 is supposed to be freed */
214 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
215 {
216         ARegion *ar;
217         
218         /* to be sure */
219         lb1->first = lb1->last = NULL;
220         
221         for (ar = lb2->first; ar; ar = ar->next) {
222                 ARegion *arnew = BKE_area_region_copy(st, ar);
223                 BLI_addtail(lb1, arnew);
224         }
225 }
226
227
228 /* lb1 should be empty */
229 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
230 {
231         SpaceLink *sl;
232         
233         lb1->first = lb1->last = NULL;    /* to be sure */
234         
235         for (sl = lb2->first; sl; sl = sl->next) {
236                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
237                 
238                 if (st && st->duplicate) {
239                         SpaceLink *slnew = st->duplicate(sl);
240                         
241                         BLI_addtail(lb1, slnew);
242                         
243                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
244                 }
245         }
246 }
247
248 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
249 /* lock can become bitflag too */
250 /* should be replaced in future by better local data handling for threads */
251 void BKE_spacedata_draw_locks(int set)
252 {
253         SpaceType *st;
254         
255         for (st = spacetypes.first; st; st = st->next) {
256                 ARegionType *art;
257         
258                 for (art = st->regiontypes.first; art; art = art->next) {
259                         if (set) 
260                                 art->do_lock = art->lock;
261                         else 
262                                 art->do_lock = FALSE;
263                 }
264         }
265 }
266
267
268 /* not region itself */
269 void BKE_area_region_free(SpaceType *st, ARegion *ar)
270 {
271         uiList *uilst;
272
273         if (st) {
274                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
275                 
276                 if (art && art->free)
277                         art->free(ar);
278                 
279                 if (ar->regiondata)
280                         printf("regiondata free error\n");
281         }
282         else if (ar->type && ar->type->free)
283                 ar->type->free(ar);
284         
285         if (ar->v2d.tab_offset) {
286                 MEM_freeN(ar->v2d.tab_offset);
287                 ar->v2d.tab_offset = NULL;
288         }
289
290         BLI_freelistN(&ar->panels);
291
292         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
293                 if (uilst->dyn_data) {
294                         uiListDyn *dyn_data = uilst->dyn_data;
295                         if (dyn_data->items_filter_flags) {
296                                 MEM_freeN(dyn_data->items_filter_flags);
297                         }
298                         if (dyn_data->items_filter_neworder) {
299                                 MEM_freeN(dyn_data->items_filter_neworder);
300                         }
301                         MEM_freeN(dyn_data);
302                 }
303                 if (uilst->properties) {
304                         IDP_FreeProperty(uilst->properties);
305                         MEM_freeN(uilst->properties);
306                 }
307         }
308         BLI_freelistN(&ar->ui_lists);
309 }
310
311 /* not area itself */
312 void BKE_screen_area_free(ScrArea *sa)
313 {
314         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
315         ARegion *ar;
316         
317         for (ar = sa->regionbase.first; ar; ar = ar->next)
318                 BKE_area_region_free(st, ar);
319
320         BLI_freelistN(&sa->regionbase);
321         
322         BKE_spacedata_freelist(&sa->spacedata);
323         
324         BLI_freelistN(&sa->actionzones);
325 }
326
327 /* don't free screen itself */
328 void BKE_screen_free(bScreen *sc)
329 {
330         ScrArea *sa, *san;
331         ARegion *ar;
332         
333         for (ar = sc->regionbase.first; ar; ar = ar->next)
334                 BKE_area_region_free(NULL, ar);
335
336         BLI_freelistN(&sc->regionbase);
337         
338         for (sa = sc->areabase.first; sa; sa = san) {
339                 san = sa->next;
340                 BKE_screen_area_free(sa);
341         }
342         
343         BLI_freelistN(&sc->vertbase);
344         BLI_freelistN(&sc->edgebase);
345         BLI_freelistN(&sc->areabase);
346 }
347
348 /* for depsgraph */
349 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
350 {
351         ScrArea *sa;
352         unsigned int layer = 0;
353
354         if (screen) {
355                 /* get all used view3d layers */
356                 for (sa = screen->areabase.first; sa; sa = sa->next)
357                         if (sa->spacetype == SPACE_VIEW3D)
358                                 layer |= ((View3D *)sa->spacedata.first)->lay;
359         }
360
361         if (!layer)
362                 return scene->lay;
363
364         return layer;
365 }
366
367 /* ***************** Utilities ********************** */
368
369 /* Find a region of the specified type from the given area */
370 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
371 {
372         if (sa) {
373                 ARegion *ar;
374                 
375                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
376                         if (ar->regiontype == type)
377                                 return ar;
378                 }
379         }
380         return NULL;
381 }
382
383 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
384 {
385         if (sa) {
386                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
387                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
388                         return ar;
389                 }
390
391                 /* fallback to any */
392                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
393         }
394         return NULL;
395 }
396
397 /* note, using this function is generally a last resort, you really want to be
398  * using the context when you can - campbell
399  * -1 for any type */
400 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
401 {
402         ScrArea *sa, *big = NULL;
403         int size, maxsize = 0;
404
405         for (sa = sc->areabase.first; sa; sa = sa->next) {
406                 if ((spacetype == -1) || sa->spacetype == spacetype) {
407                         if (min <= sa->winx && min <= sa->winy) {
408                                 size = sa->winx * sa->winy;
409                                 if (size > maxsize) {
410                                         maxsize = size;
411                                         big = sa;
412                                 }
413                         }
414                 }
415         }
416
417         return big;
418 }
419
420 void BKE_screen_view3d_sync(struct View3D *v3d, struct Scene *scene)
421 {
422         int bit;
423
424         if (v3d->scenelock && v3d->localvd == NULL) {
425                 v3d->lay = scene->lay;
426                 v3d->camera = scene->camera;
427
428                 if (v3d->camera == NULL) {
429                         ARegion *ar;
430
431                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
432                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
433                                         RegionView3D *rv3d = ar->regiondata;
434                                         if (rv3d->persp == RV3D_CAMOB)
435                                                 rv3d->persp = RV3D_PERSP;
436                                 }
437                         }
438                 }
439
440                 if ((v3d->lay & v3d->layact) == 0) {
441                         for (bit = 0; bit < 32; bit++) {
442                                 if (v3d->lay & (1 << bit)) {
443                                         v3d->layact = 1 << bit;
444                                         break;
445                                 }
446                         }
447                 }
448         }
449 }
450
451 void BKE_screen_view3d_scene_sync(bScreen *sc)
452 {
453         /* are there cameras in the views that are not in the scene? */
454         ScrArea *sa;
455         for (sa = sc->areabase.first; sa; sa = sa->next) {
456                 SpaceLink *sl;
457                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
458                         if (sl->spacetype == SPACE_VIEW3D) {
459                                 View3D *v3d = (View3D *) sl;
460                                 BKE_screen_view3d_sync(v3d, sc->scene);
461                         }
462                 }
463         }
464 }
465
466 void BKE_screen_view3d_main_sync(ListBase *screen_lb, Scene *scene)
467 {
468         bScreen *sc;
469         ScrArea *sa;
470         SpaceLink *sl;
471
472         /* from scene copy to the other views */
473         for (sc = screen_lb->first; sc; sc = sc->id.next) {
474                 if (sc->scene != scene)
475                         continue;
476
477                 for (sa = sc->areabase.first; sa; sa = sa->next)
478                         for (sl = sa->spacedata.first; sl; sl = sl->next)
479                                 if (sl->spacetype == SPACE_VIEW3D)
480                                         BKE_screen_view3d_sync((View3D *)sl, scene);
481         }
482 }
483
484 /* magic zoom calculation, no idea what
485  * it signifies, if you find out, tell me! -zr
486  */
487
488 /* simple, its magic dude!
489  * well, to be honest, this gives a natural feeling zooming
490  * with multiple keypad presses (ton)
491  */
492 float BKE_screen_view3d_zoom_to_fac(float camzoom)
493 {
494         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
495 }
496
497 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
498 {
499         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
500 }