source/blender/blenkernel/intern/context.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  * Contributor(s): Blender Foundation (2008).
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include "MEM_guardedalloc.h"
  29
  30 #include "DNA_scene_types.h"
  31 #include "DNA_screen_types.h"
  32 #include "DNA_space_types.h"
  33 #include "DNA_view3d_types.h"
  34 #include "DNA_windowmanager_types.h"
  35 #include "DNA_object_types.h"
  36
  37 #include "RNA_access.h"
  38
  39 #include "BLI_listbase.h"
  40 #include "BLI_string.h"
  41
  42 #include "BKE_context.h"
  43 #include "BKE_main.h"
  44 #include "BKE_screen.h"
  45
  46 #ifndef DISABLE_PYTHON
  47 #include "BPY_extern.h"
  48 #endif
  49
  50 #include <string.h>
  51
  52 /* struct */
  53
  54 struct bContext {
  55         int thread;
  56
  57         /* windowmanager context */
  58         struct {
  59                 struct wmWindowManager *manager;
  60                 struct wmWindow *window;
  61                 struct bScreen *screen;
  62                 struct ScrArea *area;
  63                 struct ARegion *region;
  64                 struct ARegion *menu;
  65                 struct bContextStore *store;
  66         } wm;
  67
  68         /* data context */
  69         struct {
  70                 struct Main *main;
  71                 struct Scene *scene;
  72
  73                 int recursion;
  74                 int py_init; /* true if python is initialized */
  75                 void *py_context;
  76         } data;
  77
  78         /* data evaluation */
  79         struct {
  80                 int render;
  81         } eval;
  82 };
  83
  84 /* context */
  85
  86 bContext *CTX_create()
  87 {
  88         bContext *C;
  89
  90         C= MEM_callocN(sizeof(bContext), "bContext");
  91
  92         return C;
  93 }
  94
  95 bContext *CTX_copy(const bContext *C)
  96 {
  97         bContext *newC= MEM_dupallocN((void*)C);
  98
  99         return newC;
 100 }
 101
 102 void CTX_free(bContext *C)
 103 {
 104         MEM_freeN(C);
 105 }
 106
 107 /* store */
 108
 109 bContextStore *CTX_store_add(ListBase *contexts, char *name, PointerRNA *ptr)
 110 {
 111         bContextStoreEntry *entry;
 112         bContextStore *ctx, *lastctx;
 113
 114         /* ensure we have a context to put the entry in, if it was already used
 115          * we have to copy the context to ensure */
 116         ctx= contexts->last;
 117
 118         if(!ctx || ctx->used) {
 119                 if(ctx) {
 120                         lastctx= ctx;
 121                         ctx= MEM_dupallocN(lastctx);
 122                         BLI_duplicatelist(&ctx->entries, &lastctx->entries);
 123                 }
 124                 else
 125                         ctx= MEM_callocN(sizeof(bContextStore), "bContextStore");
 126
 127                 BLI_addtail(contexts, ctx);
 128         }
 129
 130         entry= MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry");
 131         BLI_strncpy(entry->name, name, sizeof(entry->name));
 132         entry->ptr= *ptr;
 133
 134         BLI_addtail(&ctx->entries, entry);
 135
 136         return ctx;
 137 }
 138
 139 void CTX_store_set(bContext *C, bContextStore *store)
 140 {
 141         C->wm.store= store;
 142 }
 143
 144 bContextStore *CTX_store_copy(bContextStore *store)
 145 {
 146         bContextStore *ctx;
 147
 148         ctx= MEM_dupallocN(store);
 149         BLI_duplicatelist(&ctx->entries, &store->entries);
 150
 151         return ctx;
 152 }
 153
 154 void CTX_store_free(bContextStore *store)
 155 {
 156         BLI_freelistN(&store->entries);
 157         MEM_freeN(store);
 158 }
 159
 160 void CTX_store_free_list(ListBase *contexts)
 161 {
 162         bContextStore *ctx;
 163
 164         while((ctx= contexts->first)) {
 165                 BLI_remlink(contexts, ctx);
 166                 CTX_store_free(ctx);
 167         }
 168 }
 169
 170 /* is python initialied? */
 171 int CTX_py_init_get(bContext *C)
 172 {
 173         return C->data.py_init;
 174 }
 175 void CTX_py_init_set(bContext *C, int value)
 176 {
 177         C->data.py_init= value;
 178 }
 179
 180 void *CTX_py_dict_get(bContext *C)
 181 {
 182         return C->data.py_context;
 183 }
 184 void CTX_py_dict_set(bContext *C, void *value)
 185 {
 186         C->data.py_context= value;
 187 }
 188
 189 /* window manager context */
 190
 191 wmWindowManager *CTX_wm_manager(const bContext *C)
 192 {
 193         return C->wm.manager;
 194 }
 195
 196 wmWindow *CTX_wm_window(const bContext *C)
 197 {
 198         return C->wm.window;
 199 }
 200
 201 bScreen *CTX_wm_screen(const bContext *C)
 202 {
 203         return C->wm.screen;
 204 }
 205
 206 ScrArea *CTX_wm_area(const bContext *C)
 207 {
 208         return C->wm.area;
 209 }
 210
 211 SpaceLink *CTX_wm_space_data(const bContext *C)
 212 {
 213         return (C->wm.area)? C->wm.area->spacedata.first: NULL;
 214 }
 215
 216 ARegion *CTX_wm_region(const bContext *C)
 217 {
 218         return C->wm.region;
 219 }
 220
 221 void *CTX_wm_region_data(const bContext *C)
 222 {
 223         return (C->wm.region)? C->wm.region->regiondata: NULL;
 224 }
 225
 226 struct ARegion *CTX_wm_menu(const bContext *C)
 227 {
 228         return C->wm.menu;
 229 }
 230
 231 struct ReportList *CTX_wm_reports(const bContext *C)
 232 {
 233         if (C->wm.manager)
 234                 return &(C->wm.manager->reports);
 235
 236         return NULL;
 237 }
 238
 239 View3D *CTX_wm_view3d(const bContext *C)
 240 {
 241         if(C->wm.area && C->wm.area->spacetype==SPACE_VIEW3D)
 242                 return C->wm.area->spacedata.first;
 243         return NULL;
 244 }
 245
 246 RegionView3D *CTX_wm_region_view3d(const bContext *C)
 247 {
 248         if(C->wm.area && C->wm.area->spacetype==SPACE_VIEW3D)
 249                 if(C->wm.region)
 250                         return C->wm.region->regiondata;
 251         return NULL;
 252 }
 253
 254 struct SpaceText *CTX_wm_space_text(const bContext *C)
 255 {
 256         if(C->wm.area && C->wm.area->spacetype==SPACE_TEXT)
 257                 return C->wm.area->spacedata.first;
 258         return NULL;
 259 }
 260
 261 struct SpaceConsole *CTX_wm_space_console(const bContext *C)
 262 {
 263         if(C->wm.area && C->wm.area->spacetype==SPACE_CONSOLE)
 264                 return C->wm.area->spacedata.first;
 265         return NULL;
 266 }
 267
 268 struct SpaceImage *CTX_wm_space_image(const bContext *C)
 269 {
 270         if(C->wm.area && C->wm.area->spacetype==SPACE_IMAGE)
 271                 return C->wm.area->spacedata.first;
 272         return NULL;
 273 }
 274
 275 struct SpaceButs *CTX_wm_space_buts(const bContext *C)
 276 {
 277         if(C->wm.area && C->wm.area->spacetype==SPACE_BUTS)
 278                 return C->wm.area->spacedata.first;
 279         return NULL;
 280 }
 281
 282 struct SpaceFile *CTX_wm_space_file(const bContext *C)
 283 {
 284         if(C->wm.area && C->wm.area->spacetype==SPACE_FILE)
 285                 return C->wm.area->spacedata.first;
 286         return NULL;
 287 }
 288
 289 struct SpaceSeq *CTX_wm_space_seq(const bContext *C)
 290 {
 291         if(C->wm.area && C->wm.area->spacetype==SPACE_SEQ)
 292                 return C->wm.area->spacedata.first;
 293         return NULL;
 294 }
 295
 296 struct SpaceOops *CTX_wm_space_outliner(const bContext *C)
 297 {
 298         if(C->wm.area && C->wm.area->spacetype==SPACE_OUTLINER)
 299                 return C->wm.area->spacedata.first;
 300         return NULL;
 301 }
 302
 303 struct SpaceNla *CTX_wm_space_nla(const bContext *C)
 304 {
 305         if(C->wm.area && C->wm.area->spacetype==SPACE_NLA)
 306                 return C->wm.area->spacedata.first;
 307         return NULL;
 308 }
 309
 310 struct SpaceTime *CTX_wm_space_time(const bContext *C)
 311 {
 312         if(C->wm.area && C->wm.area->spacetype==SPACE_TIME)
 313                 return C->wm.area->spacedata.first;
 314         return NULL;
 315 }
 316
 317 struct SpaceNode *CTX_wm_space_node(const bContext *C)
 318 {
 319         if(C->wm.area && C->wm.area->spacetype==SPACE_NODE)
 320                 return C->wm.area->spacedata.first;
 321         return NULL;
 322 }
 323
 324 struct SpaceLogic *CTX_wm_space_logic(const bContext *C)
 325 {
 326         if(C->wm.area && C->wm.area->spacetype==SPACE_LOGIC)
 327                 return C->wm.area->spacedata.first;
 328         return NULL;
 329 }
 330
 331 struct SpaceIpo *CTX_wm_space_graph(const bContext *C)
 332 {
 333         if(C->wm.area && C->wm.area->spacetype==SPACE_IPO)
 334                 return C->wm.area->spacedata.first;
 335         return NULL;
 336 }
 337
 338 struct SpaceAction *CTX_wm_space_action(const bContext *C)
 339 {
 340         if(C->wm.area && C->wm.area->spacetype==SPACE_ACTION)
 341                 return C->wm.area->spacedata.first;
 342         return NULL;
 343 }
 344
 345 struct SpaceInfo *CTX_wm_space_info(const bContext *C)
 346 {
 347         if(C->wm.area && C->wm.area->spacetype==SPACE_INFO)
 348                 return C->wm.area->spacedata.first;
 349         return NULL;
 350 }
 351
 352 struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C)
 353 {
 354         if(C->wm.area && C->wm.area->spacetype==SPACE_USERPREF)
 355                 return C->wm.area->spacedata.first;
 356         return NULL;
 357 }
 358
 359 void CTX_wm_manager_set(bContext *C, wmWindowManager *wm)
 360 {
 361         C->wm.manager= wm;
 362         C->wm.window= NULL;
 363         C->wm.screen= NULL;
 364         C->wm.area= NULL;
 365         C->wm.region= NULL;
 366 }
 367
 368 void CTX_wm_window_set(bContext *C, wmWindow *win)
 369 {
 370         C->wm.window= win;
 371         C->wm.screen= (win)? win->screen: NULL;
 372         C->data.scene= (C->wm.screen)? C->wm.screen->scene: NULL;
 373         C->wm.area= NULL;
 374         C->wm.region= NULL;
 375 }
 376
 377 void CTX_wm_screen_set(bContext *C, bScreen *screen)
 378 {
 379         C->wm.screen= screen;
 380         C->data.scene= (C->wm.screen)? C->wm.screen->scene: NULL;
 381         C->wm.area= NULL;
 382         C->wm.region= NULL;
 383 }
 384
 385 void CTX_wm_area_set(bContext *C, ScrArea *area)
 386 {
 387         C->wm.area= area;
 388         C->wm.region= NULL;
 389 }
 390
 391 void CTX_wm_region_set(bContext *C, ARegion *region)
 392 {
 393         C->wm.region= region;
 394 }
 395
 396 void CTX_wm_menu_set(bContext *C, ARegion *menu)
 397 {
 398         C->wm.menu= menu;
 399 }
 400
 401 /* data context utility functions */
 402
 403 struct bContextDataResult {
 404         PointerRNA ptr;
 405         ListBase list;
 406         const char **dir;
 407 };
 408
 409 static int ctx_data_get(bContext *C, const char *member, bContextDataResult *result)
 410 {
 411         int done= 0, recursion= C->data.recursion;
 412         int ret= 0;
 413
 414         memset(result, 0, sizeof(bContextDataResult));
 415 #ifndef DISABLE_PYTHON
 416         if(CTX_py_dict_get(C)) {
 417                 return BPY_context_get(C, member, result);
 418 //              if (BPY_context_get(C, member, result))
 419 //                      return 1;
 420         }
 421 #endif
 422         /* we check recursion to ensure that we do not get infinite
 423          * loops requesting data from ourselfs in a context callback */
 424
 425         /* Ok, this looks evil...
 426          * if(ret) done= -(-ret | -done);
 427          *
 428          * Values in order of importance
 429          * (0, -1, 1) - Where 1 is highest priority
 430          * */
 431         if(done!=1 && recursion < 1 && C->wm.store) {
 432                 bContextStoreEntry *entry;
 433
 434                 C->data.recursion= 1;
 435
 436                 for(entry=C->wm.store->entries.first; entry; entry=entry->next) {
 437                         if(strcmp(entry->name, member) == 0) {
 438                                 result->ptr= entry->ptr;
 439                                 done= 1;
 440                         }
 441                 }
 442         }
 443         if(done!=1 && recursion < 2 && C->wm.region) {
 444                 C->data.recursion= 2;
 445                 if(C->wm.region->type && C->wm.region->type->context) {
 446                         ret = C->wm.region->type->context(C, member, result);
 447                         if(ret) done= -(-ret | -done);
 448
 449                 }
 450         }
 451         if(done!=1 && recursion < 3 && C->wm.area) {
 452                 C->data.recursion= 3;
 453                 if(C->wm.area->type && C->wm.area->type->context) {
 454                         ret = C->wm.area->type->context(C, member, result);
 455                         if(ret) done= -(-ret | -done);
 456                 }
 457         }
 458         if(done!=1 && recursion < 4 && C->wm.screen) {
 459                 bContextDataCallback cb= C->wm.screen->context;
 460                 C->data.recursion= 4;
 461                 if(cb) {
 462                         ret = cb(C, member, result);
 463                         if(ret) done= -(-ret | -done);
 464                 }
 465         }
 466
 467         C->data.recursion= recursion;
 468
 469         return done;
 470 }
 471
 472 static void *ctx_data_pointer_get(const bContext *C, const char *member)
 473 {
 474         bContextDataResult result;
 475
 476         if(C && ctx_data_get((bContext*)C, member, &result)==1)
 477                 return result.ptr.data;
 478
 479         return NULL;
 480 }
 481
 482 static int ctx_data_pointer_verify(const bContext *C, const char *member, void **pointer)
 483 {
 484         bContextDataResult result;
 485
 486         /* if context is NULL, pointer must be NULL too and that is a valid return */
 487         if (C == NULL) {
 488                 *pointer= NULL;
 489                 return 1;
 490         }
 491         else if(ctx_data_get((bContext*)C, member, &result)==1) {
 492                 *pointer= result.ptr.data;
 493                 return 1;
 494         }
 495         else {
 496                 *pointer= NULL;
 497                 return 0;
 498         }
 499 }
 500
 501 static int ctx_data_collection_get(const bContext *C, const char *member, ListBase *list)
 502 {
 503         bContextDataResult result;
 504
 505         if(ctx_data_get((bContext*)C, member, &result)==1) {
 506                 *list= result.list;
 507                 return 1;
 508         }
 509
 510         list->first= NULL;
 511         list->last= NULL;
 512
 513         return 0;
 514 }
 515
 516 PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
 517 {
 518         bContextDataResult result;
 519
 520         if(ctx_data_get((bContext*)C, member, &result)==1)
 521                 return result.ptr;
 522         else
 523                 return PointerRNA_NULL;
 524 }
 525
 526 PointerRNA CTX_data_pointer_get_type(const bContext *C, const char *member, StructRNA *type)
 527 {
 528         PointerRNA ptr = CTX_data_pointer_get(C, member);
 529
 530         if(ptr.data && RNA_struct_is_a(ptr.type, type))
 531                 return ptr;
 532
 533         return PointerRNA_NULL;
 534 }
 535
 536 ListBase CTX_data_collection_get(const bContext *C, const char *member)
 537 {
 538         bContextDataResult result;
 539
 540         if(ctx_data_get((bContext*)C, member, &result)==1) {
 541                 return result.list;
 542         }
 543         else {
 544                 ListBase list;
 545                 memset(&list, 0, sizeof(list));
 546                 return list;
 547         }
 548 }
 549
 550 /* 1:found,  -1:found but not set,  0:not found */
 551 int CTX_data_get(const bContext *C, const char *member, PointerRNA *r_ptr, ListBase *r_lb)
 552 {
 553         bContextDataResult result;
 554         int ret= ctx_data_get((bContext*)C, member, &result);
 555
 556         if(ret==1) {
 557                 *r_ptr= result.ptr;
 558                 *r_lb= result.list;
 559         }
 560         else {
 561                 memset(r_ptr, 0, sizeof(*r_ptr));
 562                 memset(r_lb, 0, sizeof(*r_lb));
 563         }
 564
 565         return ret;
 566 }
 567
 568 static void data_dir_add(ListBase *lb, const char *member)
 569 {
 570         LinkData *link;
 571
 572         if(strcmp(member, "scene") == 0) /* exception */
 573                 return;
 574
 575         for(link=lb->first; link; link=link->next)
 576                 if(strcmp(link->data, member) == 0)
 577                         return;
 578
 579         link= MEM_callocN(sizeof(LinkData), "LinkData");
 580         link->data= (void*)member;
 581         BLI_addtail(lb, link);
 582 }
 583
 584 ListBase CTX_data_dir_get(const bContext *C)
 585 {
 586         bContextDataResult result;
 587         ListBase lb;
 588         int a;
 589
 590         memset(&lb, 0, sizeof(lb));
 591
 592         if(C->wm.store) {
 593                 bContextStoreEntry *entry;
 594
 595                 for(entry=C->wm.store->entries.first; entry; entry=entry->next)
 596                         data_dir_add(&lb, entry->name);
 597         }
 598         if(C->wm.region && C->wm.region->type && C->wm.region->type->context) {
 599                 memset(&result, 0, sizeof(result));
 600                 C->wm.region->type->context(C, "", &result);
 601
 602                 if(result.dir)
 603                         for(a=0; result.dir[a]; a++)
 604                                 data_dir_add(&lb, result.dir[a]);
 605         }
 606         if(C->wm.area && C->wm.area->type && C->wm.area->type->context) {
 607                 memset(&result, 0, sizeof(result));
 608                 C->wm.area->type->context(C, "", &result);
 609
 610                 if(result.dir)
 611                         for(a=0; result.dir[a]; a++)
 612                                 data_dir_add(&lb, result.dir[a]);
 613         }
 614         if(C->wm.screen && C->wm.screen->context) {
 615                 bContextDataCallback cb= C->wm.screen->context;
 616                 memset(&result, 0, sizeof(result));
 617                 cb(C, "", &result);
 618
 619                 if(result.dir)
 620                         for(a=0; result.dir[a]; a++)
 621                                 data_dir_add(&lb, result.dir[a]);
 622         }
 623
 624         return lb;
 625 }
 626
 627 int CTX_data_equals(const char *member, const char *str)
 628 {
 629         return (strcmp(member, str) == 0);
 630 }
 631
 632 int CTX_data_dir(const char *member)
 633 {
 634         return (strcmp(member, "") == 0);
 635 }
 636
 637 void CTX_data_id_pointer_set(bContextDataResult *result, ID *id)
 638 {
 639         RNA_id_pointer_create(id, &result->ptr);
 640 }
 641
 642 void CTX_data_pointer_set(bContextDataResult *result, ID *id, StructRNA *type, void *data)
 643 {
 644         RNA_pointer_create(id, type, data, &result->ptr);
 645 }
 646
 647 void CTX_data_id_list_add(bContextDataResult *result, ID *id)
 648 {
 649         CollectionPointerLink *link;
 650
 651         link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");
 652         RNA_id_pointer_create(id, &link->ptr);
 653
 654         BLI_addtail(&result->list, link);
 655 }
 656
 657 void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void *data)
 658 {
 659         CollectionPointerLink *link;
 660
 661         link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");
 662         RNA_pointer_create(id, type, data, &link->ptr);
 663
 664         BLI_addtail(&result->list, link);
 665 }
 666
 667 int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase*))
 668 {
 669         ListBase list;
 670
 671         if(func(C, &list)) {
 672                 int tot= BLI_countlist(&list);
 673                 BLI_freelistN(&list);
 674                 return tot;
 675         }
 676         else
 677                 return 0;
 678 }
 679
 680 void CTX_data_dir_set(bContextDataResult *result, const char **dir)
 681 {
 682         result->dir= dir;
 683 }
 684
 685 /* data context */
 686
 687 Main *CTX_data_main(const bContext *C)
 688 {
 689         Main *bmain;
 690
 691         if(ctx_data_pointer_verify(C, "main", (void*)&bmain))
 692                 return bmain;
 693         else
 694                 return C->data.main;
 695 }
 696
 697 void CTX_data_main_set(bContext *C, Main *bmain)
 698 {
 699         C->data.main= bmain;
 700 }
 701
 702 Scene *CTX_data_scene(const bContext *C)
 703 {
 704         Scene *scene;
 705
 706         if(ctx_data_pointer_verify(C, "scene", (void*)&scene))
 707                 return scene;
 708         else
 709                 return C->data.scene;
 710 }
 711
 712 int CTX_data_mode_enum(const bContext *C)
 713 {
 714         Object *obedit= CTX_data_edit_object(C);
 715
 716         if(obedit) {
 717                 switch(obedit->type) {
 718                         case OB_MESH:
 719                                 return CTX_MODE_EDIT_MESH;
 720                         case OB_CURVE:
 721                                 return CTX_MODE_EDIT_CURVE;
 722                         case OB_SURF:
 723                                 return CTX_MODE_EDIT_SURFACE;
 724                         case OB_FONT:
 725                                 return CTX_MODE_EDIT_TEXT;
 726                         case OB_ARMATURE:
 727                                 return CTX_MODE_EDIT_ARMATURE;
 728                         case OB_MBALL:
 729                                 return CTX_MODE_EDIT_METABALL;
 730                         case OB_LATTICE:
 731                                 return CTX_MODE_EDIT_LATTICE;
 732                 }
 733         }
 734         else {
 735                 Object *ob = CTX_data_active_object(C);
 736
 737                 if(ob) {
 738                         if(ob->mode & OB_MODE_POSE) return CTX_MODE_POSE;
 739                         else if(ob->mode & OB_MODE_SCULPT)  return CTX_MODE_SCULPT;
 740                         else if(ob->mode & OB_MODE_WEIGHT_PAINT) return CTX_MODE_PAINT_WEIGHT;
 741                         else if(ob->mode & OB_MODE_VERTEX_PAINT) return CTX_MODE_PAINT_VERTEX;
 742                         else if(ob->mode & OB_MODE_TEXTURE_PAINT) return CTX_MODE_PAINT_TEXTURE;
 743                         else if(ob->mode & OB_MODE_PARTICLE_EDIT) return CTX_MODE_PARTICLE;
 744                 }
 745         }
 746
 747         return CTX_MODE_OBJECT;
 748 }
 749
 750
 751 /* would prefer if we can use the enum version below over this one - Campbell */
 752 /* must be aligned with above enum  */
 753 static char *data_mode_strings[] = {
 754         "mesh_edit",
 755         "curve_edit",
 756         "surface_edit",
 757         "text_edit",
 758         "armature_edit",
 759         "mball_edit",
 760         "lattice_edit",
 761         "posemode",
 762         "sculpt_mode",
 763         "weightpaint",
 764         "vertexpaint",
 765         "texturepaint",
 766         "particlemode",
 767         "objectmode",
 768         0
 769 };
 770 char *CTX_data_mode_string(const bContext *C)
 771 {
 772         return data_mode_strings[CTX_data_mode_enum(C)];
 773 }
 774
 775 void CTX_data_scene_set(bContext *C, Scene *scene)
 776 {
 777         C->data.scene= scene;
 778 }
 779
 780 ToolSettings *CTX_data_tool_settings(const bContext *C)
 781 {
 782         Scene *scene = CTX_data_scene(C);
 783
 784         if(scene)
 785                 return scene->toolsettings;
 786         else
 787                 return NULL;
 788 }
 789
 790 int CTX_data_selected_nodes(const bContext *C, ListBase *list)
 791 {
 792         return ctx_data_collection_get(C, "selected_nodes", list);
 793 }
 794
 795 int CTX_data_selected_editable_objects(const bContext *C, ListBase *list)
 796 {
 797         return ctx_data_collection_get(C, "selected_editable_objects", list);
 798 }
 799
 800 int CTX_data_selected_editable_bases(const bContext *C, ListBase *list)
 801 {
 802         return ctx_data_collection_get(C, "selected_editable_bases", list);
 803 }
 804
 805 int CTX_data_selected_objects(const bContext *C, ListBase *list)
 806 {
 807         return ctx_data_collection_get(C, "selected_objects", list);
 808 }
 809
 810 int CTX_data_selected_bases(const bContext *C, ListBase *list)
 811 {
 812         return ctx_data_collection_get(C, "selected_bases", list);
 813 }
 814
 815 int CTX_data_visible_objects(const bContext *C, ListBase *list)
 816 {
 817         return ctx_data_collection_get(C, "visible_objects", list);
 818 }
 819
 820 int CTX_data_visible_bases(const bContext *C, ListBase *list)
 821 {
 822         return ctx_data_collection_get(C, "visible_bases", list);
 823 }
 824
 825 int CTX_data_selectable_objects(const bContext *C, ListBase *list)
 826 {
 827         return ctx_data_collection_get(C, "selectable_objects", list);
 828 }
 829
 830 int CTX_data_selectable_bases(const bContext *C, ListBase *list)
 831 {
 832         return ctx_data_collection_get(C, "selectable_bases", list);
 833 }
 834
 835 struct Object *CTX_data_active_object(const bContext *C)
 836 {
 837         return ctx_data_pointer_get(C, "active_object");
 838 }
 839
 840 struct Base *CTX_data_active_base(const bContext *C)
 841 {
 842         return ctx_data_pointer_get(C, "active_base");
 843 }
 844
 845 struct Object *CTX_data_edit_object(const bContext *C)
 846 {
 847         return ctx_data_pointer_get(C, "edit_object");
 848 }
 849
 850 struct Image *CTX_data_edit_image(const bContext *C)
 851 {
 852         return ctx_data_pointer_get(C, "edit_image");
 853 }
 854
 855 struct Text *CTX_data_edit_text(const bContext *C)
 856 {
 857         return ctx_data_pointer_get(C, "edit_text");
 858 }
 859
 860 struct EditBone *CTX_data_active_bone(const bContext *C)
 861 {
 862         return ctx_data_pointer_get(C, "active_bone");
 863 }
 864
 865 int CTX_data_selected_bones(const bContext *C, ListBase *list)
 866 {
 867         return ctx_data_collection_get(C, "selected_bones", list);
 868 }
 869
 870 int CTX_data_selected_editable_bones(const bContext *C, ListBase *list)
 871 {
 872         return ctx_data_collection_get(C, "selected_editable_bones", list);
 873 }
 874
 875 int CTX_data_visible_bones(const bContext *C, ListBase *list)
 876 {
 877         return ctx_data_collection_get(C, "visible_bones", list);
 878 }
 879
 880 int CTX_data_editable_bones(const bContext *C, ListBase *list)
 881 {
 882         return ctx_data_collection_get(C, "editable_bones", list);
 883 }
 884
 885 struct bPoseChannel *CTX_data_active_pose_bone(const bContext *C)
 886 {
 887         return ctx_data_pointer_get(C, "active_pose_bone");
 888 }
 889
 890 int CTX_data_selected_pose_bones(const bContext *C, ListBase *list)
 891 {
 892         return ctx_data_collection_get(C, "selected_pose_bones", list);
 893 }
 894
 895 int CTX_data_visible_pose_bones(const bContext *C, ListBase *list)
 896 {
 897         return ctx_data_collection_get(C, "visible_pose_bones", list);
 898 }
 899