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 const ListBase *BKE_spacetypes_list()
  86 {
  87         return &spacetypes;
  88 }
  89
  90 void BKE_spacetype_register(SpaceType *st)
  91 {
  92         SpaceType *stype;
  93
  94         /* sanity check */
  95         stype= BKE_spacetype_from_id(st->spaceid);
  96         if(stype) {
  97                 printf("error: redefinition of spacetype %s\n", stype->name);
  98                 spacetype_free(stype);
  99                 MEM_freeN(stype);
 100         }
 101
 102         BLI_addtail(&spacetypes, st);
 103 }
 104
 105 /* ***************** Space handling ********************** */
 106
 107 void BKE_spacedata_freelist(ListBase *lb)
 108 {
 109         SpaceLink *sl;
 110         ARegion *ar;
 111
 112         for (sl= lb->first; sl; sl= sl->next) {
 113                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
 114
 115                 /* free regions for pushed spaces */
 116                 for(ar=sl->regionbase.first; ar; ar=ar->next) {
 117                         BKE_area_region_free(ar);
 118                 }
 119                 BLI_freelistN(&sl->regionbase);
 120
 121                 if(st && st->free)
 122                         st->free(sl);
 123         }
 124
 125         BLI_freelistN(lb);
 126 }
 127
 128 ARegion *BKE_area_region_copy(ARegion *ar)
 129 {
 130         ARegion *newar= MEM_dupallocN(ar);
 131         Panel *pa, *newpa, *patab;
 132
 133         newar->handlers.first= newar->handlers.last= NULL;
 134         newar->uiblocks.first= newar->uiblocks.last= NULL;
 135         newar->swinid= 0;
 136
 137         /* XXX regiondata callback */
 138         if(ar->regiondata)
 139                 newar->regiondata= MEM_dupallocN(ar->regiondata);
 140
 141         newar->panels.first= newar->panels.last= NULL;
 142         BLI_duplicatelist(&newar->panels, &ar->panels);
 143
 144         /* copy panel pointers */
 145         for(newpa= newar->panels.first; newpa; newpa= newpa->next) {
 146                 patab= newar->panels.first;
 147                 pa= ar->panels.first;
 148                 while(patab) {
 149                         if(newpa->paneltab == pa) {
 150                                 newpa->paneltab = patab;
 151                                 break;
 152                         }
 153                         patab= patab->next;
 154                         pa= pa->next;
 155                 }
 156         }
 157
 158         return newar;
 159 }
 160
 161
 162 /* from lb2 to lb1, lb1 is supposed to be free'd */
 163 static void region_copylist(ListBase *lb1, ListBase *lb2)
 164 {
 165         ARegion *ar;
 166
 167         /* to be sure */
 168         lb1->first= lb1->last= NULL;
 169
 170         for(ar= lb2->first; ar; ar= ar->next) {
 171                 ARegion *arnew= BKE_area_region_copy(ar);
 172                 BLI_addtail(lb1, arnew);
 173         }
 174 }
 175
 176
 177 /* lb1 should be empty */
 178 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
 179 {
 180         SpaceLink *sl;
 181
 182         lb1->first= lb2->last= NULL;    /* to be sure */
 183
 184         for (sl= lb2->first; sl; sl= sl->next) {
 185                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
 186
 187                 if(st && st->duplicate) {
 188                         SpaceLink *slnew= st->duplicate(sl);
 189
 190                         BLI_addtail(lb1, slnew);
 191
 192                         region_copylist(&slnew->regionbase, &sl->regionbase);
 193                 }
 194         }
 195 }
 196
 197 /* not region itself */
 198 void BKE_area_region_free(ARegion *ar)
 199 {
 200         if(ar) {
 201                 if(ar->type && ar->type->free)
 202                         ar->type->free(ar);
 203
 204                 BLI_freelistN(&ar->panels);
 205         }
 206 }
 207
 208 /* not area itself */
 209 void BKE_screen_area_free(ScrArea *sa)
 210 {
 211         ARegion *ar, *arn;
 212
 213         for(ar=sa->regionbase.first; ar; ar=arn) {
 214                 arn= ar->next;
 215                 BKE_area_region_free(ar);
 216         }
 217
 218         BKE_spacedata_freelist(&sa->spacedata);
 219
 220         BLI_freelistN(&sa->regionbase);
 221         BLI_freelistN(&sa->actionzones);
 222
 223 #ifndef DISABLE_PYTHON
 224         BPY_free_scriptlink(&sa->scriptlink);
 225 #endif
 226 }
 227
 228 /* don't free screen itself */
 229 void free_screen(bScreen *sc)
 230 {
 231         ScrArea *sa, *san;
 232         ARegion *ar, *arn;
 233
 234         for(ar=sc->regionbase.first; ar; ar=arn) {
 235                 arn= ar->next;
 236                 BKE_area_region_free(ar);
 237         }
 238         BLI_freelistN(&sc->regionbase);
 239
 240         for(sa= sc->areabase.first; sa; sa= san) {
 241                 san= sa->next;
 242                 BKE_screen_area_free(sa);
 243         }
 244
 245         BLI_freelistN(&sc->vertbase);
 246         BLI_freelistN(&sc->edgebase);
 247         BLI_freelistN(&sc->areabase);
 248 }
 249
 250