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