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