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