Pass EvaluationContext argument everywhere
[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  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/blenkernel/intern/context.c
24  *  \ingroup bke
25  */
26
27 #include <string.h>
28 #include <stdlib.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 #include "DNA_linestyle_types.h"
40 #include "DNA_gpencil_types.h"
41 #include "DNA_workspace_types.h"
42
43 #include "DEG_depsgraph.h"
44
45 #include "BLI_listbase.h"
46 #include "BLI_string.h"
47 #include "BLI_threads.h"
48 #include "BLI_utildefines.h"
49
50 #include "BLT_translation.h"
51
52 #include "BKE_context.h"
53 #include "BKE_layer.h"
54 #include "BKE_main.h"
55 #include "BKE_scene.h"
56 #include "BKE_screen.h"
57 #include "BKE_sound.h"
58 #include "BKE_workspace.h"
59
60 #include "RNA_access.h"
61
62 #ifdef WITH_PYTHON
63 #  include "BPY_extern.h"
64 #endif
65
66 /* struct */
67
68 struct bContext {
69         int thread;
70
71         /* windowmanager context */
72         struct {
73                 struct wmWindowManager *manager;
74                 struct wmWindow *window;
75                 struct WorkSpace *workspace;
76                 struct bScreen *screen;
77                 struct ScrArea *area;
78                 struct ARegion *region;
79                 struct ARegion *menu;
80                 struct bContextStore *store;
81                 const char *operator_poll_msg; /* reason for poll failing */
82         } wm;
83         
84         /* data context */
85         struct {
86                 struct Main *main;
87                 struct Scene *scene;
88
89                 int recursion;
90                 int py_init; /* true if python is initialized */
91                 void *py_context;
92         } data;
93         
94         /* data evaluation */
95 #if 0
96         struct {
97                 int render;
98         } eval;
99 #endif
100 };
101
102 /* context */
103
104 bContext *CTX_create(void)
105 {
106         bContext *C;
107         
108         C = MEM_callocN(sizeof(bContext), "bContext");
109
110         return C;
111 }
112
113 bContext *CTX_copy(const bContext *C)
114 {
115         bContext *newC = MEM_dupallocN((void *)C);
116
117         return newC;
118 }
119
120 void CTX_free(bContext *C)
121 {
122         MEM_freeN(C);
123 }
124
125 /* store */
126
127 bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *ptr)
128 {
129         bContextStoreEntry *entry;
130         bContextStore *ctx, *lastctx;
131
132         /* ensure we have a context to put the entry in, if it was already used
133          * we have to copy the context to ensure */
134         ctx = contexts->last;
135
136         if (!ctx || ctx->used) {
137                 if (ctx) {
138                         lastctx = ctx;
139                         ctx = MEM_dupallocN(lastctx);
140                         BLI_duplicatelist(&ctx->entries, &lastctx->entries);
141                 }
142                 else
143                         ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
144
145                 BLI_addtail(contexts, ctx);
146         }
147
148         entry = MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry");
149         BLI_strncpy(entry->name, name, sizeof(entry->name));
150         entry->ptr = *ptr;
151
152         BLI_addtail(&ctx->entries, entry);
153
154         return ctx;
155 }
156
157 bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context)
158 {
159         bContextStoreEntry *entry, *tentry;
160         bContextStore *ctx, *lastctx;
161
162         /* ensure we have a context to put the entries in, if it was already used
163          * we have to copy the context to ensure */
164         ctx = contexts->last;
165
166         if (!ctx || ctx->used) {
167                 if (ctx) {
168                         lastctx = ctx;
169                         ctx = MEM_dupallocN(lastctx);
170                         BLI_duplicatelist(&ctx->entries, &lastctx->entries);
171                 }
172                 else
173                         ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
174
175                 BLI_addtail(contexts, ctx);
176         }
177
178         for (tentry = context->entries.first; tentry; tentry = tentry->next) {
179                 entry = MEM_dupallocN(tentry);
180                 BLI_addtail(&ctx->entries, entry);
181         }
182
183         return ctx;
184 }
185
186 void CTX_store_set(bContext *C, bContextStore *store)
187 {
188         C->wm.store = store;
189 }
190
191 bContextStore *CTX_store_copy(bContextStore *store)
192 {
193         bContextStore *ctx;
194
195         ctx = MEM_dupallocN(store);
196         BLI_duplicatelist(&ctx->entries, &store->entries);
197
198         return ctx;
199 }
200
201 void CTX_store_free(bContextStore *store)
202 {
203         BLI_freelistN(&store->entries);
204         MEM_freeN(store);
205 }
206
207 void CTX_store_free_list(ListBase *contexts)
208 {
209         bContextStore *ctx;
210
211         while ((ctx = BLI_pophead(contexts))) {
212                 CTX_store_free(ctx);
213         }
214 }
215
216 /* is python initialied? */
217
218 int CTX_py_init_get(bContext *C)
219 {
220         return C->data.py_init;
221 }
222 void CTX_py_init_set(bContext *C, int value)
223 {
224         C->data.py_init = value;
225 }
226
227 void *CTX_py_dict_get(const bContext *C)
228 {
229         return C->data.py_context;
230 }
231 void CTX_py_dict_set(bContext *C, void *value)
232 {
233         C->data.py_context = value;
234 }
235
236 /* data context utility functions */
237
238 struct bContextDataResult {
239         PointerRNA ptr;
240         ListBase list;
241         const char **dir;
242         short type; /* 0: normal, 1: seq */
243 };
244
245 static void *ctx_wm_python_context_get(
246         const bContext *C,
247         const char *member, const StructRNA *member_type,
248         void *fall_through)
249 {
250 #ifdef WITH_PYTHON
251         if (UNLIKELY(C && CTX_py_dict_get(C))) {
252                 bContextDataResult result;
253                 memset(&result, 0, sizeof(bContextDataResult));
254                 BPY_context_member_get((bContext *)C, member, &result);
255
256                 if (result.ptr.data) {
257                         if (RNA_struct_is_a(result.ptr.type, member_type)) {
258                                 return result.ptr.data;
259                         }
260                         else {
261                                 printf("PyContext '%s' is a '%s', expected a '%s'\n",
262                                        member,
263                                        RNA_struct_identifier(result.ptr.type),
264                                        RNA_struct_identifier(member_type));
265                         }
266                 }
267         }
268 #else
269         UNUSED_VARS(C, member, member_type);
270 #endif
271
272         /* don't allow UI context access from non-main threads */
273         if (!BLI_thread_is_main())
274                 return NULL;
275
276         return fall_through;
277 }
278
279 static int ctx_data_get(bContext *C, const char *member, bContextDataResult *result)
280 {
281         bScreen *sc;
282         ScrArea *sa;
283         ARegion *ar;
284         int done = 0, recursion = C->data.recursion;
285         int ret = 0;
286
287         memset(result, 0, sizeof(bContextDataResult));
288 #ifdef WITH_PYTHON
289         if (CTX_py_dict_get(C)) {
290                 if (BPY_context_member_get(C, member, result)) {
291                         return 1;
292                 }
293         }
294 #endif
295
296         /* don't allow UI context access from non-main threads */
297         if (!BLI_thread_is_main())
298                 return done;
299
300         /* we check recursion to ensure that we do not get infinite
301          * loops requesting data from ourselves in a context callback */
302
303         /* Ok, this looks evil...
304          * if (ret) done = -(-ret | -done);
305          *
306          * Values in order of importance
307          * (0, -1, 1) - Where 1 is highest priority
308          * */
309         if (done != 1 && recursion < 1 && C->wm.store) {
310                 bContextStoreEntry *entry;
311
312                 C->data.recursion = 1;
313
314                 entry = BLI_rfindstring(&C->wm.store->entries, member, offsetof(bContextStoreEntry, name));
315                 if (entry) {
316                         result->ptr = entry->ptr;
317                         done = 1;
318                 }
319         }
320         if (done != 1 && recursion < 2 && (ar = CTX_wm_region(C))) {
321                 C->data.recursion = 2;
322                 if (ar->type && ar->type->context) {
323                         ret = ar->type->context(C, member, result);
324                         if (ret) done = -(-ret | -done);
325
326                 }
327         }
328         if (done != 1 && recursion < 3 && (sa = CTX_wm_area(C))) {
329                 C->data.recursion = 3;
330                 if (sa->type && sa->type->context) {
331                         ret = sa->type->context(C, member, result);
332                         if (ret) done = -(-ret | -done);
333                 }
334         }
335         if (done != 1 && recursion < 4 && (sc = CTX_wm_screen(C))) {
336                 bContextDataCallback cb = sc->context;
337                 C->data.recursion = 4;
338                 if (cb) {
339                         ret = cb(C, member, result);
340                         if (ret) done = -(-ret | -done);
341                 }
342         }
343
344         C->data.recursion = recursion;
345
346         return done;
347 }
348
349 static void *ctx_data_pointer_get(const bContext *C, const char *member)
350 {
351         bContextDataResult result;
352
353         if (C && ctx_data_get((bContext *)C, member, &result) == 1) {
354                 BLI_assert(result.type == CTX_DATA_TYPE_POINTER);
355                 return result.ptr.data;
356         }
357         else {
358                 return NULL;
359         }
360 }
361
362 static int ctx_data_pointer_verify(const bContext *C, const char *member, void **pointer)
363 {
364         bContextDataResult result;
365
366         /* if context is NULL, pointer must be NULL too and that is a valid return */
367         if (C == NULL) {
368                 *pointer = NULL;
369                 return 1;
370         }
371         else if (ctx_data_get((bContext *)C, member, &result) == 1) {
372                 BLI_assert(result.type == CTX_DATA_TYPE_POINTER);
373                 *pointer = result.ptr.data;
374                 return 1;
375         }
376         else {
377                 *pointer = NULL;
378                 return 0;
379         }
380 }
381
382 static int ctx_data_collection_get(const bContext *C, const char *member, ListBase *list)
383 {
384         bContextDataResult result;
385
386         if (ctx_data_get((bContext *)C, member, &result) == 1) {
387                 BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);
388                 *list = result.list;
389                 return 1;
390         }
391
392         BLI_listbase_clear(list);
393
394         return 0;
395 }
396
397 PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
398 {
399         bContextDataResult result;
400
401         if (ctx_data_get((bContext *)C, member, &result) == 1) {
402                 BLI_assert(result.type == CTX_DATA_TYPE_POINTER);
403                 return result.ptr;
404         }
405         else {
406                 return PointerRNA_NULL;
407         }
408 }
409
410 PointerRNA CTX_data_pointer_get_type(const bContext *C, const char *member, StructRNA *type)
411 {
412         PointerRNA ptr = CTX_data_pointer_get(C, member);
413
414         if (ptr.data) {
415                 if (RNA_struct_is_a(ptr.type, type)) {
416                         return ptr;
417                 }
418                 else {
419                         printf("%s: warning, member '%s' is '%s', not '%s'\n",
420                                __func__, member, RNA_struct_identifier(ptr.type), RNA_struct_identifier(type));
421                 }
422         }
423         
424         return PointerRNA_NULL;
425 }
426
427 ListBase CTX_data_collection_get(const bContext *C, const char *member)
428 {
429         bContextDataResult result;
430
431         if (ctx_data_get((bContext *)C, member, &result) == 1) {
432                 BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);
433                 return result.list;
434         }
435         else {
436                 ListBase list = {NULL, NULL};
437                 return list;
438         }
439 }
440
441 /* 1:found,  -1:found but not set,  0:not found */
442 int CTX_data_get(const bContext *C, const char *member, PointerRNA *r_ptr, ListBase *r_lb, short *r_type)
443 {
444         bContextDataResult result;
445         int ret = ctx_data_get((bContext *)C, member, &result);
446
447         if (ret == 1) {
448                 *r_ptr = result.ptr;
449                 *r_lb = result.list;
450                 *r_type = result.type;
451         }
452         else {
453                 memset(r_ptr, 0, sizeof(*r_ptr));
454                 memset(r_lb, 0, sizeof(*r_lb));
455                 *r_type = 0;
456         }
457
458         return ret;
459 }
460
461 static void data_dir_add(ListBase *lb, const char *member, const bool use_all)
462 {
463         LinkData *link;
464         
465         if ((use_all == false) && STREQ(member, "scene")) /* exception */
466                 return;
467
468         if (BLI_findstring(lb, member, offsetof(LinkData, data)))
469                 return;
470         
471         link = MEM_callocN(sizeof(LinkData), "LinkData");
472         link->data = (void *)member;
473         BLI_addtail(lb, link);
474 }
475
476 /**
477  * \param C Context
478  * \param use_store Use 'C->wm.store'
479  * \param use_rna Use Include the properties from 'RNA_Context'
480  * \param use_all Don't skip values (currently only "scene")
481  */
482 ListBase CTX_data_dir_get_ex(const bContext *C, const bool use_store, const bool use_rna, const bool use_all)
483 {
484         bContextDataResult result;
485         ListBase lb;
486         bScreen *sc;
487         ScrArea *sa;
488         ARegion *ar;
489         int a;
490
491         memset(&lb, 0, sizeof(lb));
492
493         if (use_rna) {
494                 char name[256], *nameptr;
495                 int namelen;
496
497                 PropertyRNA *iterprop;
498                 PointerRNA ctx_ptr;
499                 RNA_pointer_create(NULL, &RNA_Context, (void *)C, &ctx_ptr);
500
501                 iterprop = RNA_struct_iterator_property(ctx_ptr.type);
502
503                 RNA_PROP_BEGIN (&ctx_ptr, itemptr, iterprop)
504                 {
505                         nameptr = RNA_struct_name_get_alloc(&itemptr, name, sizeof(name), &namelen);
506                         data_dir_add(&lb, name, use_all);
507                         if (nameptr) {
508                                 if (name != nameptr) {
509                                         MEM_freeN(nameptr);
510                                 }
511                         }
512                 }
513                 RNA_PROP_END;
514         }
515         if (use_store && C->wm.store) {
516                 bContextStoreEntry *entry;
517
518                 for (entry = C->wm.store->entries.first; entry; entry = entry->next)
519                         data_dir_add(&lb, entry->name, use_all);
520         }
521         if ((ar = CTX_wm_region(C)) && ar->type && ar->type->context) {
522                 memset(&result, 0, sizeof(result));
523                 ar->type->context(C, "", &result);
524
525                 if (result.dir)
526                         for (a = 0; result.dir[a]; a++)
527                                 data_dir_add(&lb, result.dir[a], use_all);
528         }
529         if ((sa = CTX_wm_area(C)) && sa->type && sa->type->context) {
530                 memset(&result, 0, sizeof(result));
531                 sa->type->context(C, "", &result);
532
533                 if (result.dir)
534                         for (a = 0; result.dir[a]; a++)
535                                 data_dir_add(&lb, result.dir[a], use_all);
536         }
537         if ((sc = CTX_wm_screen(C)) && sc->context) {
538                 bContextDataCallback cb = sc->context;
539                 memset(&result, 0, sizeof(result));
540                 cb(C, "", &result);
541
542                 if (result.dir)
543                         for (a = 0; result.dir[a]; a++)
544                                 data_dir_add(&lb, result.dir[a], use_all);
545         }
546
547         return lb;
548 }
549
550 ListBase CTX_data_dir_get(const bContext *C)
551 {
552         return CTX_data_dir_get_ex(C, true, false, false);
553 }
554
555 bool CTX_data_equals(const char *member, const char *str)
556 {
557         return (STREQ(member, str));
558 }
559
560 bool CTX_data_dir(const char *member)
561 {
562         return member[0] == '\0';
563 }
564
565 void CTX_data_id_pointer_set(bContextDataResult *result, ID *id)
566 {
567         RNA_id_pointer_create(id, &result->ptr);
568 }
569
570 void CTX_data_pointer_set(bContextDataResult *result, ID *id, StructRNA *type, void *data)
571 {
572         RNA_pointer_create(id, type, data, &result->ptr);
573 }
574
575 void CTX_data_id_list_add(bContextDataResult *result, ID *id)
576 {
577         CollectionPointerLink *link;
578
579         link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");
580         RNA_id_pointer_create(id, &link->ptr);
581
582         BLI_addtail(&result->list, link);
583 }
584
585 void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void *data)
586 {
587         CollectionPointerLink *link;
588
589         link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");
590         RNA_pointer_create(id, type, data, &link->ptr);
591
592         BLI_addtail(&result->list, link);
593 }
594
595 int ctx_data_list_count(const bContext *C, int (*func)(const bContext *, ListBase *))
596 {
597         ListBase list;
598
599         if (func(C, &list)) {
600                 int tot = BLI_listbase_count(&list);
601                 BLI_freelistN(&list);
602                 return tot;
603         }
604         else
605                 return 0;
606 }
607
608 void CTX_data_dir_set(bContextDataResult *result, const char **dir)
609 {
610         result->dir = dir;
611 }
612
613 void CTX_data_type_set(bContextDataResult *result, short type)
614 {
615         result->type = type;
616 }
617
618 short CTX_data_type_get(bContextDataResult *result)
619 {
620         return result->type;
621 }
622
623
624
625 /* window manager context */
626
627 wmWindowManager *CTX_wm_manager(const bContext *C)
628 {
629         return C->wm.manager;
630 }
631
632 wmWindow *CTX_wm_window(const bContext *C)
633 {
634         return ctx_wm_python_context_get(C, "window", &RNA_Window, C->wm.window);
635 }
636
637 WorkSpace *CTX_wm_workspace(const bContext *C)
638 {
639         return ctx_wm_python_context_get(C, "workspace", &RNA_WorkSpace, C->wm.workspace);
640 }
641
642 bScreen *CTX_wm_screen(const bContext *C)
643 {
644         return ctx_wm_python_context_get(C, "screen", &RNA_Screen, C->wm.screen);
645 }
646
647 ScrArea *CTX_wm_area(const bContext *C)
648 {
649         return ctx_wm_python_context_get(C, "area", &RNA_Area, C->wm.area);
650 }
651
652 SpaceLink *CTX_wm_space_data(const bContext *C)
653 {
654         ScrArea *sa = CTX_wm_area(C);
655         return (sa) ? sa->spacedata.first : NULL;
656 }
657
658 ARegion *CTX_wm_region(const bContext *C)
659 {
660         return ctx_wm_python_context_get(C, "region", &RNA_Region, C->wm.region);
661 }
662
663 void *CTX_wm_region_data(const bContext *C)
664 {
665         ARegion *ar = CTX_wm_region(C);
666         return (ar) ? ar->regiondata : NULL;
667 }
668
669 struct ARegion *CTX_wm_menu(const bContext *C)
670 {
671         return C->wm.menu;
672 }
673
674 struct ReportList *CTX_wm_reports(const bContext *C)
675 {
676         if (C->wm.manager)
677                 return &(C->wm.manager->reports);
678
679         return NULL;
680 }
681
682 View3D *CTX_wm_view3d(const bContext *C)
683 {
684         ScrArea *sa = CTX_wm_area(C);
685         if (sa && sa->spacetype == SPACE_VIEW3D)
686                 return sa->spacedata.first;
687         return NULL;
688 }
689
690 RegionView3D *CTX_wm_region_view3d(const bContext *C)
691 {
692         ScrArea *sa = CTX_wm_area(C);
693         ARegion *ar = CTX_wm_region(C);
694
695         if (sa && sa->spacetype == SPACE_VIEW3D)
696                 if (ar)
697                         return ar->regiondata;
698         return NULL;
699 }
700
701 struct SpaceText *CTX_wm_space_text(const bContext *C)
702 {
703         ScrArea *sa = CTX_wm_area(C);
704         if (sa && sa->spacetype == SPACE_TEXT)
705                 return sa->spacedata.first;
706         return NULL;
707 }
708
709 struct SpaceConsole *CTX_wm_space_console(const bContext *C)
710 {
711         ScrArea *sa = CTX_wm_area(C);
712         if (sa && sa->spacetype == SPACE_CONSOLE)
713                 return sa->spacedata.first;
714         return NULL;
715 }
716
717 struct SpaceImage *CTX_wm_space_image(const bContext *C)
718 {
719         ScrArea *sa = CTX_wm_area(C);
720         if (sa && sa->spacetype == SPACE_IMAGE)
721                 return sa->spacedata.first;
722         return NULL;
723 }
724
725 struct SpaceButs *CTX_wm_space_buts(const bContext *C)
726 {
727         ScrArea *sa = CTX_wm_area(C);
728         if (sa && sa->spacetype == SPACE_BUTS)
729                 return sa->spacedata.first;
730         return NULL;
731 }
732
733 struct SpaceFile *CTX_wm_space_file(const bContext *C)
734 {
735         ScrArea *sa = CTX_wm_area(C);
736         if (sa && sa->spacetype == SPACE_FILE)
737                 return sa->spacedata.first;
738         return NULL;
739 }
740
741 struct SpaceSeq *CTX_wm_space_seq(const bContext *C)
742 {
743         ScrArea *sa = CTX_wm_area(C);
744         if (sa && sa->spacetype == SPACE_SEQ)
745                 return sa->spacedata.first;
746         return NULL;
747 }
748
749 struct SpaceOops *CTX_wm_space_outliner(const bContext *C)
750 {
751         ScrArea *sa = CTX_wm_area(C);
752         if (sa && sa->spacetype == SPACE_OUTLINER)
753                 return sa->spacedata.first;
754         return NULL;
755 }
756
757 struct SpaceNla *CTX_wm_space_nla(const bContext *C)
758 {
759         ScrArea *sa = CTX_wm_area(C);
760         if (sa && sa->spacetype == SPACE_NLA)
761                 return sa->spacedata.first;
762         return NULL;
763 }
764
765 struct SpaceTime *CTX_wm_space_time(const bContext *C)
766 {
767         ScrArea *sa = CTX_wm_area(C);
768         if (sa && sa->spacetype == SPACE_TIME)
769                 return sa->spacedata.first;
770         return NULL;
771 }
772
773 struct SpaceNode *CTX_wm_space_node(const bContext *C)
774 {
775         ScrArea *sa = CTX_wm_area(C);
776         if (sa && sa->spacetype == SPACE_NODE)
777                 return sa->spacedata.first;
778         return NULL;
779 }
780
781 struct SpaceLogic *CTX_wm_space_logic(const bContext *C)
782 {
783         ScrArea *sa = CTX_wm_area(C);
784         if (sa && sa->spacetype == SPACE_LOGIC)
785                 return sa->spacedata.first;
786         return NULL;
787 }
788
789 struct SpaceIpo *CTX_wm_space_graph(const bContext *C)
790 {
791         ScrArea *sa = CTX_wm_area(C);
792         if (sa && sa->spacetype == SPACE_IPO)
793                 return sa->spacedata.first;
794         return NULL;
795 }
796
797 struct SpaceAction *CTX_wm_space_action(const bContext *C)
798 {
799         ScrArea *sa = CTX_wm_area(C);
800         if (sa && sa->spacetype == SPACE_ACTION)
801                 return sa->spacedata.first;
802         return NULL;
803 }
804
805 struct SpaceInfo *CTX_wm_space_info(const bContext *C)
806 {
807         ScrArea *sa = CTX_wm_area(C);
808         if (sa && sa->spacetype == SPACE_INFO)
809                 return sa->spacedata.first;
810         return NULL;
811 }
812
813 struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C)
814 {
815         ScrArea *sa = CTX_wm_area(C);
816         if (sa && sa->spacetype == SPACE_USERPREF)
817                 return sa->spacedata.first;
818         return NULL;
819 }
820
821 struct SpaceClip *CTX_wm_space_clip(const bContext *C)
822 {
823         ScrArea *sa = CTX_wm_area(C);
824         if (sa && sa->spacetype == SPACE_CLIP)
825                 return sa->spacedata.first;
826         return NULL;
827 }
828
829 void CTX_wm_manager_set(bContext *C, wmWindowManager *wm)
830 {
831         C->wm.manager = wm;
832         C->wm.window = NULL;
833         C->wm.screen = NULL;
834         C->wm.area = NULL;
835         C->wm.region = NULL;
836 }
837
838 void CTX_wm_window_set(bContext *C, wmWindow *win)
839 {
840         C->wm.window = win;
841         if (win) {
842                 C->data.scene = win->scene;
843         }
844         C->wm.workspace = (win) ? BKE_workspace_active_get(win->workspace_hook) : NULL;
845         C->wm.screen = (win) ? BKE_workspace_active_screen_get(win->workspace_hook) : NULL;
846         C->wm.area = NULL;
847         C->wm.region = NULL;
848 }
849
850 void CTX_wm_screen_set(bContext *C, bScreen *screen)
851 {
852         C->wm.screen = screen;
853         C->wm.area = NULL;
854         C->wm.region = NULL;
855 }
856
857 void CTX_wm_area_set(bContext *C, ScrArea *area)
858 {
859         C->wm.area = area;
860         C->wm.region = NULL;
861 }
862
863 void CTX_wm_region_set(bContext *C, ARegion *region)
864 {
865         C->wm.region = region;
866 }
867
868 void CTX_wm_menu_set(bContext *C, ARegion *menu)
869 {
870         C->wm.menu = menu;
871 }
872
873 void CTX_wm_operator_poll_msg_set(bContext *C, const char *msg)
874 {
875         C->wm.operator_poll_msg = msg;
876 }
877
878 const char *CTX_wm_operator_poll_msg_get(bContext *C)
879 {
880         return IFACE_(C->wm.operator_poll_msg);
881 }
882
883 /* data context */
884
885 Main *CTX_data_main(const bContext *C)
886 {
887         Main *bmain;
888
889         if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain))
890                 return bmain;
891         else
892                 return C->data.main;
893 }
894
895 void CTX_data_main_set(bContext *C, Main *bmain)
896 {
897         C->data.main = bmain;
898         BKE_sound_init_main(bmain);
899 }
900
901 Scene *CTX_data_scene(const bContext *C)
902 {
903         Scene *scene;
904
905         if (ctx_data_pointer_verify(C, "scene", (void *)&scene))
906                 return scene;
907         else
908                 return C->data.scene;
909 }
910
911 SceneLayer *CTX_data_scene_layer(const bContext *C)
912 {
913         SceneLayer *sl;
914
915         if (ctx_data_pointer_verify(C, "render_layer", (void *)&sl)) {
916                 return sl;
917         }
918         else {
919                 return BKE_scene_layer_from_workspace_get(CTX_wm_workspace(C));
920         }
921 }
922
923 /**
924  * This is tricky. Sometimes the user overrides the render_layer
925  * but not the scene_collection. In this case what to do?
926  *
927  * If the scene_collection is linked to the SceneLayer we use it.
928  * Otherwise we fallback to the active one of the SceneLayer.
929  */
930 LayerCollection *CTX_data_layer_collection(const bContext *C)
931 {
932         SceneLayer *sl = CTX_data_scene_layer(C);
933         LayerCollection *lc;
934
935         if (ctx_data_pointer_verify(C, "layer_collection", (void *)&lc)) {
936                 if (BKE_scene_layer_has_collection(sl, lc->scene_collection)) {
937                         return lc;
938                 }
939         }
940
941         /* fallback */
942         return BKE_layer_collection_get_active(sl);
943 }
944
945 SceneCollection *CTX_data_scene_collection(const bContext *C)
946 {
947         SceneCollection *sc;
948         if (ctx_data_pointer_verify(C, "scene_collection", (void *)&sc)) {
949                 if (BKE_scene_layer_has_collection(CTX_data_scene_layer(C), sc)) {
950                         return sc;
951                 }
952         }
953
954         LayerCollection *lc = CTX_data_layer_collection(C);
955         if (lc) {
956                 return lc->scene_collection;
957         }
958
959         /* fallback */
960         Scene *scene = CTX_data_scene(C);
961         return BKE_collection_master(scene);
962 }
963
964 int CTX_data_mode_enum_ex(const Object *obedit, const Object *ob)
965 {
966         // Object *obedit = CTX_data_edit_object(C);
967         if (obedit) {
968                 switch (obedit->type) {
969                         case OB_MESH:
970                                 return CTX_MODE_EDIT_MESH;
971                         case OB_CURVE:
972                                 return CTX_MODE_EDIT_CURVE;
973                         case OB_SURF:
974                                 return CTX_MODE_EDIT_SURFACE;
975                         case OB_FONT:
976                                 return CTX_MODE_EDIT_TEXT;
977                         case OB_ARMATURE:
978                                 return CTX_MODE_EDIT_ARMATURE;
979                         case OB_MBALL:
980                                 return CTX_MODE_EDIT_METABALL;
981                         case OB_LATTICE:
982                                 return CTX_MODE_EDIT_LATTICE;
983                 }
984         }
985         else {
986                 // Object *ob = CTX_data_active_object(C);
987                 if (ob) {
988                         if (ob->mode & OB_MODE_POSE) return CTX_MODE_POSE;
989                         else if (ob->mode & OB_MODE_SCULPT) return CTX_MODE_SCULPT;
990                         else if (ob->mode & OB_MODE_WEIGHT_PAINT) return CTX_MODE_PAINT_WEIGHT;
991                         else if (ob->mode & OB_MODE_VERTEX_PAINT) return CTX_MODE_PAINT_VERTEX;
992                         else if (ob->mode & OB_MODE_TEXTURE_PAINT) return CTX_MODE_PAINT_TEXTURE;
993                         else if (ob->mode & OB_MODE_PARTICLE_EDIT) return CTX_MODE_PARTICLE;
994                 }
995         }
996
997         return CTX_MODE_OBJECT;
998 }
999
1000 int CTX_data_mode_enum(const bContext *C)
1001 {
1002         Object *obedit = CTX_data_edit_object(C);
1003         Object *obact = obedit ? NULL : CTX_data_active_object(C);
1004         return CTX_data_mode_enum_ex(obedit, obact);
1005 }
1006
1007 /* would prefer if we can use the enum version below over this one - Campbell */
1008 /* must be aligned with above enum  */
1009 static const char *data_mode_strings[] = {
1010         "mesh_edit",
1011         "curve_edit",
1012         "surface_edit",
1013         "text_edit",
1014         "armature_edit",
1015         "mball_edit",
1016         "lattice_edit",
1017         "posemode",
1018         "sculpt_mode",
1019         "weightpaint",
1020         "vertexpaint",
1021         "imagepaint",
1022         "particlemode",
1023         "objectmode",
1024         NULL
1025 };
1026 const char *CTX_data_mode_string(const bContext *C)
1027 {
1028         return data_mode_strings[CTX_data_mode_enum(C)];
1029 }
1030
1031 void CTX_data_scene_set(bContext *C, Scene *scene)
1032 {
1033         C->data.scene = scene;
1034 }
1035
1036 ToolSettings *CTX_data_tool_settings(const bContext *C)
1037 {
1038         Scene *scene = CTX_data_scene(C);
1039
1040         if (scene)
1041                 return scene->toolsettings;
1042         else
1043                 return NULL;
1044 }
1045
1046 int CTX_data_selected_nodes(const bContext *C, ListBase *list)
1047 {
1048         return ctx_data_collection_get(C, "selected_nodes", list);
1049 }
1050
1051 int CTX_data_selected_editable_objects(const bContext *C, ListBase *list)
1052 {
1053         return ctx_data_collection_get(C, "selected_editable_objects", list);
1054 }
1055
1056 int CTX_data_selected_editable_bases(const bContext *C, ListBase *list)
1057 {
1058         return ctx_data_collection_get(C, "selected_editable_bases", list);
1059 }
1060
1061 int CTX_data_editable_objects(const bContext *C, ListBase *list)
1062 {
1063         return ctx_data_collection_get(C, "editable_objects", list);
1064 }
1065
1066 int CTX_data_editable_bases(const bContext *C, ListBase *list)
1067 {
1068         return ctx_data_collection_get(C, "editable_bases", list);
1069 }
1070
1071 int CTX_data_selected_objects(const bContext *C, ListBase *list)
1072 {
1073         return ctx_data_collection_get(C, "selected_objects", list);
1074 }
1075
1076 int CTX_data_selected_bases(const bContext *C, ListBase *list)
1077 {
1078         return ctx_data_collection_get(C, "selected_bases", list);
1079 }
1080
1081 int CTX_data_visible_objects(const bContext *C, ListBase *list)
1082 {
1083         return ctx_data_collection_get(C, "visible_objects", list);
1084 }
1085
1086 int CTX_data_visible_bases(const bContext *C, ListBase *list)
1087 {
1088         return ctx_data_collection_get(C, "visible_bases", list);
1089 }
1090
1091 int CTX_data_selectable_objects(const bContext *C, ListBase *list)
1092 {
1093         return ctx_data_collection_get(C, "selectable_objects", list);
1094 }
1095
1096 int CTX_data_selectable_bases(const bContext *C, ListBase *list)
1097 {
1098         return ctx_data_collection_get(C, "selectable_bases", list);
1099 }
1100
1101 struct Object *CTX_data_active_object(const bContext *C)
1102 {
1103         return ctx_data_pointer_get(C, "active_object");
1104 }
1105
1106 struct Base *CTX_data_active_base(const bContext *C)
1107 {
1108         return ctx_data_pointer_get(C, "active_base");
1109 }
1110
1111 struct Object *CTX_data_edit_object(const bContext *C)
1112 {
1113         return ctx_data_pointer_get(C, "edit_object");
1114 }
1115
1116 struct Image *CTX_data_edit_image(const bContext *C)
1117 {
1118         return ctx_data_pointer_get(C, "edit_image");
1119 }
1120
1121 struct Text *CTX_data_edit_text(const bContext *C)
1122 {
1123         return ctx_data_pointer_get(C, "edit_text");
1124 }
1125
1126 struct MovieClip *CTX_data_edit_movieclip(const bContext *C)
1127 {
1128         return ctx_data_pointer_get(C, "edit_movieclip");
1129 }
1130
1131 struct Mask *CTX_data_edit_mask(const bContext *C)
1132 {
1133         return ctx_data_pointer_get(C, "edit_mask");
1134 }
1135
1136 struct EditBone *CTX_data_active_bone(const bContext *C)
1137 {
1138         return ctx_data_pointer_get(C, "active_bone");
1139 }
1140
1141 struct CacheFile *CTX_data_edit_cachefile(const bContext *C)
1142 {
1143         return ctx_data_pointer_get(C, "edit_cachefile");
1144 }
1145
1146 int CTX_data_selected_bones(const bContext *C, ListBase *list)
1147 {
1148         return ctx_data_collection_get(C, "selected_bones", list);
1149 }
1150
1151 int CTX_data_selected_editable_bones(const bContext *C, ListBase *list)
1152 {
1153         return ctx_data_collection_get(C, "selected_editable_bones", list);
1154 }
1155
1156 int CTX_data_visible_bones(const bContext *C, ListBase *list)
1157 {
1158         return ctx_data_collection_get(C, "visible_bones", list);
1159 }
1160
1161 int CTX_data_editable_bones(const bContext *C, ListBase *list)
1162 {
1163         return ctx_data_collection_get(C, "editable_bones", list);
1164 }
1165
1166 struct bPoseChannel *CTX_data_active_pose_bone(const bContext *C)
1167 {
1168         return ctx_data_pointer_get(C, "active_pose_bone");
1169 }
1170
1171 int CTX_data_selected_pose_bones(const bContext *C, ListBase *list)
1172 {
1173         return ctx_data_collection_get(C, "selected_pose_bones", list);
1174 }
1175
1176 int CTX_data_visible_pose_bones(const bContext *C, ListBase *list)
1177 {
1178         return ctx_data_collection_get(C, "visible_pose_bones", list);
1179 }
1180
1181 bGPdata *CTX_data_gpencil_data(const bContext *C)
1182 {
1183         return ctx_data_pointer_get(C, "gpencil_data");
1184 }
1185
1186 bGPDlayer *CTX_data_active_gpencil_layer(const bContext *C)
1187 {
1188         return ctx_data_pointer_get(C, "active_gpencil_layer");
1189 }
1190
1191 bGPDpalette *CTX_data_active_gpencil_palette(const bContext *C)
1192 {
1193         return ctx_data_pointer_get(C, "active_gpencil_palette");
1194 }
1195
1196 bGPDpalettecolor *CTX_data_active_gpencil_palettecolor(const bContext *C)
1197 {
1198         return ctx_data_pointer_get(C, "active_gpencil_palettecolor");
1199 }
1200
1201 bGPDbrush *CTX_data_active_gpencil_brush(const bContext *C)
1202 {
1203         return ctx_data_pointer_get(C, "active_gpencil_brush");
1204 }
1205
1206 bGPDframe *CTX_data_active_gpencil_frame(const bContext *C)
1207 {
1208         return ctx_data_pointer_get(C, "active_gpencil_frame");
1209 }
1210
1211 int CTX_data_visible_gpencil_layers(const bContext *C, ListBase *list)
1212 {
1213         return ctx_data_collection_get(C, "visible_gpencil_layers", list);
1214 }
1215
1216 int CTX_data_editable_gpencil_layers(const bContext *C, ListBase *list)
1217 {
1218         return ctx_data_collection_get(C, "editable_gpencil_layers", list);
1219 }
1220
1221 int CTX_data_editable_gpencil_strokes(const bContext *C, ListBase *list)
1222 {
1223         return ctx_data_collection_get(C, "editable_gpencil_strokes", list);
1224 }
1225
1226 Depsgraph *CTX_data_depsgraph(const bContext *C)
1227 {
1228         Scene *scene = CTX_data_scene(C);
1229         SceneLayer *scene_layer = CTX_data_scene_layer(C);
1230         return BKE_scene_get_depsgraph(scene, scene_layer);
1231 }
1232
1233 void CTX_data_eval_ctx(const bContext *C, EvaluationContext *eval_ctx)
1234 {
1235         BLI_assert(C);
1236
1237         *eval_ctx = *CTX_data_main(C)->eval_ctx;
1238         eval_ctx->scene_layer = CTX_data_scene_layer(C);
1239 }