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         PanelType *pt;
  57         HeaderType *ht;
  58         MenuType *mt;
  59
  60         for(art= st->regiontypes.first; art; art= art->next) {
  61                 BLI_freelistN(&art->drawcalls);
  62
  63                 for(pt= art->paneltypes.first; pt; pt= pt->next)
  64                         if(pt->ext.free)
  65                                 pt->ext.free(pt->ext.data);
  66
  67                 for(ht= art->headertypes.first; ht; ht= ht->next)
  68                         if(ht->ext.free)
  69                                 ht->ext.free(ht->ext.data);
  70
  71                 for(mt= art->menutypes.first; mt; mt= mt->next)
  72                         if(mt->ext.free)
  73                                 mt->ext.free(mt->ext.data);
  74
  75                 BLI_freelistN(&art->paneltypes);
  76                 BLI_freelistN(&art->headertypes);
  77                 BLI_freelistN(&art->menutypes);
  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()
 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 /* ***************** Space handling ********************** */
 141
 142 void BKE_spacedata_freelist(ListBase *lb)
 143 {
 144         SpaceLink *sl;
 145         ARegion *ar;
 146
 147         for (sl= lb->first; sl; sl= sl->next) {
 148                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
 149
 150                 /* free regions for pushed spaces */
 151                 for(ar=sl->regionbase.first; ar; ar=ar->next)
 152                         BKE_area_region_free(st, ar);
 153
 154                 BLI_freelistN(&sl->regionbase);
 155
 156                 if(st && st->free)
 157                         st->free(sl);
 158         }
 159
 160         BLI_freelistN(lb);
 161 }
 162
 163 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
 164 {
 165         ARegion *newar= MEM_dupallocN(ar);
 166         Panel *pa, *newpa, *patab;
 167
 168         newar->prev= newar->next= NULL;
 169         newar->handlers.first= newar->handlers.last= NULL;
 170         newar->uiblocks.first= newar->uiblocks.last= NULL;
 171         newar->swinid= 0;
 172
 173         /* use optional regiondata callback */
 174         if(ar->regiondata) {
 175                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
 176
 177                 if(art && art->duplicate)
 178                         newar->regiondata= art->duplicate(ar->regiondata);
 179                 else
 180                         newar->regiondata= MEM_dupallocN(ar->regiondata);
 181         }
 182
 183         if(ar->v2d.tab_offset)
 184                 newar->v2d.tab_offset= MEM_dupallocN(ar->v2d.tab_offset);
 185
 186         newar->panels.first= newar->panels.last= NULL;
 187         BLI_duplicatelist(&newar->panels, &ar->panels);
 188
 189         /* copy panel pointers */
 190         for(newpa= newar->panels.first; newpa; newpa= newpa->next) {
 191                 patab= newar->panels.first;
 192                 pa= ar->panels.first;
 193                 while(patab) {
 194                         if(newpa->paneltab == pa) {
 195                                 newpa->paneltab = patab;
 196                                 break;
 197                         }
 198                         patab= patab->next;
 199                         pa= pa->next;
 200                 }
 201         }
 202
 203         return newar;
 204 }
 205
 206
 207 /* from lb2 to lb1, lb1 is supposed to be free'd */
 208 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
 209 {
 210         ARegion *ar;
 211
 212         /* to be sure */
 213         lb1->first= lb1->last= NULL;
 214
 215         for(ar= lb2->first; ar; ar= ar->next) {
 216                 ARegion *arnew= BKE_area_region_copy(st, ar);
 217                 BLI_addtail(lb1, arnew);
 218         }
 219 }
 220
 221
 222 /* lb1 should be empty */
 223 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
 224 {
 225         SpaceLink *sl;
 226
 227         lb1->first= lb1->last= NULL;    /* to be sure */
 228
 229         for (sl= lb2->first; sl; sl= sl->next) {
 230                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
 231
 232                 if(st && st->duplicate) {
 233                         SpaceLink *slnew= st->duplicate(sl);
 234
 235                         BLI_addtail(lb1, slnew);
 236
 237                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
 238                 }
 239         }
 240 }
 241
 242 /* lb1 should be empty */
 243 void BKE_spacedata_copyfirst(ListBase *lb1, ListBase *lb2)
 244 {
 245         SpaceLink *sl;
 246
 247         lb1->first= lb1->last= NULL;    /* to be sure */
 248
 249         sl= lb2->first;
 250         if(sl) {
 251                 SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
 252
 253                 if(st && st->duplicate) {
 254                         SpaceLink *slnew= st->duplicate(sl);
 255
 256                         BLI_addtail(lb1, slnew);
 257
 258                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
 259                 }
 260         }
 261 }
 262
 263 /* not region itself */
 264 void BKE_area_region_free(SpaceType *st, ARegion *ar)
 265 {
 266         if(st) {
 267                 ARegionType *art= BKE_regiontype_from_id(st, ar->regiontype);
 268
 269                 if(art && art->free)
 270                         art->free(ar);
 271
 272                 if(ar->regiondata)
 273                         printf("regiondata free error\n");
 274         }
 275         else if(ar->type && ar->type->free)
 276                 ar->type->free(ar);
 277
 278         if(ar->v2d.tab_offset) {
 279                 MEM_freeN(ar->v2d.tab_offset);
 280                 ar->v2d.tab_offset= NULL;
 281         }
 282
 283         if(ar)
 284                 BLI_freelistN(&ar->panels);
 285 }
 286
 287 /* not area itself */
 288 void BKE_screen_area_free(ScrArea *sa)
 289 {
 290         SpaceType *st= BKE_spacetype_from_id(sa->spacetype);
 291         ARegion *ar;
 292
 293         for(ar=sa->regionbase.first; ar; ar=ar->next)
 294                 BKE_area_region_free(st, ar);
 295
 296         BLI_freelistN(&sa->regionbase);
 297
 298         BKE_spacedata_freelist(&sa->spacedata);
 299
 300         BLI_freelistN(&sa->actionzones);
 301 }
 302
 303 /* don't free screen itself */
 304 void free_screen(bScreen *sc)
 305 {
 306         ScrArea *sa, *san;
 307         ARegion *ar;
 308
 309         for(ar=sc->regionbase.first; ar; ar=ar->next)
 310                 BKE_area_region_free(NULL, ar);
 311
 312         BLI_freelistN(&sc->regionbase);
 313
 314         for(sa= sc->areabase.first; sa; sa= san) {
 315                 san= sa->next;
 316                 BKE_screen_area_free(sa);
 317         }
 318
 319         BLI_freelistN(&sc->vertbase);
 320         BLI_freelistN(&sc->edgebase);
 321         BLI_freelistN(&sc->areabase);
 322 }
 323
 324