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