Differential D16806 Diff 58720 source/blender/blenkernel/intern/context.cc

Changeset View

Standalone View

source/blender/blenkernel/intern/context.cc

This file was moved from source/blender/blenkernel/intern/context.c.

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines

/* struct */		/* struct */

struct bContext {		struct bContext {
int thread;		int thread;

/* windowmanager context */		/* windowmanager context */
struct {		struct {
struct wmWindowManager *manager;		wmWindowManager *manager;
struct wmWindow *window;		wmWindow *window;
struct WorkSpace *workspace;		WorkSpace *workspace;
struct bScreen *screen;		bScreen *screen;
struct ScrArea *area;		ScrArea *area;
struct ARegion *region;		ARegion *region;
struct ARegion *menu;		ARegion *menu;
struct wmGizmoGroup *gizmo_group;		wmGizmoGroup *gizmo_group;
struct bContextStore *store;		bContextStore *store;

/* Operator poll. */		/* Operator poll. */
/**		/**
* Store the reason the poll function fails (static string, not allocated).		* Store the reason the poll function fails (static string, not allocated).
* For more advanced formatting use `operator_poll_msg_dyn_params`.		* For more advanced formatting use `operator_poll_msg_dyn_params`.
*/		*/
const char *operator_poll_msg;		const char *operator_poll_msg;
/**		/**
* Store values to dynamically to create the string (called when a tool-tip is shown).		* Store values to dynamically to create the string (called when a tool-tip is shown).
*/		*/
struct bContextPollMsgDyn_Params operator_poll_msg_dyn_params;		struct bContextPollMsgDyn_Params operator_poll_msg_dyn_params;
} wm;		} wm;

/* data context */		/* data context */
struct {		struct {
struct Main *main;		Main *main;
struct Scene *scene;		Scene *scene;

int recursion;		int recursion;
/** True if python is initialized. */		/** True if python is initialized. */
bool py_init;		bool py_init;
void *py_context;		void *py_context;
/**		/**
* If we need to remove members, do so in a copy		* If we need to remove members, do so in a copy
* (keep this to check if the copy needs freeing).		* (keep this to check if the copy needs freeing).
*/		*/
void *py_context_orig;		void *py_context_orig;
} data;		} data;
};		};

/* context */		/* context */

bContext *CTX_create(void)		bContext *CTX_create(void)
{		{
bContext *C = MEM_callocN(sizeof(bContext), "bContext");		bContext *C = MEM_cnew<bContext>(__func__);

return C;		return C;
}		}

bContext CTX_copy(const bContext C)		bContext CTX_copy(const bContext C)
{		{
bContext newC = MEM_dupallocN((void )C);		bContext *newC = MEM_new<bContext>(__func__);
		newC = C;

memset(&newC->wm.operator_poll_msg_dyn_params, 0, sizeof(newC->wm.operator_poll_msg_dyn_params));		memset(&newC->wm.operator_poll_msg_dyn_params, 0, sizeof(newC->wm.operator_poll_msg_dyn_params));

return newC;		return newC;
}		}

void CTX_free(bContext *C)		void CTX_free(bContext *C)
{		{
/* This may contain a dynamically allocated message, free. */		/* This may contain a dynamically allocated message, free. */
CTX_wm_operator_poll_msg_clear(C);		CTX_wm_operator_poll_msg_clear(C);

MEM_freeN(C);		MEM_freeN(C);
}		}

/* store */		/* store */

bContextStore CTX_store_add(ListBase contexts, const char name, const PointerRNA ptr)		bContextStore CTX_store_add(ListBase contexts, const char name, const PointerRNA ptr)
{		{
/* ensure we have a context to put the entry in, if it was already used		/* ensure we have a context to put the entry in, if it was already used
* we have to copy the context to ensure */		* we have to copy the context to ensure */
bContextStore *ctx = contexts->last;		bContextStore ctx = static_cast<bContextStore >(contexts->last);

if (!ctx \|\| ctx->used) {		if (!ctx \|\| ctx->used) {
if (ctx) {		if (ctx) {
bContextStore *lastctx = ctx;		bContextStore *lastctx = ctx;
ctx = MEM_dupallocN(lastctx);		ctx = MEM_new<bContextStore>(__func__);
		ctx = lastctx;
BLI_duplicatelist(&ctx->entries, &lastctx->entries);		BLI_duplicatelist(&ctx->entries, &lastctx->entries);
}		}
else {		else {
ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");		ctx = MEM_cnew<bContextStore>(__func__);
}		}

BLI_addtail(contexts, ctx);		BLI_addtail(contexts, ctx);
}		}

bContextStoreEntry *entry = MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry");		bContextStoreEntry *entry = MEM_cnew<bContextStoreEntry>(__func__);
BLI_strncpy(entry->name, name, sizeof(entry->name));		BLI_strncpy(entry->name, name, sizeof(entry->name));
entry->ptr = *ptr;		entry->ptr = *ptr;

BLI_addtail(&ctx->entries, entry);		BLI_addtail(&ctx->entries, entry);

return ctx;		return ctx;
}		}

bContextStore CTX_store_add_all(ListBase contexts, bContextStore *context)		bContextStore CTX_store_add_all(ListBase contexts, bContextStore *context)
{		{
/* ensure we have a context to put the entries in, if it was already used		/* ensure we have a context to put the entries in, if it was already used
* we have to copy the context to ensure */		* we have to copy the context to ensure */
bContextStore *ctx = contexts->last;		bContextStore ctx = static_cast<bContextStore >(contexts->last);

if (!ctx \|\| ctx->used) {		if (!ctx \|\| ctx->used) {
if (ctx) {		if (ctx) {
bContextStore *lastctx = ctx;		bContextStore *lastctx = ctx;
ctx = MEM_dupallocN(lastctx);		ctx = MEM_new<bContextStore>(__func__);
		ctx = lastctx;
BLI_duplicatelist(&ctx->entries, &lastctx->entries);		BLI_duplicatelist(&ctx->entries, &lastctx->entries);
}		}
else {		else {
ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");		ctx = MEM_cnew<bContextStore>(__func__);
}		}

BLI_addtail(contexts, ctx);		BLI_addtail(contexts, ctx);
}		}

LISTBASE_FOREACH (bContextStoreEntry *, tentry, &context->entries) {		LISTBASE_FOREACH (bContextStoreEntry *, tentry, &context->entries) {
bContextStoreEntry *entry = MEM_dupallocN(tentry);		bContextStoreEntry *entry = MEM_cnew<bContextStoreEntry>(__func__);
		entry = tentry;
BLI_addtail(&ctx->entries, entry);		BLI_addtail(&ctx->entries, entry);
}		}

return ctx;		return ctx;
}		}

bContextStore CTX_store_get(bContext C)		bContextStore CTX_store_get(bContext C)
{		{
return C->wm.store;		return C->wm.store;
}		}

void CTX_store_set(bContext C, bContextStore store)		void CTX_store_set(bContext C, bContextStore store)
{		{
C->wm.store = store;		C->wm.store = store;
}		}

