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