doxygen: blender/blenkernel tagged.
[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 void CTX_wm_manager_set(bContext *C, wmWindowManager *wm)
367 {
368         C->wm.manager= wm;
369         C->wm.window= NULL;
370         C->wm.screen= NULL;
371         C->wm.area= NULL;
372         C->wm.region= NULL;
373 }
374
375 void CTX_wm_window_set(bContext *C, wmWindow *win)
376 {
377         C->wm.window= win;
378         C->wm.screen= (win)? win->screen: NULL;
379         C->data.scene= (C->wm.screen)? C->wm.screen->scene: NULL;
380         C->wm.area= NULL;
381         C->wm.region= NULL;
382 }
383
384 void CTX_wm_screen_set(bContext *C, bScreen *screen)
385 {
386         C->wm.screen= screen;
387         C->data.scene= (C->wm.screen)? C->wm.screen->scene: NULL;
388         C->wm.area= NULL;
389         C->wm.region= NULL;
390 }
391
392 void CTX_wm_area_set(bContext *C, ScrArea *area)
393 {
394         C->wm.area= area;
395         C->wm.region= NULL;
396 }
397
398 void CTX_wm_region_set(bContext *C, ARegion *region)
399 {
400         C->wm.region= region;
401 }
402
403 void CTX_wm_menu_set(bContext *C, ARegion *menu)
404 {
405         C->wm.menu= menu;
406 }
407
408 void CTX_wm_operator_poll_msg_set(bContext *C, const char *msg)
409 {
410         C->wm.operator_poll_msg= msg;
411 }
412
413 const char *CTX_wm_operator_poll_msg_get(bContext *C)
414 {
415         return C->wm.operator_poll_msg;
416 }
417
418 /* data context utility functions */
419
420 struct bContextDataResult {
421         PointerRNA ptr;
422         ListBase list;
423         const char **dir;
424         short type; /* 0: normal, 1: seq */
425 };
426
427 static int ctx_data_get(bContext *C, const char *member, bContextDataResult *result)
428 {
429         int done= 0, recursion= C->data.recursion;
430         int ret= 0;
431
432         memset(result, 0, sizeof(bContextDataResult));
433 #ifdef WITH_PYTHON
434         if(CTX_py_dict_get(C)) {
435                 return BPY_context_member_get(C, member, result);
436 //              if (BPY_context_member_get(C, member, result))
437 //                      return 1;
438         }
439 #endif
440         /* we check recursion to ensure that we do not get infinite
441          * loops requesting data from ourselfs in a context callback */
442
443         /* Ok, this looks evil...
444          * if(ret) done= -(-ret | -done);
445          *
446          * Values in order of importance
447          * (0, -1, 1) - Where 1 is highest priority
448          * */
449         if(done!=1 && recursion < 1 && C->wm.store) {
450                 bContextStoreEntry *entry;
451
452                 C->data.recursion= 1;
453
454                 for(entry=C->wm.store->entries.first; entry; entry=entry->next) {
455                         if(strcmp(entry->name, member) == 0) {
456                                 result->ptr= entry->ptr;
457                                 done= 1;
458                         }
459                 }
460         }
461         if(done!=1 && recursion < 2 && C->wm.region) {
462                 C->data.recursion= 2;
463                 if(C->wm.region->type && C->wm.region->type->context) {
464                         ret = C->wm.region->type->context(C, member, result);
465                         if(ret) done= -(-ret | -done);
466
467                 }
468         }
469         if(done!=1 && recursion < 3 && C->wm.area) {
470                 C->data.recursion= 3;
471                 if(C->wm.area->type && C->wm.area->type->context) {
472                         ret = C->wm.area->type->context(C, member, result);
473                         if(ret) done= -(-ret | -done);
474                 }
475         }
476         if(done!=1 && recursion < 4 && C->wm.screen) {
477                 bContextDataCallback cb= C->wm.screen->context;
478                 C->data.recursion= 4;
479                 if(cb) {
480                         ret = cb(C, member, result);
481                         if(ret) done= -(-ret | -done);
482                 }
483         }
484
485         C->data.recursion= recursion;
486
487         return done;
488 }
489
490 static void *ctx_data_pointer_get(const bContext *C, const char *member)
491 {
492         bContextDataResult result;
493
494         if(C && ctx_data_get((bContext*)C, member, &result)==1)
495                 return result.ptr.data;
496
497         return NULL;
498 }
499
500 static int ctx_data_pointer_verify(const bContext *C, const char *member, void **pointer)
501 {
502         bContextDataResult result;
503
504         /* if context is NULL, pointer must be NULL too and that is a valid return */
505         if (C == NULL) {
506                 *pointer= NULL;
507                 return 1;
508         }
509         else if(ctx_data_get((bContext*)C, member, &result)==1) {
510                 *pointer= result.ptr.data;
511                 return 1;
512         }
513         else {
514                 *pointer= NULL;
515                 return 0;
516         }
517 }
518
519 static int ctx_data_collection_get(const bContext *C, const char *member, ListBase *list)
520 {
521         bContextDataResult result;
522
523         if(ctx_data_get((bContext*)C, member, &result)==1) {
524                 *list= result.list;
525                 return 1;
526         }
527
528         list->first= NULL;
529         list->last= NULL;
530
531         return 0;
532 }
533
534 PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
535 {
536         bContextDataResult result;
537
538         if(ctx_data_get((bContext*)C, member, &result)==1)
539                 return result.ptr;
540         else
541                 return PointerRNA_NULL;
542 }
543
544 PointerRNA CTX_data_pointer_get_type(const bContext *C, const char *member, StructRNA *type)
545 {
546         PointerRNA ptr = CTX_data_pointer_get(C, member);
547
548         if(ptr.data && RNA_struct_is_a(ptr.type, type))
549                 return ptr;
550         
551         return PointerRNA_NULL;
552 }
553
554 ListBase CTX_data_collection_get(const bContext *C, const char *member)
555 {
556         bContextDataResult result;
557
558         if(ctx_data_get((bContext*)C, member, &result)==1) {
559                 return result.list;
560         }
561         else {
562                 ListBase list= {NULL, NULL};
563                 return list;
564         }
565 }
566
567 /* 1:found,  -1:found but not set,  0:not found */
568 int CTX_data_get(const bContext *C, const char *member, PointerRNA *r_ptr, ListBase *r_lb, short *r_type)
569 {
570         bContextDataResult result;
571         int ret= ctx_data_get((bContext*)C, member, &result);
572
573         if(ret==1) {
574                 *r_ptr= result.ptr;
575                 *r_lb= result.list;
576                 *r_type= result.type;
577         }
578         else {
579                 memset(r_ptr, 0, sizeof(*r_ptr));
580                 memset(r_lb, 0, sizeof(*r_lb));
581                 *r_type= 0;
582         }
583
584         return ret;
585 }
586
587 static void data_dir_add(ListBase *lb, const char *member)
588 {
589         LinkData *link;
590         
591         if(strcmp(member, "scene") == 0) /* exception */
592                 return;
593
594         if(BLI_findstring(lb, member, offsetof(LinkData, data)))
595                 return;
596         
597         link= MEM_callocN(sizeof(LinkData), "LinkData");
598         link->data= (void*)member;
599         BLI_addtail(lb, link);
600 }
601
602 ListBase CTX_data_dir_get(const bContext *C)
603 {
604         bContextDataResult result;
605         ListBase lb;
606         int a;
607
608         memset(&lb, 0, sizeof(lb));
609
610         if(C->wm.store) {
611                 bContextStoreEntry *entry;
612
613                 for(entry=C->wm.store->entries.first; entry; entry=entry->next)
614                         data_dir_add(&lb, entry->name);
615         }
616         if(C->wm.region && C->wm.region->type && C->wm.region->type->context) {
617                 memset(&result, 0, sizeof(result));
618                 C->wm.region->type->context(C, "", &result);
619
620                 if(result.dir)
621                         for(a=0; result.dir[a]; a++)
622                                 data_dir_add(&lb, result.dir[a]);
623         }
624         if(C->wm.area && C->wm.area->type && C->wm.area->type->context) {
625                 memset(&result, 0, sizeof(result));
626                 C->wm.area->type->context(C, "", &result);
627
628                 if(result.dir)
629                         for(a=0; result.dir[a]; a++)
630                                 data_dir_add(&lb, result.dir[a]);
631         }
632         if(C->wm.screen && C->wm.screen->context) {
633                 bContextDataCallback cb= C->wm.screen->context;
634                 memset(&result, 0, sizeof(result));
635                 cb(C, "", &result);
636
637                 if(result.dir)
638                         for(a=0; result.dir[a]; a++)
639                                 data_dir_add(&lb, result.dir[a]);
640         }
641
642         return lb;
643 }
644
645 int CTX_data_equals(const char *member, const char *str)
646 {
647         return (strcmp(member, str) == 0);
648 }
649
650 int CTX_data_dir(const char *member)
651 {
652         return (strcmp(member, "") == 0);
653 }
654
655 void CTX_data_id_pointer_set(bContextDataResult *result, ID *id)
656 {
657         RNA_id_pointer_create(id, &result->ptr);
658 }
659
660 void CTX_data_pointer_set(bContextDataResult *result, ID *id, StructRNA *type, void *data)
661 {
662         RNA_pointer_create(id, type, data, &result->ptr);
663 }
664
665 void CTX_data_id_list_add(bContextDataResult *result, ID *id)
666 {
667         CollectionPointerLink *link;
668
669         link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");
670         RNA_id_pointer_create(id, &link->ptr);
671
672         BLI_addtail(&result->list, link);
673 }
674
675 void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void *data)
676 {
677         CollectionPointerLink *link;
678
679         link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");
680         RNA_pointer_create(id, type, data, &link->ptr);
681
682         BLI_addtail(&result->list, link);
683 }
684
685 int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase*))
686 {
687         ListBase list;
688
689         if(func(C, &list)) {
690                 int tot= BLI_countlist(&list);
691                 BLI_freelistN(&list);
692                 return tot;
693         }
694         else
695                 return 0;
696 }
697
698 void CTX_data_dir_set(bContextDataResult *result, const char **dir)
699 {
700         result->dir= dir;
701 }
702
703 void CTX_data_type_set(bContextDataResult *result, short type)
704 {
705         result->type= type;
706 }
707
708 short CTX_data_type_get(bContextDataResult *result)
709 {
710         return result->type;
711 }
712
713 /* data context */
714
715 Main *CTX_data_main(const bContext *C)
716 {
717         Main *bmain;
718
719         if(ctx_data_pointer_verify(C, "blend_data", (void*)&bmain))
720                 return bmain;
721         else
722                 return C->data.main;
723 }
724
725 void CTX_data_main_set(bContext *C, Main *bmain)
726 {
727         C->data.main= bmain;
728 }
729
730 Scene *CTX_data_scene(const bContext *C)
731 {
732         Scene *scene;
733
734         if(ctx_data_pointer_verify(C, "scene", (void*)&scene))
735                 return scene;
736         else
737                 return C->data.scene;
738 }
739
740 int CTX_data_mode_enum(const bContext *C)
741 {
742         Object *obedit= CTX_data_edit_object(C);
743
744         if(obedit) {
745                 switch(obedit->type) {
746                         case OB_MESH:
747                                 return CTX_MODE_EDIT_MESH;
748                         case OB_CURVE:
749                                 return CTX_MODE_EDIT_CURVE;
750                         case OB_SURF:
751                                 return CTX_MODE_EDIT_SURFACE;
752                         case OB_FONT:
753                                 return CTX_MODE_EDIT_TEXT;
754                         case OB_ARMATURE:
755                                 return CTX_MODE_EDIT_ARMATURE;
756                         case OB_MBALL:
757                                 return CTX_MODE_EDIT_METABALL;
758                         case OB_LATTICE:
759                                 return CTX_MODE_EDIT_LATTICE;
760                 }
761         }
762         else {
763                 Object *ob = CTX_data_active_object(C);
764
765                 if(ob) {
766                         if(ob->mode & OB_MODE_POSE) return CTX_MODE_POSE;
767                         else if(ob->mode & OB_MODE_SCULPT)  return CTX_MODE_SCULPT;
768                         else if(ob->mode & OB_MODE_WEIGHT_PAINT) return CTX_MODE_PAINT_WEIGHT;
769                         else if(ob->mode & OB_MODE_VERTEX_PAINT) return CTX_MODE_PAINT_VERTEX;
770                         else if(ob->mode & OB_MODE_TEXTURE_PAINT) return CTX_MODE_PAINT_TEXTURE;
771                         else if(ob->mode & OB_MODE_PARTICLE_EDIT) return CTX_MODE_PARTICLE;
772                 }
773         }
774
775         return CTX_MODE_OBJECT;
776 }
777
778
779 /* would prefer if we can use the enum version below over this one - Campbell */
780 /* must be aligned with above enum  */
781 static const char *data_mode_strings[] = {
782         "mesh_edit",
783         "curve_edit",
784         "surface_edit",
785         "text_edit",
786         "armature_edit",
787         "mball_edit",
788         "lattice_edit",
789         "posemode",
790         "sculpt_mode",
791         "weightpaint",
792         "vertexpaint",
793         "texturepaint",
794         "particlemode",
795         "objectmode",
796         NULL
797 };
798 const char *CTX_data_mode_string(const bContext *C)
799 {
800         return data_mode_strings[CTX_data_mode_enum(C)];
801 }
802
803 void CTX_data_scene_set(bContext *C, Scene *scene)
804 {
805         C->data.scene= scene;
806 }
807
808 ToolSettings *CTX_data_tool_settings(const bContext *C)
809 {
810         Scene *scene = CTX_data_scene(C);
811
812         if(scene)
813                 return scene->toolsettings;
814         else
815                 return NULL;
816 }
817
818 int CTX_data_selected_nodes(const bContext *C, ListBase *list)
819 {
820         return ctx_data_collection_get(C, "selected_nodes", list);
821 }
822
823 int CTX_data_selected_editable_objects(const bContext *C, ListBase *list)
824 {
825         return ctx_data_collection_get(C, "selected_editable_objects", list);
826 }
827
828 int CTX_data_selected_editable_bases(const bContext *C, ListBase *list)
829 {
830         return ctx_data_collection_get(C, "selected_editable_bases", list);
831 }
832
833 int CTX_data_selected_objects(const bContext *C, ListBase *list)
834 {
835         return ctx_data_collection_get(C, "selected_objects", list);
836 }
837
838 int CTX_data_selected_bases(const bContext *C, ListBase *list)
839 {
840         return ctx_data_collection_get(C, "selected_bases", list);
841 }
842
843 int CTX_data_visible_objects(const bContext *C, ListBase *list)
844 {
845         return ctx_data_collection_get(C, "visible_objects", list);
846 }
847
848 int CTX_data_visible_bases(const bContext *C, ListBase *list)
849 {
850         return ctx_data_collection_get(C, "visible_bases", list);
851 }
852
853 int CTX_data_selectable_objects(const bContext *C, ListBase *list)
854 {
855         return ctx_data_collection_get(C, "selectable_objects", list);
856 }
857
858 int CTX_data_selectable_bases(const bContext *C, ListBase *list)
859 {
860         return ctx_data_collection_get(C, "selectable_bases", list);
861 }
862
863 struct Object *CTX_data_active_object(const bContext *C)
864 {
865         return ctx_data_pointer_get(C, "active_object");
866 }
867
868 struct Base *CTX_data_active_base(const bContext *C)
869 {
870         return ctx_data_pointer_get(C, "active_base");
871 }
872
873 struct Object *CTX_data_edit_object(const bContext *C)
874 {
875         return ctx_data_pointer_get(C, "edit_object");
876 }
877
878 struct Image *CTX_data_edit_image(const bContext *C)
879 {
880         return ctx_data_pointer_get(C, "edit_image");
881 }
882
883 struct Text *CTX_data_edit_text(const bContext *C)
884 {
885         return ctx_data_pointer_get(C, "edit_text");
886 }
887
888 struct EditBone *CTX_data_active_bone(const bContext *C)
889 {
890         return ctx_data_pointer_get(C, "active_bone");
891 }
892
893 int CTX_data_selected_bones(const bContext *C, ListBase *list)
894 {
895         return ctx_data_collection_get(C, "selected_bones", list);
896 }
897
898 int CTX_data_selected_editable_bones(const bContext *C, ListBase *list)
899 {
900         return ctx_data_collection_get(C, "selected_editable_bones", list);
901 }
902
903 int CTX_data_visible_bones(const bContext *C, ListBase *list)
904 {
905         return ctx_data_collection_get(C, "visible_bones", list);
906 }
907
908 int CTX_data_editable_bones(const bContext *C, ListBase *list)
909 {
910         return ctx_data_collection_get(C, "editable_bones", list);
911 }
912
913 struct bPoseChannel *CTX_data_active_pose_bone(const bContext *C)
914 {
915         return ctx_data_pointer_get(C, "active_pose_bone");
916 }
917
918 int CTX_data_selected_pose_bones(const bContext *C, ListBase *list)
919 {
920         return ctx_data_collection_get(C, "selected_pose_bones", list);
921 }
922
923 int CTX_data_visible_pose_bones(const bContext *C, ListBase *list)
924 {
925         return ctx_data_collection_get(C, "visible_pose_bones", list);
926 }
927