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