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