2.5
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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_screen_types.h"
37 #include "DNA_space_types.h"
38
39 #include "BLI_blenlib.h"
40
41 #include "BKE_screen.h"
42
43 #ifndef DISABLE_PYTHON
44 #include "BPY_extern.h"
45 #endif
46
47 /* ************ Spacetype/regiontype handling ************** */
48
49 /* keep global; this has to be accessible outside of windowmanager */
50 static ListBase spacetypes= {NULL, NULL};
51
52 /* not SpaceType itself */
53 static void spacetype_free(SpaceType *st)
54 {
55         ARegionType *art;
56         
57         for(art= st->regiontypes.first; art; art= art->next)
58                 BLI_freelistN(&art->drawcalls);
59         
60         BLI_freelistN(&st->regiontypes);
61 }
62
63 void BKE_spacetypes_free(void)
64 {
65         SpaceType *st;
66         
67         for(st= spacetypes.first; st; st= st->next) {
68                 spacetype_free(st);
69         }
70         
71         BLI_freelistN(&spacetypes);
72 }
73
74 SpaceType *BKE_spacetype_from_id(int spaceid)
75 {
76         SpaceType *st;
77         
78         for(st= spacetypes.first; st; st= st->next) {
79                 if(st->spaceid==spaceid)
80                         return st;
81         }
82         return NULL;
83 }
84
85 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
86 {
87         ARegionType *art;
88         
89         for(art= st->regiontypes.first; art; art= art->next)
90                 if(art->regionid==regionid)
91                         return art;
92         
93         printf("Error, region type missing in %s\n", st->name);
94         return st->regiontypes.first;
95 }
96
97
98 const ListBase *BKE_spacetypes_list()
99 {
100         return &spacetypes;
101 }
102
103 void BKE_spacetype_register(SpaceType *st)
104 {
105         SpaceType *stype;
106         
107         /* sanity check */
108         stype= BKE_spacetype_from_id(st->spaceid);
109         if(stype) {
110                 printf("error: redefinition of spacetype %s\n", stype->name);
111                 spacetype_free(stype);
112                 MEM_freeN(stype);
113         }
114         
115         BLI_addtail(&spacetypes, st);
116 }
117
118 /* ***************** Space handling ********************** */
119
120 void BKE_spacedata_freelist(ListBase *lb)
121 {
122         SpaceLink *sl;
123         ARegion *ar;
124         
125         for (sl= lb->first; sl; sl= sl->next) {
126                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
127                 
128                 /* free regions for pushed spaces */
129                 for(ar=sl->regionbase.first; ar; ar=ar->next)
130                         BKE_area_region_free(st, ar);
131
132                 BLI_freelistN(&sl->regionbase);
133                 
134                 if(st && st->free) 
135                         st->free(sl);
136         }
137         
138         BLI_freelistN(lb);
139 }
140
141 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
142 {
143         ARegion *newar= MEM_dupallocN(ar);
144         Panel *pa, *newpa, *patab;
145         
146         newar->prev= newar->next= NULL;
147         newar->handlers.first= newar->handlers.last= NULL;
148         newar->uiblocks.first= newar->uiblocks.last= NULL;
149         newar->swinid= 0;
150         
151         /* use optional regiondata callback */
152         if(ar->regiondata) {
153                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
154
155                 if(art && art->duplicate)
156                         newar->regiondata= art->duplicate(ar->regiondata);
157                 else
158                         newar->regiondata= MEM_dupallocN(ar->regiondata);
159         }
160         
161         newar->panels.first= newar->panels.last= NULL;
162         BLI_duplicatelist(&newar->panels, &ar->panels);
163         
164         /* copy panel pointers */
165         for(newpa= newar->panels.first; newpa; newpa= newpa->next) {
166                 patab= newar->panels.first;
167                 pa= ar->panels.first;
168                 while(patab) {
169                         if(newpa->paneltab == pa) {
170                                 newpa->paneltab = patab;
171                                 break;
172                         }
173                         patab= patab->next;
174                         pa= pa->next;
175                 }
176         }
177         
178         return newar;
179 }
180
181
182 /* from lb2 to lb1, lb1 is supposed to be free'd */
183 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
184 {
185         ARegion *ar;
186         
187         /* to be sure */
188         lb1->first= lb1->last= NULL;
189         
190         for(ar= lb2->first; ar; ar= ar->next) {
191                 ARegion *arnew= BKE_area_region_copy(st, ar);
192                 BLI_addtail(lb1, arnew);
193         }
194 }
195
196
197 /* lb1 should be empty */
198 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
199 {
200         SpaceLink *sl;
201         
202         lb1->first= lb2->last= NULL;    /* to be sure */
203         
204         for (sl= lb2->first; sl; sl= sl->next) {
205                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
206                 
207                 if(st && st->duplicate) {
208                         SpaceLink *slnew= st->duplicate(sl);
209                         
210                         BLI_addtail(lb1, slnew);
211                         
212                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
213                 }
214         }
215 }
216
217 /* not region itself */
218 void BKE_area_region_free(SpaceType *st, ARegion *ar)
219 {
220         if(st) {
221                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
222                 
223                 if(art && art->free)
224                         art->free(ar);
225         }
226         if(ar) {
227                 if(ar->regiondata)
228                         printf("regiondata free error\n");
229                 BLI_freelistN(&ar->panels);
230         }
231 }
232
233 /* not area itself */
234 void BKE_screen_area_free(ScrArea *sa)
235 {
236         SpaceType *st= BKE_spacetype_from_id(sa->spacetype);
237         ARegion *ar;
238         
239         for(ar=sa->regionbase.first; ar; ar=ar->next)
240                 BKE_area_region_free(st, ar);
241
242         BLI_freelistN(&sa->regionbase);
243         
244         BKE_spacedata_freelist(&sa->spacedata);
245         
246         BLI_freelistN(&sa->actionzones);
247         
248 #ifndef DISABLE_PYTHON
249         BPY_free_scriptlink(&sa->scriptlink);
250 #endif
251 }
252
253 /* don't free screen itself */
254 void free_screen(bScreen *sc)
255 {
256         ScrArea *sa, *san;
257         ARegion *ar;
258         
259         for(ar=sc->regionbase.first; ar; ar=ar->next)
260                 BKE_area_region_free(NULL, ar);
261
262         BLI_freelistN(&sc->regionbase);
263         
264         for(sa= sc->areabase.first; sa; sa= san) {
265                 san= sa->next;
266                 BKE_screen_area_free(sa);
267         }
268         
269         BLI_freelistN(&sc->vertbase);
270         BLI_freelistN(&sc->edgebase);
271         BLI_freelistN(&sc->areabase);
272 }
273
274