More F-Modifier Tweaks:
[blender.git] / source / blender / blenkernel / intern / screen.c
1 /* 
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <math.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_scene_types.h"
37 #include "DNA_screen_types.h"
38 #include "DNA_space_types.h"
39 #include "DNA_view3d_types.h"
40
41 #include "BLI_blenlib.h"
42
43 #include "BKE_screen.h"
44
45 #ifndef DISABLE_PYTHON
46 #include "BPY_extern.h"
47 #endif
48
49 /* ************ Spacetype/regiontype handling ************** */
50
51 /* keep global; this has to be accessible outside of windowmanager */
52 static ListBase spacetypes= {NULL, NULL};
53
54 /* not SpaceType itself */
55 static void spacetype_free(SpaceType *st)
56 {
57         ARegionType *art;
58         PanelType *pt;
59         HeaderType *ht;
60         
61         for(art= st->regiontypes.first; art; art= art->next) {
62                 BLI_freelistN(&art->drawcalls);
63
64                 for(pt= art->paneltypes.first; pt; pt= pt->next)
65                         if(pt->ext.free)
66                                 pt->ext.free(pt->ext.data);
67
68                 for(ht= art->headertypes.first; ht; ht= ht->next)
69                         if(ht->ext.free)
70                                 ht->ext.free(ht->ext.data);
71
72                 BLI_freelistN(&art->paneltypes);
73                 BLI_freelistN(&art->headertypes);
74         }
75         
76         BLI_freelistN(&st->regiontypes);
77         BLI_freelistN(&st->toolshelf);
78
79 }
80
81 void BKE_spacetypes_free(void)
82 {
83         SpaceType *st;
84         
85         for(st= spacetypes.first; st; st= st->next) {
86                 spacetype_free(st);
87         }
88         
89         BLI_freelistN(&spacetypes);
90 }
91
92 SpaceType *BKE_spacetype_from_id(int spaceid)
93 {
94         SpaceType *st;
95         
96         for(st= spacetypes.first; st; st= st->next) {
97                 if(st->spaceid==spaceid)
98                         return st;
99         }
100         return NULL;
101 }
102
103 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
104 {
105         ARegionType *art;
106         
107         for(art= st->regiontypes.first; art; art= art->next)
108                 if(art->regionid==regionid)
109                         return art;
110         
111         printf("Error, region type missing in - name:\"%s\", id:%d\n", st->name, st->spaceid);
112         return st->regiontypes.first;
113 }
114
115
116 const ListBase *BKE_spacetypes_list()
117 {
118         return &spacetypes;
119 }
120
121 void BKE_spacetype_register(SpaceType *st)
122 {
123         SpaceType *stype;
124         
125         /* sanity check */
126         stype= BKE_spacetype_from_id(st->spaceid);
127         if(stype) {
128                 printf("error: redefinition of spacetype %s\n", stype->name);
129                 spacetype_free(stype);
130                 MEM_freeN(stype);
131         }
132         
133         BLI_addtail(&spacetypes, st);
134 }
135
136 /* ***************** Space handling ********************** */
137
138 void BKE_spacedata_freelist(ListBase *lb)
139 {
140         SpaceLink *sl;
141         ARegion *ar;
142         
143         for (sl= lb->first; sl; sl= sl->next) {
144                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
145                 
146                 /* free regions for pushed spaces */
147                 for(ar=sl->regionbase.first; ar; ar=ar->next)
148                         BKE_area_region_free(st, ar);
149
150                 BLI_freelistN(&sl->regionbase);
151                 
152                 if(st && st->free) 
153                         st->free(sl);
154         }
155         
156         BLI_freelistN(lb);
157 }
158
159 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
160 {
161         ARegion *newar= MEM_dupallocN(ar);
162         Panel *pa, *newpa, *patab;
163         
164         newar->prev= newar->next= NULL;
165         newar->handlers.first= newar->handlers.last= NULL;
166         newar->uiblocks.first= newar->uiblocks.last= NULL;
167         newar->swinid= 0;
168         
169         /* use optional regiondata callback */
170         if(ar->regiondata) {
171                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
172
173                 if(art && art->duplicate)
174                         newar->regiondata= art->duplicate(ar->regiondata);
175                 else
176                         newar->regiondata= MEM_dupallocN(ar->regiondata);
177         }
178
179         if(ar->v2d.tab_offset)
180                 newar->v2d.tab_offset= MEM_dupallocN(ar->v2d.tab_offset);
181         
182         newar->panels.first= newar->panels.last= NULL;
183         BLI_duplicatelist(&newar->panels, &ar->panels);
184         
185         /* copy panel pointers */
186         for(newpa= newar->panels.first; newpa; newpa= newpa->next) {
187                 patab= newar->panels.first;
188                 pa= ar->panels.first;
189                 while(patab) {
190                         if(newpa->paneltab == pa) {
191                                 newpa->paneltab = patab;
192                                 break;
193                         }
194                         patab= patab->next;
195                         pa= pa->next;
196                 }
197         }
198         
199         return newar;
200 }
201
202
203 /* from lb2 to lb1, lb1 is supposed to be free'd */
204 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
205 {
206         ARegion *ar;
207         
208         /* to be sure */
209         lb1->first= lb1->last= NULL;
210         
211         for(ar= lb2->first; ar; ar= ar->next) {
212                 ARegion *arnew= BKE_area_region_copy(st, ar);
213                 BLI_addtail(lb1, arnew);
214         }
215 }
216
217
218 /* lb1 should be empty */
219 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
220 {
221         SpaceLink *sl;
222         
223         lb1->first= lb1->last= NULL;    /* to be sure */
224         
225         for (sl= lb2->first; sl; sl= sl->next) {
226                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
227                 
228                 if(st && st->duplicate) {
229                         SpaceLink *slnew= st->duplicate(sl);
230                         
231                         BLI_addtail(lb1, slnew);
232                         
233                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
234                 }
235         }
236 }
237
238 /* lb1 should be empty */
239 void BKE_spacedata_copyfirst(ListBase *lb1, ListBase *lb2)
240 {
241         SpaceLink *sl;
242         
243         lb1->first= lb1->last= NULL;    /* to be sure */
244         
245         sl= lb2->first;
246         if(sl) {
247                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
248
249                 if(st && st->duplicate) {
250                         SpaceLink *slnew= st->duplicate(sl);
251
252                         BLI_addtail(lb1, slnew);
253
254                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
255                 }
256         }
257 }
258
259 /* not region itself */
260 void BKE_area_region_free(SpaceType *st, ARegion *ar)
261 {
262         if(st) {
263                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
264                 
265                 if(art && art->free)
266                         art->free(ar);
267                 
268                 if(ar->regiondata)
269                         printf("regiondata free error\n");
270         }
271         else if(ar->type && ar->type->free)
272                 ar->type->free(ar);
273         
274         if(ar->v2d.tab_offset) {
275                 MEM_freeN(ar->v2d.tab_offset);
276                 ar->v2d.tab_offset= NULL;
277         }
278
279         if(ar)
280                 BLI_freelistN(&ar->panels);
281 }
282
283 /* not area itself */
284 void BKE_screen_area_free(ScrArea *sa)
285 {
286         SpaceType *st= BKE_spacetype_from_id(sa->spacetype);
287         ARegion *ar;
288         
289         for(ar=sa->regionbase.first; ar; ar=ar->next)
290                 BKE_area_region_free(st, ar);
291
292         BLI_freelistN(&sa->regionbase);
293         
294         BKE_spacedata_freelist(&sa->spacedata);
295         
296         BLI_freelistN(&sa->actionzones);
297 }
298
299 /* don't free screen itself */
300 void free_screen(bScreen *sc)
301 {
302         ScrArea *sa, *san;
303         ARegion *ar;
304         
305         for(ar=sc->regionbase.first; ar; ar=ar->next)
306                 BKE_area_region_free(NULL, ar);
307
308         BLI_freelistN(&sc->regionbase);
309         
310         for(sa= sc->areabase.first; sa; sa= san) {
311                 san= sa->next;
312                 BKE_screen_area_free(sa);
313         }
314         
315         BLI_freelistN(&sc->vertbase);
316         BLI_freelistN(&sc->edgebase);
317         BLI_freelistN(&sc->areabase);
318 }
319
320 /* for depsgraph */
321 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
322 {
323         ScrArea *sa;
324         unsigned int layer= 0;
325
326         if(screen) {
327                 /* get all used view3d layers */
328                 for(sa= screen->areabase.first; sa; sa= sa->next)
329                         if(sa->spacetype==SPACE_VIEW3D)
330                                 layer |= ((View3D *)sa->spacedata.first)->lay;
331         }
332
333         if(!layer)
334                 return scene->lay;
335
336         return layer;
337 }
338
339 /* ***************** Utilities ********************** */
340
341 /* Find a region of the specified type from the given area */
342 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
343 {
344         if (sa) {
345                 ARegion *ar;
346                 
347                 for (ar=sa->regionbase.first; ar; ar= ar->next) {
348                         if (ar->regiontype == type)
349                                 return ar;
350                 }
351         }
352         return NULL;
353 }