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