const PointerRNA CTX_store_ptr_lookup(const bContextStore store,		const PointerRNA CTX_store_ptr_lookup(const bContextStore store,
const char *name,		const char *name,
const StructRNA *type)		const StructRNA *type)
{		{
bContextStoreEntry *entry = BLI_rfindstring(		bContextStoreEntry entry = static_cast<bContextStoreEntry >(
&store->entries, name, offsetof(bContextStoreEntry, name));		BLI_rfindstring(&store->entries, name, offsetof(bContextStoreEntry, name)));
if (!entry) {		if (!entry) {
return NULL;		return nullptr;
}		}

if (type && !RNA_struct_is_a(entry->ptr.type, type)) {		if (type && !RNA_struct_is_a(entry->ptr.type, type)) {
return NULL;		return nullptr;
}		}
return &entry->ptr;		return &entry->ptr;
}		}

bContextStore CTX_store_copy(bContextStore store)		bContextStore CTX_store_copy(bContextStore store)
{		{
bContextStore *ctx = MEM_dupallocN(store);		bContextStore *ctx = MEM_cnew<bContextStore>(__func__);
		ctx = store;
BLI_duplicatelist(&ctx->entries, &store->entries);		BLI_duplicatelist(&ctx->entries, &store->entries);

return ctx;		return ctx;
}		}

void CTX_store_free(bContextStore *store)		void CTX_store_free(bContextStore *store)
{		{
BLI_freelistN(&store->entries);		BLI_freelistN(&store->entries);
MEM_freeN(store);		MEM_freeN(store);
}		}

void CTX_store_free_list(ListBase *contexts)		void CTX_store_free_list(ListBase *contexts)
{		{
bContextStore *ctx;		bContextStore *ctx;
while ((ctx = BLI_pophead(contexts))) {		while ((ctx = static_cast<bContextStore *>(BLI_pophead(contexts)))) {
CTX_store_free(ctx);		CTX_store_free(ctx);
}		}
}		}

/* is python initialized? */		/* is python initialized? */

bool CTX_py_init_get(bContext *C)		bool CTX_py_init_get(bContext *C)
{		{
return C->data.py_init;		return C->data.py_init;
}		}
void CTX_py_init_set(bContext *C, bool value)		void CTX_py_init_set(bContext *C, bool value)
{		{
C->data.py_init = value;		C->data.py_init = value;
}		}

void CTX_py_dict_get(const bContext C)		void CTX_py_dict_get(const bContext C)
{		{
return C->data.py_context;		return C->data.py_context;
}		}
void CTX_py_dict_get_orig(const bContext C)		void CTX_py_dict_get_orig(const bContext C)
{		{
return C->data.py_context_orig;		return C->data.py_context_orig;
}		}

void CTX_py_state_push(bContext C, struct bContext_PyState pystate, void *value)		void CTX_py_state_push(bContext C, bContext_PyState pystate, void *value)
{		{
pystate->py_context = C->data.py_context;		pystate->py_context = C->data.py_context;
pystate->py_context_orig = C->data.py_context_orig;		pystate->py_context_orig = C->data.py_context_orig;

C->data.py_context = value;		C->data.py_context = value;
C->data.py_context_orig = value;		C->data.py_context_orig = value;
}		}
void CTX_py_state_pop(bContext C, struct bContext_PyState pystate)		void CTX_py_state_pop(bContext C, bContext_PyState pystate)
{		{
C->data.py_context = pystate->py_context;		C->data.py_context = pystate->py_context;
C->data.py_context_orig = pystate->py_context_orig;		C->data.py_context_orig = pystate->py_context_orig;
}		}

/* data context utility functions */		/* data context utility functions */

struct bContextDataResult {		struct bContextDataResult {
Show All 27 Lines	if (UNLIKELY(C && CTX_py_dict_get(C))) {
}		}
}		}
#else		#else
UNUSED_VARS(C, member, member_type);		UNUSED_VARS(C, member, member_type);
#endif		#endif

/* don't allow UI context access from non-main threads */		/* don't allow UI context access from non-main threads */
if (!BLI_thread_is_main()) {		if (!BLI_thread_is_main()) {
return NULL;		return nullptr;
}		}

return fall_through;		return fall_through;
}		}

static eContextResult ctx_data_get(bContext C, const char member, bContextDataResult *result)		static eContextResult ctx_data_get(bContext C, const char member, bContextDataResult *result)
{		{
bScreen *screen;		bScreen *screen;
ScrArea *area;		ScrArea *area;
ARegion *region;		ARegion *region;
int done = 0, recursion = C->data.recursion;		int done = 0, recursion = C->data.recursion;
int ret = 0;		int ret = 0;

memset(result, 0, sizeof(bContextDataResult));		memset(result, 0, sizeof(bContextDataResult));
#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (CTX_py_dict_get(C)) {		if (CTX_py_dict_get(C)) {
if (BPY_context_member_get(C, member, result)) {		if (BPY_context_member_get(C, member, result)) {
return 1;		return CTX_RESULT_OK;
}		}
}		}
#endif		#endif

/* don't allow UI context access from non-main threads */		/* don't allow UI context access from non-main threads */
if (!BLI_thread_is_main()) {		if (!BLI_thread_is_main()) {
return done;		return CTX_RESULT_MEMBER_NOT_FOUND;
}		}

/* we check recursion to ensure that we do not get infinite		/* we check recursion to ensure that we do not get infinite
* loops requesting data from ourselves in a context callback */		* loops requesting data from ourselves in a context callback */

/* Ok, this looks evil...		/* Ok, this looks evil...
* if (ret) done = -(-ret \| -done);		* if (ret) done = -(-ret \| -done);
*		*
* Values in order of importance		* Values in order of importance
* (0, -1, 1) - Where 1 is highest priority		* (0, -1, 1) - Where 1 is highest priority
*/		*/
if (done != 1 && recursion < 1 && C->wm.store) {		if (done != 1 && recursion < 1 && C->wm.store) {
C->data.recursion = 1;		C->data.recursion = 1;

const PointerRNA *ptr = CTX_store_ptr_lookup(C->wm.store, member, NULL);		const PointerRNA *ptr = CTX_store_ptr_lookup(C->wm.store, member, nullptr);

if (ptr) {		if (ptr) {
result->ptr = *ptr;		result->ptr = *ptr;
done = 1;		done = 1;
}		}
}		}
if (done != 1 && recursion < 2 && (region = CTX_wm_region(C))) {		if (done != 1 && recursion < 2 && (region = CTX_wm_region(C))) {
C->data.recursion = 2;		C->data.recursion = 2;
Show All 10 Lines	if (area->type && area->type->context) {
ret = area->type->context(C, member, result);		ret = area->type->context(C, member, result);
if (ret) {		if (ret) {
done = -(-ret \| -done);		done = -(-ret \| -done);
}		}
}		}
}		}

