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