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