if (done != 1 && recursion < 4 && (screen = CTX_wm_screen(C))) {		if (done != 1 && recursion < 4 && (screen = CTX_wm_screen(C))) {
bContextDataCallback cb = screen->context;		bContextDataCallback cb = reinterpret_cast<bContextDataCallback>(screen->context);
C->data.recursion = 4;		C->data.recursion = 4;
if (cb) {		if (cb) {
ret = cb(C, member, result);		ret = cb(C, member, result);
if (ret) {		if (ret) {
done = -(-ret \| -done);		done = -(-ret \| -done);
}		}
}		}
}		}

C->data.recursion = recursion;		C->data.recursion = recursion;

return done;		return eContextResult(done);
}		}

static void ctx_data_pointer_get(const bContext C, const char *member)		static void ctx_data_pointer_get(const bContext C, const char *member)
{		{
bContextDataResult result;		bContextDataResult result;
if (C && ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {		if (C && ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {
BLI_assert(result.type == CTX_DATA_TYPE_POINTER);		BLI_assert(result.type == CTX_DATA_TYPE_POINTER);
return result.ptr.data;		return result.ptr.data;
}		}

return NULL;		return nullptr;
}		}

static bool ctx_data_pointer_verify(const bContext C, const char member, void **pointer)		static bool ctx_data_pointer_verify(const bContext C, const char member, void **pointer)
{		{
/* if context is NULL, pointer must be NULL too and that is a valid return */		/* if context is nullptr, pointer must be nullptr too and that is a valid return */
if (C == NULL) {		if (C == nullptr) {
*pointer = NULL;		*pointer = nullptr;
return true;		return true;
}		}

bContextDataResult result;		bContextDataResult result;
if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {		if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {
BLI_assert(result.type == CTX_DATA_TYPE_POINTER);		BLI_assert(result.type == CTX_DATA_TYPE_POINTER);
*pointer = result.ptr.data;		*pointer = result.ptr.data;
return true;		return true;
}		}

*pointer = NULL;		*pointer = nullptr;
return false;		return false;
}		}

static bool ctx_data_collection_get(const bContext C, const char member, ListBase *list)		static bool ctx_data_collection_get(const bContext C, const char member, ListBase *list)
{		{
bContextDataResult result;		bContextDataResult result;
if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {		if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {
BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);		BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);
Show All 20 Lines	static int ctx_data_base_collection_get(const bContext C, const char member, ListBase *list)

Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);		ViewLayer *view_layer = CTX_data_view_layer(C);
BKE_view_layer_synced_ensure(scene, view_layer);		BKE_view_layer_synced_ensure(scene, view_layer);

bool ok = false;		bool ok = false;

CollectionPointerLink *ctx_object;		CollectionPointerLink *ctx_object;
for (ctx_object = ctx_object_list.first; ctx_object; ctx_object = ctx_object->next) {		for (ctx_object = static_cast<CollectionPointerLink *>(ctx_object_list.first); ctx_object;
Object *ob = ctx_object->ptr.data;		ctx_object = ctx_object->next) {
		Object ob = static_cast<Object >(ctx_object->ptr.data);
Base *base = BKE_view_layer_base_find(view_layer, ob);		Base *base = BKE_view_layer_base_find(view_layer, ob);
if (base != NULL) {		if (base != nullptr) {
CTX_data_list_add(&result, &scene->id, &RNA_ObjectBase, base);		CTX_data_list_add(&result, &scene->id, &RNA_ObjectBase, base);
ok = true;		ok = true;
}		}
}		}
CTX_data_type_set(&result, CTX_DATA_TYPE_COLLECTION);		CTX_data_type_set(&result, CTX_DATA_TYPE_COLLECTION);
BLI_freelistN(&ctx_object_list);		BLI_freelistN(&ctx_object_list);

*list = result.list;		*list = result.list;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
ListBase CTX_data_collection_get(const bContext C, const char member)		ListBase CTX_data_collection_get(const bContext C, const char member)
{		{
bContextDataResult result;		bContextDataResult result;
if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {		if (ctx_data_get((bContext *)C, member, &result) == CTX_RESULT_OK) {
BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);		BLI_assert(result.type == CTX_DATA_TYPE_COLLECTION);
return result.list;		return result.list;
}		}

ListBase list = {NULL, NULL};		ListBase list = {nullptr, nullptr};
return list;		return list;
}		}

int /eContextResult/ CTX_data_get(		int /eContextResult/ CTX_data_get(
const bContext C, const char member, PointerRNA r_ptr, ListBase r_lb, short *r_type)		const bContext C, const char member, PointerRNA r_ptr, ListBase r_lb, short *r_type)
{		{
bContextDataResult result;		bContextDataResult result;
eContextResult ret = ctx_data_get((bContext *)C, member, &result);		eContextResult ret = ctx_data_get((bContext *)C, member, &result);
Show All 19 Lines	static void data_dir_add(ListBase lb, const char member, const bool use_all)
if ((use_all == false) && STREQ(member, "scene")) { /* exception */		if ((use_all == false) && STREQ(member, "scene")) { /* exception */
return;		return;
}		}

if (BLI_findstring(lb, member, offsetof(LinkData, data))) {		if (BLI_findstring(lb, member, offsetof(LinkData, data))) {
return;		return;
}		}

link = MEM_callocN(sizeof(LinkData), "LinkData");		link = MEM_cnew<LinkData>(__func__);
link->data = (void *)member;		link->data = (void *)member;
BLI_addtail(lb, link);		BLI_addtail(lb, link);
}		}

ListBase CTX_data_dir_get_ex(const bContext *C,		ListBase CTX_data_dir_get_ex(const bContext *C,
const bool use_store,		const bool use_store,
const bool use_rna,		const bool use_rna,
const bool use_all)		const bool use_all)
{		{
bContextDataResult result;		bContextDataResult result;
ListBase lb;		ListBase lb;
bScreen *screen;		bScreen *screen;
ScrArea *area;		ScrArea *area;
ARegion *region;		ARegion *region;
int a;		int a;

memset(&lb, 0, sizeof(lb));		memset(&lb, 0, sizeof(lb));

if (use_rna) {		if (use_rna) {
char name[256], *nameptr;		char name[256], *nameptr;
int namelen;		int namelen;

PropertyRNA *iterprop;		PropertyRNA *iterprop;
PointerRNA ctx_ptr;		PointerRNA ctx_ptr;
RNA_pointer_create(NULL, &RNA_Context, (void *)C, &ctx_ptr);		RNA_pointer_create(nullptr, &RNA_Context, (void *)C, &ctx_ptr);

iterprop = RNA_struct_iterator_property(ctx_ptr.type);		iterprop = RNA_struct_iterator_property(ctx_ptr.type);

RNA_PROP_BEGIN (&ctx_ptr, itemptr, iterprop) {		RNA_PROP_BEGIN (&ctx_ptr, itemptr, iterprop) {
nameptr = RNA_struct_name_get_alloc(&itemptr, name, sizeof(name), &namelen);		nameptr = RNA_struct_name_get_alloc(&itemptr, name, sizeof(name), &namelen);
data_dir_add(&lb, name, use_all);		data_dir_add(&lb, name, use_all);
if (nameptr) {		if (nameptr) {
if (name != nameptr) {		if (name != nameptr) {
MEM_freeN(nameptr);		MEM_freeN(nameptr);
}		}
}		}
}		}
RNA_PROP_END;		RNA_PROP_END;
}		}
if (use_store && C->wm.store) {		if (use_store && C->wm.store) {
bContextStoreEntry *entry;		bContextStoreEntry *entry;

for (entry = C->wm.store->entries.first; entry; entry = entry->next) {		for (entry = static_cast<bContextStoreEntry *>(C->wm.store->entries.first); entry;
		entry = entry->next) {
data_dir_add(&lb, entry->name, use_all);		data_dir_add(&lb, entry->name, use_all);
}		}
}		}
if ((region = CTX_wm_region(C)) && region->type && region->type->context) {		if ((region = CTX_wm_region(C)) && region->type && region->type->context) {
memset(&result, 0, sizeof(result));		memset(&result, 0, sizeof(result));
region->type->context(C, "", &result);		region->type->context(C, "", &result);

if (result.dir) {		if (result.dir) {
for (a = 0; result.dir[a]; a++) {		for (a = 0; result.dir[a]; a++) {
data_dir_add(&lb, result.dir[a], use_all);		data_dir_add(&lb, result.dir[a], use_all);
}		}
}		}
}		}
if ((area = CTX_wm_area(C)) && area->type && area->type->context) {		if ((area = CTX_wm_area(C)) && area->type && area->type->context) {
memset(&result, 0, sizeof(result));		memset(&result, 0, sizeof(result));
area->type->context(C, "", &result);		area->type->context(C, "", &result);

if (result.dir) {		if (result.dir) {
for (a = 0; result.dir[a]; a++) {		for (a = 0; result.dir[a]; a++) {
data_dir_add(&lb, result.dir[a], use_all);		data_dir_add(&lb, result.dir[a], use_all);
}		}
}		}
}		}
if ((screen = CTX_wm_screen(C)) && screen->context) {		if ((screen = CTX_wm_screen(C)) && screen->context) {
bContextDataCallback cb = screen->context;		bContextDataCallback cb = reinterpret_cast<bContextDataCallback>(screen->context);
memset(&result, 0, sizeof(result));		memset(&result, 0, sizeof(result));
cb(C, "", &result);		cb(C, "", &result);

if (result.dir) {		if (result.dir) {
for (a = 0; result.dir[a]; a++) {		for (a = 0; result.dir[a]; a++) {
data_dir_add(&lb, result.dir[a], use_all);		data_dir_add(&lb, result.dir[a], use_all);
}		}
}		}
Show All 29 Lines

void CTX_data_pointer_set_ptr(bContextDataResult result, const PointerRNA ptr)		void CTX_data_pointer_set_ptr(bContextDataResult result, const PointerRNA ptr)
{		{
result->ptr = *ptr;		result->ptr = *ptr;
}		}

void CTX_data_id_list_add(bContextDataResult result, ID id)		void CTX_data_id_list_add(bContextDataResult result, ID id)
{		{
CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");		CollectionPointerLink *link = MEM_cnew<CollectionPointerLink>(__func__);
RNA_id_pointer_create(id, &link->ptr);		RNA_id_pointer_create(id, &link->ptr);

BLI_addtail(&result->list, link);		BLI_addtail(&result->list, link);
}		}

void CTX_data_list_add(bContextDataResult result, ID id, StructRNA type, void data)		void CTX_data_list_add(bContextDataResult result, ID id, StructRNA type, void data)
{		{
CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");		CollectionPointerLink *link = MEM_cnew<CollectionPointerLink>(__func__);
RNA_pointer_create(id, type, data, &link->ptr);		RNA_pointer_create(id, type, data, &link->ptr);

BLI_addtail(&result->list, link);		BLI_addtail(&result->list, link);
}		}

void CTX_data_list_add_ptr(bContextDataResult result, const PointerRNA ptr)		void CTX_data_list_add_ptr(bContextDataResult result, const PointerRNA ptr)
{		{
CollectionPointerLink *link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");		CollectionPointerLink *link = MEM_cnew<CollectionPointerLink>(__func__);
link->ptr = *ptr;		link->ptr = *ptr;

BLI_addtail(&result->list, link);		BLI_addtail(&result->list, link);
}		}

int ctx_data_list_count(const bContext C, bool (func)(const bContext , ListBase ))		int ctx_data_list_count(const bContext C, bool (func)(const bContext , ListBase ))
{		{
ListBase list;		ListBase list;
Show All 26 Lines

wmWindowManager CTX_wm_manager(const bContext C)		wmWindowManager CTX_wm_manager(const bContext C)
{		{
return C->wm.manager;		return C->wm.manager;
}		}

bool CTX_wm_interface_locked(const bContext *C)		bool CTX_wm_interface_locked(const bContext *C)
{		{
return (bool)C->wm.manager->is_interface_locked;		return bool(C->wm.manager->is_interface_locked);
}		}

wmWindow CTX_wm_window(const bContext C)		wmWindow CTX_wm_window(const bContext C)
{		{
return ctx_wm_python_context_get(C, "window", &RNA_Window, C->wm.window);		return static_cast<wmWindow *>(
		ctx_wm_python_context_get(C, "window", &RNA_Window, C->wm.window));
}		}

WorkSpace CTX_wm_workspace(const bContext C)		WorkSpace CTX_wm_workspace(const bContext C)
{		{
return ctx_wm_python_context_get(C, "workspace", &RNA_WorkSpace, C->wm.workspace);		return static_cast<WorkSpace *>(
		ctx_wm_python_context_get(C, "workspace", &RNA_WorkSpace, C->wm.workspace));
}		}

bScreen CTX_wm_screen(const bContext C)		bScreen CTX_wm_screen(const bContext C)
{		{
return ctx_wm_python_context_get(C, "screen", &RNA_Screen, C->wm.screen);		return static_cast<bScreen *>(ctx_wm_python_context_get(C, "screen", &RNA_Screen, C->wm.screen));
}		}

ScrArea CTX_wm_area(const bContext C)		ScrArea CTX_wm_area(const bContext C)
{		{
return ctx_wm_python_context_get(C, "area", &RNA_Area, C->wm.area);		return static_cast<ScrArea *>(ctx_wm_python_context_get(C, "area", &RNA_Area, C->wm.area));
}		}

SpaceLink CTX_wm_space_data(const bContext C)		SpaceLink CTX_wm_space_data(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
return (area) ? area->spacedata.first : NULL;		return (area) ? static_cast<SpaceLink *>(area->spacedata.first) : nullptr;
}		}

ARegion CTX_wm_region(const bContext C)		ARegion CTX_wm_region(const bContext C)
{		{
return ctx_wm_python_context_get(C, "region", &RNA_Region, C->wm.region);		return static_cast<ARegion *>(ctx_wm_python_context_get(C, "region", &RNA_Region, C->wm.region));
}		}

void CTX_wm_region_data(const bContext C)		void CTX_wm_region_data(const bContext C)
{		{
ARegion *region = CTX_wm_region(C);		ARegion *region = CTX_wm_region(C);
return (region) ? region->regiondata : NULL;		return (region) ? region->regiondata : nullptr;
}		}

struct ARegion CTX_wm_menu(const bContext C)		ARegion CTX_wm_menu(const bContext C)
{		{
return C->wm.menu;		return C->wm.menu;
}		}

struct wmGizmoGroup CTX_wm_gizmo_group(const bContext C)		wmGizmoGroup CTX_wm_gizmo_group(const bContext C)
{		{
return C->wm.gizmo_group;		return C->wm.gizmo_group;
}		}

struct wmMsgBus CTX_wm_message_bus(const bContext C)		wmMsgBus CTX_wm_message_bus(const bContext C)
{		{
return C->wm.manager ? C->wm.manager->message_bus : NULL;		return C->wm.manager ? C->wm.manager->message_bus : nullptr;
}		}

struct ReportList CTX_wm_reports(const bContext C)		ReportList CTX_wm_reports(const bContext C)
{		{
if (C->wm.manager) {		if (C->wm.manager) {
return &(C->wm.manager->reports);		return &(C->wm.manager->reports);
}		}

return NULL;		return nullptr;
}		}

View3D CTX_wm_view3d(const bContext C)		View3D CTX_wm_view3d(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_VIEW3D) {		if (area && area->spacetype == SPACE_VIEW3D) {
return area->spacedata.first;		return static_cast<View3D *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

RegionView3D CTX_wm_region_view3d(const bContext C)		RegionView3D CTX_wm_region_view3d(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
ARegion *region = CTX_wm_region(C);		ARegion *region = CTX_wm_region(C);

if (area && area->spacetype == SPACE_VIEW3D) {		if (area && area->spacetype == SPACE_VIEW3D) {
if (region && region->regiontype == RGN_TYPE_WINDOW) {		if (region && region->regiontype == RGN_TYPE_WINDOW) {
return region->regiondata;		return static_cast<RegionView3D *>(region->regiondata);
}		}
}		}
return NULL;		return nullptr;
}		}

struct SpaceText CTX_wm_space_text(const bContext C)		SpaceText CTX_wm_space_text(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_TEXT) {		if (area && area->spacetype == SPACE_TEXT) {
return area->spacedata.first;		return static_cast<SpaceText *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceConsole CTX_wm_space_console(const bContext C)		SpaceConsole CTX_wm_space_console(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_CONSOLE) {		if (area && area->spacetype == SPACE_CONSOLE) {
return area->spacedata.first;		return static_cast<SpaceConsole *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceImage CTX_wm_space_image(const bContext C)		SpaceImage CTX_wm_space_image(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_IMAGE) {		if (area && area->spacetype == SPACE_IMAGE) {
return area->spacedata.first;		return static_cast<SpaceImage *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceProperties CTX_wm_space_properties(const bContext C)		SpaceProperties CTX_wm_space_properties(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_PROPERTIES) {		if (area && area->spacetype == SPACE_PROPERTIES) {
return area->spacedata.first;		return static_cast<SpaceProperties *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceFile CTX_wm_space_file(const bContext C)		SpaceFile CTX_wm_space_file(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_FILE) {		if (area && area->spacetype == SPACE_FILE) {
return area->spacedata.first;		return static_cast<SpaceFile *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceSeq CTX_wm_space_seq(const bContext C)		SpaceSeq CTX_wm_space_seq(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_SEQ) {		if (area && area->spacetype == SPACE_SEQ) {
return area->spacedata.first;		return static_cast<SpaceSeq *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceOutliner CTX_wm_space_outliner(const bContext C)		SpaceOutliner CTX_wm_space_outliner(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_OUTLINER) {		if (area && area->spacetype == SPACE_OUTLINER) {
return area->spacedata.first;		return static_cast<SpaceOutliner *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceNla CTX_wm_space_nla(const bContext C)		SpaceNla CTX_wm_space_nla(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_NLA) {		if (area && area->spacetype == SPACE_NLA) {
return area->spacedata.first;		return static_cast<SpaceNla *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceNode CTX_wm_space_node(const bContext C)		SpaceNode CTX_wm_space_node(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_NODE) {		if (area && area->spacetype == SPACE_NODE) {
return area->spacedata.first;		return static_cast<SpaceNode *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceGraph CTX_wm_space_graph(const bContext C)		SpaceGraph CTX_wm_space_graph(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_GRAPH) {		if (area && area->spacetype == SPACE_GRAPH) {
return area->spacedata.first;		return static_cast<SpaceGraph *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceAction CTX_wm_space_action(const bContext C)		SpaceAction CTX_wm_space_action(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_ACTION) {		if (area && area->spacetype == SPACE_ACTION) {
return area->spacedata.first;		return static_cast<SpaceAction *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceInfo CTX_wm_space_info(const bContext C)		SpaceInfo CTX_wm_space_info(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_INFO) {		if (area && area->spacetype == SPACE_INFO) {
return area->spacedata.first;		return static_cast<SpaceInfo *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceUserPref CTX_wm_space_userpref(const bContext C)		SpaceUserPref CTX_wm_space_userpref(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_USERPREF) {		if (area && area->spacetype == SPACE_USERPREF) {
return area->spacedata.first;		return static_cast<SpaceUserPref *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceClip CTX_wm_space_clip(const bContext C)		SpaceClip CTX_wm_space_clip(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_CLIP) {		if (area && area->spacetype == SPACE_CLIP) {
return area->spacedata.first;		return static_cast<SpaceClip *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceTopBar CTX_wm_space_topbar(const bContext C)		SpaceTopBar CTX_wm_space_topbar(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_TOPBAR) {		if (area && area->spacetype == SPACE_TOPBAR) {
return area->spacedata.first;		return static_cast<SpaceTopBar *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

struct SpaceSpreadsheet CTX_wm_space_spreadsheet(const bContext C)		SpaceSpreadsheet CTX_wm_space_spreadsheet(const bContext C)
{		{
ScrArea *area = CTX_wm_area(C);		ScrArea *area = CTX_wm_area(C);
if (area && area->spacetype == SPACE_SPREADSHEET) {		if (area && area->spacetype == SPACE_SPREADSHEET) {
return area->spacedata.first;		return static_cast<SpaceSpreadsheet *>(area->spacedata.first);
}		}
return NULL;		return nullptr;
}		}

void CTX_wm_manager_set(bContext C, wmWindowManager wm)		void CTX_wm_manager_set(bContext C, wmWindowManager wm)
{		{
C->wm.manager = wm;		C->wm.manager = wm;
C->wm.window = NULL;		C->wm.window = nullptr;
C->wm.screen = NULL;		C->wm.screen = nullptr;
C->wm.area = NULL;		C->wm.area = nullptr;
C->wm.region = NULL;		C->wm.region = nullptr;
}		}

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
# define PYCTX_REGION_MEMBERS "region", "region_data"		# define PYCTX_REGION_MEMBERS "region", "region_data"
# define PYCTX_AREA_MEMBERS "area", "space_data", PYCTX_REGION_MEMBERS		# define PYCTX_AREA_MEMBERS "area", "space_data", PYCTX_REGION_MEMBERS
# define PYCTX_SCREEN_MEMBERS "screen", PYCTX_AREA_MEMBERS		# define PYCTX_SCREEN_MEMBERS "screen", PYCTX_AREA_MEMBERS
# define PYCTX_WINDOW_MEMBERS "window", "scene", "workspace", PYCTX_SCREEN_MEMBERS		# define PYCTX_WINDOW_MEMBERS "window", "scene", "workspace", PYCTX_SCREEN_MEMBERS
#endif		#endif

void CTX_wm_window_set(bContext C, wmWindow win)		void CTX_wm_window_set(bContext C, wmWindow win)
{		{
C->wm.window = win;		C->wm.window = win;
if (win) {		if (win) {
C->data.scene = win->scene;		C->data.scene = win->scene;
}		}
C->wm.workspace = (win) ? BKE_workspace_active_get(win->workspace_hook) : NULL;		C->wm.workspace = (win) ? BKE_workspace_active_get(win->workspace_hook) : nullptr;
C->wm.screen = (win) ? BKE_workspace_active_screen_get(win->workspace_hook) : NULL;		C->wm.screen = (win) ? BKE_workspace_active_screen_get(win->workspace_hook) : nullptr;
C->wm.area = NULL;		C->wm.area = nullptr;
C->wm.region = NULL;		C->wm.region = nullptr;

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (C->data.py_context != NULL) {		if (C->data.py_context != nullptr) {
BPY_context_dict_clear_members(C, PYCTX_WINDOW_MEMBERS);		const char *members[] = {PYCTX_WINDOW_MEMBERS};
		BPY_context_dict_clear_members_array(
		&C->data.py_context, C->data.py_context_orig, members, ARRAY_SIZE(members));
}		}
#endif		#endif
}		}

void CTX_wm_screen_set(bContext C, bScreen screen)		void CTX_wm_screen_set(bContext C, bScreen screen)
{		{
C->wm.screen = screen;		C->wm.screen = screen;
C->wm.area = NULL;		C->wm.area = nullptr;
C->wm.region = NULL;		C->wm.region = nullptr;

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (C->data.py_context != NULL) {		if (C->data.py_context != nullptr) {
BPY_context_dict_clear_members(C, PYCTX_SCREEN_MEMBERS);		const char *members[] = {PYCTX_SCREEN_MEMBERS};
		BPY_context_dict_clear_members_array(
		&C->data.py_context, C->data.py_context_orig, members, ARRAY_SIZE(members));
}		}
#endif		#endif
}		}

void CTX_wm_area_set(bContext C, ScrArea area)		void CTX_wm_area_set(bContext C, ScrArea area)
{		{
C->wm.area = area;		C->wm.area = area;
C->wm.region = NULL;		C->wm.region = nullptr;

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (C->data.py_context != NULL) {		if (C->data.py_context != nullptr) {
BPY_context_dict_clear_members(C, PYCTX_AREA_MEMBERS);		const char *members[] = {PYCTX_AREA_MEMBERS};
		BPY_context_dict_clear_members_array(
		&C->data.py_context, C->data.py_context_orig, members, ARRAY_SIZE(members));
}		}
#endif		#endif
}		}

void CTX_wm_region_set(bContext C, ARegion region)		void CTX_wm_region_set(bContext C, ARegion region)
{		{
C->wm.region = region;		C->wm.region = region;

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (C->data.py_context != NULL) {		if (C->data.py_context != nullptr) {
BPY_context_dict_clear_members(C, PYCTX_REGION_MEMBERS);		const char *members[] = {PYCTX_REGION_MEMBERS};
		BPY_context_dict_clear_members_array(
		&C->data.py_context, C->data.py_context_orig, members, ARRAY_SIZE(members));
}		}
#endif		#endif
}		}

void CTX_wm_menu_set(bContext C, ARegion menu)		void CTX_wm_menu_set(bContext C, ARegion menu)
{		{
C->wm.menu = menu;		C->wm.menu = menu;
}		}

void CTX_wm_gizmo_group_set(bContext C, struct wmGizmoGroup gzgroup)		void CTX_wm_gizmo_group_set(bContext C, wmGizmoGroup gzgroup)
{		{
C->wm.gizmo_group = gzgroup;		C->wm.gizmo_group = gzgroup;
}		}

void CTX_wm_operator_poll_msg_clear(bContext *C)		void CTX_wm_operator_poll_msg_clear(bContext *C)
{		{
struct bContextPollMsgDyn_Params *params = &C->wm.operator_poll_msg_dyn_params;		bContextPollMsgDyn_Params *params = &C->wm.operator_poll_msg_dyn_params;
if (params->free_fn != NULL) {		if (params->free_fn != nullptr) {
params->free_fn(C, params->user_data);		params->free_fn(C, params->user_data);
}		}
params->get_fn = NULL;		params->get_fn = nullptr;
params->free_fn = NULL;		params->free_fn = nullptr;
params->user_data = NULL;		params->user_data = nullptr;

C->wm.operator_poll_msg = NULL;		C->wm.operator_poll_msg = nullptr;
}		}
void CTX_wm_operator_poll_msg_set(bContext C, const char msg)		void CTX_wm_operator_poll_msg_set(bContext C, const char msg)
{		{
CTX_wm_operator_poll_msg_clear(C);		CTX_wm_operator_poll_msg_clear(C);

C->wm.operator_poll_msg = msg;		C->wm.operator_poll_msg = msg;
}		}

void CTX_wm_operator_poll_msg_set_dynamic(bContext *C,		void CTX_wm_operator_poll_msg_set_dynamic(bContext C, const bContextPollMsgDyn_Params params)
const struct bContextPollMsgDyn_Params *params)
{		{
CTX_wm_operator_poll_msg_clear(C);		CTX_wm_operator_poll_msg_clear(C);

C->wm.operator_poll_msg_dyn_params = *params;		C->wm.operator_poll_msg_dyn_params = *params;
}		}

const char CTX_wm_operator_poll_msg_get(bContext C, bool *r_free)		const char CTX_wm_operator_poll_msg_get(bContext C, bool *r_free)
{		{
struct bContextPollMsgDyn_Params *params = &C->wm.operator_poll_msg_dyn_params;		bContextPollMsgDyn_Params *params = &C->wm.operator_poll_msg_dyn_params;
if (params->get_fn != NULL) {		if (params->get_fn != nullptr) {
char *msg = params->get_fn(C, params->user_data);		char *msg = params->get_fn(C, params->user_data);
if (msg != NULL) {		if (msg != nullptr) {
*r_free = true;		*r_free = true;
}		}
return msg;		return msg;
}		}

*r_free = false;		*r_free = false;
return IFACE_(C->wm.operator_poll_msg);		return IFACE_(C->wm.operator_poll_msg);
}		}

/* data context */		/* data context */

Main CTX_data_main(const bContext C)		Main CTX_data_main(const bContext C)
{		{
Main *bmain;		Main *bmain;
if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain)) {		if (ctx_data_pointer_verify(C, "blend_data", (void **)&bmain)) {
return bmain;		return bmain;
}		}

return C->data.main;		return C->data.main;
}		}

void CTX_data_main_set(bContext C, Main bmain)		void CTX_data_main_set(bContext C, Main bmain)
{		{
C->data.main = bmain;		C->data.main = bmain;
BKE_sound_init_main(bmain);		BKE_sound_init_main(bmain);
}		}

Scene CTX_data_scene(const bContext C)		Scene CTX_data_scene(const bContext C)
{		{
Scene *scene;		Scene *scene;
if (ctx_data_pointer_verify(C, "scene", (void *)&scene)) {		if (ctx_data_pointer_verify(C, "scene", (void **)&scene)) {
return scene;		return scene;
}		}

return C->data.scene;		return C->data.scene;
}		}

ViewLayer CTX_data_view_layer(const bContext C)		ViewLayer CTX_data_view_layer(const bContext C)
{		{
ViewLayer *view_layer;		ViewLayer *view_layer;

if (ctx_data_pointer_verify(C, "view_layer", (void *)&view_layer)) {		if (ctx_data_pointer_verify(C, "view_layer", (void **)&view_layer)) {
return view_layer;		return view_layer;
}		}

wmWindow *win = CTX_wm_window(C);		wmWindow *win = CTX_wm_window(C);
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
if (win) {		if (win) {
view_layer = BKE_view_layer_find(scene, win->view_layer_name);		view_layer = BKE_view_layer_find(scene, win->view_layer_name);
if (view_layer) {		if (view_layer) {
Show All 10 Lines	RenderEngineType CTX_data_engine_type(const bContext C)
return RE_engines_find(scene->r.engine);		return RE_engines_find(scene->r.engine);
}		}

LayerCollection CTX_data_layer_collection(const bContext C)		LayerCollection CTX_data_layer_collection(const bContext C)
{		{
ViewLayer *view_layer = CTX_data_view_layer(C);		ViewLayer *view_layer = CTX_data_view_layer(C);
LayerCollection *layer_collection;		LayerCollection *layer_collection;

if (ctx_data_pointer_verify(C, "layer_collection", (void *)&layer_collection)) {		if (ctx_data_pointer_verify(C, "layer_collection", (void **)&layer_collection)) {
if (BKE_view_layer_has_collection(view_layer, layer_collection->collection)) {		if (BKE_view_layer_has_collection(view_layer, layer_collection->collection)) {
return layer_collection;		return layer_collection;
}		}
}		}

/* fallback */		/* fallback */
return BKE_layer_collection_get_active(view_layer);		return BKE_layer_collection_get_active(view_layer);
}		}

Collection CTX_data_collection(const bContext C)		Collection CTX_data_collection(const bContext C)
{		{
Collection *collection;		Collection *collection;
if (ctx_data_pointer_verify(C, "collection", (void *)&collection)) {		if (ctx_data_pointer_verify(C, "collection", (void **)&collection)) {
return collection;		return collection;
}		}

LayerCollection *layer_collection = CTX_data_layer_collection(C);		LayerCollection *layer_collection = CTX_data_layer_collection(C);
if (layer_collection) {		if (layer_collection) {
return layer_collection->collection;		return layer_collection->collection;
}		}

▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines	enum eContextObjectMode CTX_data_mode_enum_ex(const Object *obedit,
}		}

return CTX_MODE_OBJECT;		return CTX_MODE_OBJECT;
}		}

enum eContextObjectMode CTX_data_mode_enum(const bContext *C)		enum eContextObjectMode CTX_data_mode_enum(const bContext *C)
{		{
Object *obedit = CTX_data_edit_object(C);		Object *obedit = CTX_data_edit_object(C);
Object *obact = obedit ? NULL : CTX_data_active_object(C);		Object *obact = obedit ? nullptr : CTX_data_active_object(C);
return CTX_data_mode_enum_ex(obedit, obact, obact ? obact->mode : OB_MODE_OBJECT);		return CTX_data_mode_enum_ex(obedit, obact, obact ? eObjectMode(obact->mode) : OB_MODE_OBJECT);
}		}

/**		/**
* Would prefer if we can use the enum version below over this one - Campbell.		* Would prefer if we can use the enum version below over this one - Campbell.
*		*
* \note Must be aligned with above enum.		* \note Must be aligned with above enum.
*/		*/
static const char *data_mode_strings[] = {		static const char *data_mode_strings[] = {
Show All 13 Lines	static const char *data_mode_strings[] = {
"particlemode",		"particlemode",
"objectmode",		"objectmode",
"greasepencil_paint",		"greasepencil_paint",
"greasepencil_edit",		"greasepencil_edit",
"greasepencil_sculpt",		"greasepencil_sculpt",
"greasepencil_weight",		"greasepencil_weight",
"greasepencil_vertex",		"greasepencil_vertex",
"curves_sculpt",		"curves_sculpt",
NULL,		nullptr,
};		};
BLI_STATIC_ASSERT(ARRAY_SIZE(data_mode_strings) == CTX_MODE_NUM + 1,		BLI_STATIC_ASSERT(ARRAY_SIZE(data_mode_strings) == CTX_MODE_NUM + 1,
"Must have a string for each context mode")		"Must have a string for each context mode")
const char CTX_data_mode_string(const bContext C)		const char CTX_data_mode_string(const bContext C)
{		{
return data_mode_strings[CTX_data_mode_enum(C)];		return data_mode_strings[CTX_data_mode_enum(C)];
}		}

void CTX_data_scene_set(bContext C, Scene scene)		void CTX_data_scene_set(bContext C, Scene scene)
{		{
C->data.scene = scene;		C->data.scene = scene;

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON
if (C->data.py_context != NULL) {		if (C->data.py_context != nullptr) {
BPY_context_dict_clear_members(C, "scene");		const char *members[] = {"scene"};
		BPY_context_dict_clear_members_array(&C->data.py_context, C->data.py_context_orig, members, 1);
}		}
#endif		#endif
}		}

ToolSettings CTX_data_tool_settings(const bContext C)		ToolSettings CTX_data_tool_settings(const bContext C)
{		{
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);

if (scene) {		if (scene) {
return scene->toolsettings;		return scene->toolsettings;
}		}

return NULL;		return nullptr;
}		}

bool CTX_data_selected_ids(const bContext C, ListBase list)		bool CTX_data_selected_ids(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "selected_ids", list);		return ctx_data_collection_get(C, "selected_ids", list);
}		}

bool CTX_data_selected_nodes(const bContext C, ListBase list)		bool CTX_data_selected_nodes(const bContext C, ListBase list)
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	bool CTX_data_selectable_objects(const bContext C, ListBase list)
return ctx_data_collection_get(C, "selectable_objects", list);		return ctx_data_collection_get(C, "selectable_objects", list);
}		}

bool CTX_data_selectable_bases(const bContext C, ListBase list)		bool CTX_data_selectable_bases(const bContext C, ListBase list)
{		{
return ctx_data_base_collection_get(C, "selectable_objects", list);		return ctx_data_base_collection_get(C, "selectable_objects", list);
}		}

struct Object CTX_data_active_object(const bContext C)		Object CTX_data_active_object(const bContext C)
{		{
return ctx_data_pointer_get(C, "active_object");		return static_cast<Object *>(ctx_data_pointer_get(C, "active_object"));
}		}

struct Base CTX_data_active_base(const bContext C)		Base CTX_data_active_base(const bContext C)
{		{
Object *ob = ctx_data_pointer_get(C, "active_object");		Object *ob = CTX_data_active_object(C);

if (ob == NULL) {		if (ob == nullptr) {
return NULL;		return nullptr;
}		}
const Scene *scene = CTX_data_scene(C);		const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);		ViewLayer *view_layer = CTX_data_view_layer(C);
BKE_view_layer_synced_ensure(scene, view_layer);		BKE_view_layer_synced_ensure(scene, view_layer);
return BKE_view_layer_base_find(view_layer, ob);		return BKE_view_layer_base_find(view_layer, ob);
}		}

struct Object CTX_data_edit_object(const bContext C)		Object CTX_data_edit_object(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_object");		return static_cast<Object *>(ctx_data_pointer_get(C, "edit_object"));
}		}

struct Image CTX_data_edit_image(const bContext C)		Image CTX_data_edit_image(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_image");		return static_cast<Image *>(ctx_data_pointer_get(C, "edit_image"));
}		}

struct Text CTX_data_edit_text(const bContext C)		Text CTX_data_edit_text(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_text");		return static_cast<Text *>(ctx_data_pointer_get(C, "edit_text"));
}		}

struct MovieClip CTX_data_edit_movieclip(const bContext C)		MovieClip CTX_data_edit_movieclip(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_movieclip");		return static_cast<MovieClip *>(ctx_data_pointer_get(C, "edit_movieclip"));
}		}

struct Mask CTX_data_edit_mask(const bContext C)		Mask CTX_data_edit_mask(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_mask");		return static_cast<Mask *>(ctx_data_pointer_get(C, "edit_mask"));
}		}

struct EditBone CTX_data_active_bone(const bContext C)		EditBone CTX_data_active_bone(const bContext C)
{		{
return ctx_data_pointer_get(C, "active_bone");		return static_cast<EditBone *>(ctx_data_pointer_get(C, "active_bone"));
}		}

struct CacheFile CTX_data_edit_cachefile(const bContext C)		CacheFile CTX_data_edit_cachefile(const bContext C)
{		{
return ctx_data_pointer_get(C, "edit_cachefile");		return static_cast<CacheFile *>(ctx_data_pointer_get(C, "edit_cachefile"));
}		}

bool CTX_data_selected_bones(const bContext C, ListBase list)		bool CTX_data_selected_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "selected_bones", list);		return ctx_data_collection_get(C, "selected_bones", list);
}		}

bool CTX_data_selected_editable_bones(const bContext C, ListBase list)		bool CTX_data_selected_editable_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "selected_editable_bones", list);		return ctx_data_collection_get(C, "selected_editable_bones", list);
}		}

bool CTX_data_visible_bones(const bContext C, ListBase list)		bool CTX_data_visible_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "visible_bones", list);		return ctx_data_collection_get(C, "visible_bones", list);
}		}

bool CTX_data_editable_bones(const bContext C, ListBase list)		bool CTX_data_editable_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "editable_bones", list);		return ctx_data_collection_get(C, "editable_bones", list);
}		}

struct bPoseChannel CTX_data_active_pose_bone(const bContext C)		bPoseChannel CTX_data_active_pose_bone(const bContext C)
{		{
return ctx_data_pointer_get(C, "active_pose_bone");		return static_cast<bPoseChannel *>(ctx_data_pointer_get(C, "active_pose_bone"));
}		}

bool CTX_data_selected_pose_bones(const bContext C, ListBase list)		bool CTX_data_selected_pose_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "selected_pose_bones", list);		return ctx_data_collection_get(C, "selected_pose_bones", list);
}		}

bool CTX_data_selected_pose_bones_from_active_object(const bContext C, ListBase list)		bool CTX_data_selected_pose_bones_from_active_object(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "selected_pose_bones_from_active_object", list);		return ctx_data_collection_get(C, "selected_pose_bones_from_active_object", list);
}		}

bool CTX_data_visible_pose_bones(const bContext C, ListBase list)		bool CTX_data_visible_pose_bones(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "visible_pose_bones", list);		return ctx_data_collection_get(C, "visible_pose_bones", list);
}		}

bGPdata CTX_data_gpencil_data(const bContext C)		bGPdata CTX_data_gpencil_data(const bContext C)
{		{
return ctx_data_pointer_get(C, "gpencil_data");		return static_cast<bGPdata *>(ctx_data_pointer_get(C, "gpencil_data"));
}		}

bGPDlayer CTX_data_active_gpencil_layer(const bContext C)		bGPDlayer CTX_data_active_gpencil_layer(const bContext C)
{		{
return ctx_data_pointer_get(C, "active_gpencil_layer");		return static_cast<bGPDlayer *>(ctx_data_pointer_get(C, "active_gpencil_layer"));
}		}

bGPDframe CTX_data_active_gpencil_frame(const bContext C)		bGPDframe CTX_data_active_gpencil_frame(const bContext C)
{		{
return ctx_data_pointer_get(C, "active_gpencil_frame");		return static_cast<bGPDframe *>(ctx_data_pointer_get(C, "active_gpencil_frame"));
}		}

bool CTX_data_visible_gpencil_layers(const bContext C, ListBase list)		bool CTX_data_visible_gpencil_layers(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "visible_gpencil_layers", list);		return ctx_data_collection_get(C, "visible_gpencil_layers", list);
}		}

bool CTX_data_editable_gpencil_layers(const bContext C, ListBase list)		bool CTX_data_editable_gpencil_layers(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "editable_gpencil_layers", list);		return ctx_data_collection_get(C, "editable_gpencil_layers", list);
}		}

bool CTX_data_editable_gpencil_strokes(const bContext C, ListBase list)		bool CTX_data_editable_gpencil_strokes(const bContext C, ListBase list)
{		{
return ctx_data_collection_get(C, "editable_gpencil_strokes", list);		return ctx_data_collection_get(C, "editable_gpencil_strokes", list);
}		}

const AssetLibraryReference CTX_wm_asset_library_ref(const bContext C)		const AssetLibraryReference CTX_wm_asset_library_ref(const bContext C)
{		{
return ctx_data_pointer_get(C, "asset_library_ref");		return static_cast<AssetLibraryReference *>(ctx_data_pointer_get(C, "asset_library_ref"));
}		}

AssetHandle CTX_wm_asset_handle(const bContext C, bool r_is_valid)		AssetHandle CTX_wm_asset_handle(const bContext C, bool r_is_valid)
{		{
AssetHandle *asset_handle_p =		AssetHandle *asset_handle_p =
(AssetHandle *)CTX_data_pointer_get_type(C, "asset_handle", &RNA_AssetHandle).data;		(AssetHandle *)CTX_data_pointer_get_type(C, "asset_handle", &RNA_AssetHandle).data;
if (asset_handle_p) {		if (asset_handle_p) {
*r_is_valid = true;		*r_is_valid = true;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines