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