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 }