Cleanup: Rename callback flags from library_query to `IDWALK_CB_...`

Better to have clear way to tell whether flag is parameter for
BKE_library_foreach_ID_link(), parameter for its callback function, or
return value from this callback function.

7 files changed, 166 insertions, 165 deletions

diff --git a/source/blender/blenkernel/BKE_library_query.h b/source/blender/blenkernel/BKE_library_query.h
index 693d5e9a28b..59b38aec346 100644
--- a/source/blender/blenkernel/BKE_library_query.h
+++ b/source/blender/blenkernel/BKE_library_query.h
@@ -36,28 +36,28 @@ struct Main;
 
 /* Tips for the callback for cases it's gonna to modify the pointer. */
 enum {
-	IDWALK_NOP = 0,
-	IDWALK_NEVER_NULL = (1 << 0),
-	IDWALK_NEVER_SELF = (1 << 1),
+	IDWALK_CB_NOP = 0,
+	IDWALK_CB_NEVER_NULL = (1 << 0),
+	IDWALK_CB_NEVER_SELF = (1 << 1),
 
 	/**
 	 * Indicates whether this is direct (i.e. by local data) or indirect (i.e. by linked data) usage.
 	 * \note Object proxies are half-local, half-linked...
 	 */
-	IDWALK_INDIRECT_USAGE = (1 << 2),
+	IDWALK_CB_INDIRECT_USAGE = (1 << 2),
 
 	/** That ID is used as mere sub-data by its owner
 	 * (only case currently: those f***ing nodetrees in materials etc.).
 	 * This means callback shall not *do* anything, only use this as informative data if it needs it. */
-	IDWALK_PRIVATE = (1 << 3),
+	IDWALK_CB_PRIVATE = (1 << 3),
 
 	/**
 	 * Adjusts #ID.us reference-count.
 	 * \note keep in sync with 'newlibadr_us' use in readfile.c
 	 */
-	IDWALK_USER = (1 << 8),
+	IDWALK_CB_USER = (1 << 8),
 	/** Ensure #ID.us is at least 1 on use. */
-	IDWALK_USER_ONE = (1 << 9),
+	IDWALK_CB_USER_ONE = (1 << 9),
 };
 
 enum {
@@ -75,6 +75,7 @@ typedef int (*LibraryIDLinkCallback) (void *user_data, struct ID *id_self, struc
 
 /* Flags for the foreach function itself. */
 enum {
+	IDWALK_NOP      = 0,
 	IDWALK_READONLY = (1 << 0),
 	IDWALK_RECURSE  = (1 << 1),  /* Also implies IDWALK_READONLY. */
 };
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index daa8c6f5e5c..7350e014d43 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -276,7 +276,7 @@ void BKE_id_clear_newpoin(ID *id)
 static int id_expand_local_callback(
         void *UNUSED(user_data), struct ID *id_self, struct ID **id_pointer, int cd_flag)
 {
-	if (cd_flag & IDWALK_PRIVATE) {
+	if (cd_flag & IDWALK_CB_PRIVATE) {
 		return IDWALK_RET_NOP;
 	}
 
diff --git a/source/blender/blenkernel/intern/library_query.c b/source/blender/blenkernel/intern/library_query.c
index 03c4b803350..9aaf2b24c5d 100644
--- a/source/blender/blenkernel/intern/library_query.c
+++ b/source/blender/blenkernel/intern/library_query.c
@@ -162,7 +162,7 @@ static void library_foreach_constraintObjectLooper(bConstraint *UNUSED(con), ID
                                                    bool is_reference, void *user_data)
 {
 	LibraryForeachIDData *data = (LibraryForeachIDData *) user_data;
-	const int cd_flag = is_reference ? IDWALK_USER : IDWALK_NOP;
+	const int cd_flag = is_reference ? IDWALK_CB_USER : IDWALK_CB_NOP;
 	FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cd_flag);
 
 	FOREACH_FINALIZE_VOID;
@@ -208,7 +208,7 @@ static void library_foreach_nla_strip(LibraryForeachIDData *data, NlaStrip *stri
 {
 	NlaStrip *substrip;
 
-	FOREACH_CALLBACK_INVOKE(data, strip->act, IDWALK_USER);
+	FOREACH_CALLBACK_INVOKE(data, strip->act, IDWALK_CB_USER);
 
 	for (substrip = strip->strips.first; substrip; substrip = substrip->next) {
 		library_foreach_nla_strip(data, substrip);
@@ -231,14 +231,14 @@ static void library_foreach_animationData(LibraryForeachIDData *data, AnimData *
 			/* only used targets */
 			DRIVER_TARGETS_USED_LOOPER(dvar)
 			{
-				FOREACH_CALLBACK_INVOKE_ID(data, dtar->id, IDWALK_NOP);
+				FOREACH_CALLBACK_INVOKE_ID(data, dtar->id, IDWALK_CB_NOP);
 			}
 			DRIVER_TARGETS_LOOPER_END
 		}
 	}
 
-	FOREACH_CALLBACK_INVOKE(data, adt->action, IDWALK_USER);
-	FOREACH_CALLBACK_INVOKE(data, adt->tmpact, IDWALK_USER);
+	FOREACH_CALLBACK_INVOKE(data, adt->action, IDWALK_CB_USER);
+	FOREACH_CALLBACK_INVOKE(data, adt->tmpact, IDWALK_CB_USER);
 
 	for (nla_track = adt->nla_tracks.first; nla_track; nla_track = nla_track->next) {
 		for (nla_strip = nla_track->strips.first; nla_strip; nla_strip = nla_strip->next) {
@@ -251,16 +251,16 @@ static void library_foreach_animationData(LibraryForeachIDData *data, AnimData *
 
 static void library_foreach_mtex(LibraryForeachIDData *data, MTex *mtex)
 {
-	FOREACH_CALLBACK_INVOKE(data, mtex->object, IDWALK_NOP);
-	FOREACH_CALLBACK_INVOKE(data, mtex->tex, IDWALK_USER);
+	FOREACH_CALLBACK_INVOKE(data, mtex->object, IDWALK_CB_NOP);
+	FOREACH_CALLBACK_INVOKE(data, mtex->tex, IDWALK_CB_USER);
 
 	FOREACH_FINALIZE_VOID;
 }
 
 static void library_foreach_paint(LibraryForeachIDData *data, Paint *paint)
 {
-	FOREACH_CALLBACK_INVOKE(data, paint->brush, IDWALK_USER);
-	FOREACH_CALLBACK_INVOKE(data, paint->palette, IDWALK_USER);
+	FOREACH_CALLBACK_INVOKE(data, paint->brush, IDWALK_CB_USER);
+	FOREACH_CALLBACK_INVOKE(data, paint->palette, IDWALK_CB_USER);
 
 	FOREACH_FINALIZE_VOID;
 }
@@ -270,7 +270,7 @@ static void library_foreach_ID_as_subdata_link(
 {
 	/* Needed e.g. for callbacks handling relationships... This call shall be absolutely readonly. */
 	ID *id = *id_pp;
-	FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pp, IDWALK_PRIVATE);
+	FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pp, IDWALK_CB_PRIVATE);
 	BLI_assert(id == *id_pp);
 
 	if (flag & IDWALK_RECURSE) {
@@ -323,7 +323,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 
 	for (; id != NULL; id = (flag & IDWALK_RECURSE) ? BLI_LINKSTACK_POP(data.ids_todo) : NULL) {
 		data.self_id = id;
-		data.cd_flag = ID_IS_LINKED_DATABLOCK(id) ? IDWALK_INDIRECT_USAGE : 0;
+		data.cd_flag = ID_IS_LINKED_DATABLOCK(id) ? IDWALK_CB_INDIRECT_USAGE : 0;
 
 		if (bmain != NULL && bmain->relations != NULL && (flag & IDWALK_READONLY)) {
 			/* Note that this is minor optimization, even in worst cases (like id being an object with lots of
@@ -346,7 +346,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_LI:
 			{
 				Library *lib = (Library *) id;
-				CALLBACK_INVOKE(lib->parent, IDWALK_NOP);
+				CALLBACK_INVOKE(lib->parent, IDWALK_CB_NOP);
 				break;
 			}
 			case ID_SCE:
@@ -356,39 +356,39 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				SceneRenderLayer *srl;
 				Base *base;
 
-				CALLBACK_INVOKE(scene->camera, IDWALK_NOP);
-				CALLBACK_INVOKE(scene->world, IDWALK_USER);
-				CALLBACK_INVOKE(scene->set, IDWALK_NOP);
-				CALLBACK_INVOKE(scene->clip, IDWALK_USER);
+				CALLBACK_INVOKE(scene->camera, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(scene->world, IDWALK_CB_USER);
+				CALLBACK_INVOKE(scene->set, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(scene->clip, IDWALK_CB_USER);
 				if (scene->nodetree) {
 					/* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
 					library_foreach_ID_as_subdata_link((ID **)&scene->nodetree, callback, user_data, flag, &data);
 				}
 				/* DO NOT handle scene->basact here, it's doubling with the loop over whole scene->base later,
 				 * since basact is just a pointer to one of those items. */
-				CALLBACK_INVOKE(scene->obedit, IDWALK_NOP);
+				CALLBACK_INVOKE(scene->obedit, IDWALK_CB_NOP);
 
 				for (srl = scene->r.layers.first; srl; srl = srl->next) {
 					FreestyleModuleConfig *fmc;
 					FreestyleLineSet *fls;
 
 					if (srl->mat_override) {
-						CALLBACK_INVOKE(srl->mat_override, IDWALK_USER);
+						CALLBACK_INVOKE(srl->mat_override, IDWALK_CB_USER);
 					}
 					if (srl->light_override) {
-						CALLBACK_INVOKE(srl->light_override, IDWALK_USER);
+						CALLBACK_INVOKE(srl->light_override, IDWALK_CB_USER);
 					}
 					for (fmc = srl->freestyleConfig.modules.first; fmc; fmc = fmc->next) {
 						if (fmc->script) {
-							CALLBACK_INVOKE(fmc->script, IDWALK_NOP);
+							CALLBACK_INVOKE(fmc->script, IDWALK_CB_NOP);
 						}
 					}
 					for (fls = srl->freestyleConfig.linesets.first; fls; fls = fls->next) {
 						if (fls->group) {
-							CALLBACK_INVOKE(fls->group, IDWALK_USER);
+							CALLBACK_INVOKE(fls->group, IDWALK_CB_USER);
 						}
 						if (fls->linestyle) {
-							CALLBACK_INVOKE(fls->linestyle, IDWALK_USER);
+							CALLBACK_INVOKE(fls->linestyle, IDWALK_CB_USER);
 						}
 					}
 				}
@@ -397,39 +397,39 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					Sequence *seq;
 					SEQP_BEGIN(scene->ed, seq)
 					{
-						CALLBACK_INVOKE(seq->scene, IDWALK_NOP);
-						CALLBACK_INVOKE(seq->scene_camera, IDWALK_NOP);
-						CALLBACK_INVOKE(seq->clip, IDWALK_USER);
-						CALLBACK_INVOKE(seq->mask, IDWALK_USER);
-						CALLBACK_INVOKE(seq->sound, IDWALK_USER);
+						CALLBACK_INVOKE(seq->scene, IDWALK_CB_NOP);
+						CALLBACK_INVOKE(seq->scene_camera, IDWALK_CB_NOP);
+						CALLBACK_INVOKE(seq->clip, IDWALK_CB_USER);
+						CALLBACK_INVOKE(seq->mask, IDWALK_CB_USER);
+						CALLBACK_INVOKE(seq->sound, IDWALK_CB_USER);
 						for (SequenceModifierData *smd = seq->modifiers.first; smd; smd = smd->next) {
-							CALLBACK_INVOKE(smd->mask_id, IDWALK_USER);
+							CALLBACK_INVOKE(smd->mask_id, IDWALK_CB_USER);
 						}
 					}
 					SEQ_END
 				}
 
-				CALLBACK_INVOKE(scene->gpd, IDWALK_USER);
+				CALLBACK_INVOKE(scene->gpd, IDWALK_CB_USER);
 
 				for (base = scene->base.first; base; base = base->next) {
-					CALLBACK_INVOKE(base->object, IDWALK_USER);
+					CALLBACK_INVOKE(base->object, IDWALK_CB_USER);
 				}
 
 				for (TimeMarker *marker = scene->markers.first; marker; marker = marker->next) {
-					CALLBACK_INVOKE(marker->camera, IDWALK_NOP);
+					CALLBACK_INVOKE(marker->camera, IDWALK_CB_NOP);
 				}
 
 				if (toolsett) {
-					CALLBACK_INVOKE(toolsett->skgen_template, IDWALK_NOP);
+					CALLBACK_INVOKE(toolsett->skgen_template, IDWALK_CB_NOP);
 
-					CALLBACK_INVOKE(toolsett->particle.scene, IDWALK_NOP);
-					CALLBACK_INVOKE(toolsett->particle.object, IDWALK_NOP);
-					CALLBACK_INVOKE(toolsett->particle.shape_object, IDWALK_NOP);
+					CALLBACK_INVOKE(toolsett->particle.scene, IDWALK_CB_NOP);
+					CALLBACK_INVOKE(toolsett->particle.object, IDWALK_CB_NOP);
+					CALLBACK_INVOKE(toolsett->particle.shape_object, IDWALK_CB_NOP);
 
 					library_foreach_paint(&data, &toolsett->imapaint.paint);
-					CALLBACK_INVOKE(toolsett->imapaint.stencil, IDWALK_USER);
-					CALLBACK_INVOKE(toolsett->imapaint.clone, IDWALK_USER);
-					CALLBACK_INVOKE(toolsett->imapaint.canvas, IDWALK_USER);
+					CALLBACK_INVOKE(toolsett->imapaint.stencil, IDWALK_CB_USER);
+					CALLBACK_INVOKE(toolsett->imapaint.clone, IDWALK_CB_USER);
+					CALLBACK_INVOKE(toolsett->imapaint.canvas, IDWALK_CB_USER);
 
 					if (toolsett->vpaint) {
 						library_foreach_paint(&data, &toolsett->vpaint->paint);
@@ -439,7 +439,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					}
 					if (toolsett->sculpt) {
 						library_foreach_paint(&data, &toolsett->sculpt->paint);
-						CALLBACK_INVOKE(toolsett->sculpt->gravity_object, IDWALK_NOP);
+						CALLBACK_INVOKE(toolsett->sculpt->gravity_object, IDWALK_CB_NOP);
 					}
 					if (toolsett->uvsculpt) {
 						library_foreach_paint(&data, &toolsett->uvsculpt->paint);
@@ -450,7 +450,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					BKE_rigidbody_world_id_loop(scene->rigidbody_world, library_foreach_rigidbodyworldSceneLooper, &data);
 				}
 
-				CALLBACK_INVOKE(scene->gm.dome.warptext, IDWALK_NOP);
+				CALLBACK_INVOKE(scene->gm.dome.warptext, IDWALK_CB_NOP);
 
 				break;
 			}
@@ -462,51 +462,51 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 
 				/* Object is special, proxies make things hard... */
 				const int data_cd_flag = data.cd_flag;
-				const int proxy_cd_flag = (object->proxy || object->proxy_group) ? IDWALK_INDIRECT_USAGE : 0;
+				const int proxy_cd_flag = (object->proxy || object->proxy_group) ? IDWALK_CB_INDIRECT_USAGE : 0;
 
 				/* object data special case */
 				data.cd_flag |= proxy_cd_flag;
 				if (object->type == OB_EMPTY) {
 					/* empty can have NULL or Image */
-					CALLBACK_INVOKE_ID(object->data, IDWALK_USER);
+					CALLBACK_INVOKE_ID(object->data, IDWALK_CB_USER);
 				}
 				else {
 					/* when set, this can't be NULL */
 					if (object->data) {
-						CALLBACK_INVOKE_ID(object->data, IDWALK_USER | IDWALK_NEVER_NULL);
+						CALLBACK_INVOKE_ID(object->data, IDWALK_CB_USER | IDWALK_CB_NEVER_NULL);
 					}
 				}
 				data.cd_flag = data_cd_flag;
 
-				CALLBACK_INVOKE(object->parent, IDWALK_NOP);
-				CALLBACK_INVOKE(object->track, IDWALK_NOP);
+				CALLBACK_INVOKE(object->parent, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(object->track, IDWALK_CB_NOP);
 				/* object->proxy is refcounted, but not object->proxy_group... *sigh* */
-				CALLBACK_INVOKE(object->proxy, IDWALK_USER);
-				CALLBACK_INVOKE(object->proxy_group, IDWALK_NOP);
+				CALLBACK_INVOKE(object->proxy, IDWALK_CB_USER);
+				CALLBACK_INVOKE(object->proxy_group, IDWALK_CB_NOP);
 
 				/* Special case!
 				 * Since this field is set/owned by 'user' of this ID (and not ID itself), it is only indirect usage
 				 * if proxy object is linked... Twisted. */
 				if (object->proxy_from) {
-					data.cd_flag = ID_IS_LINKED_DATABLOCK(object->proxy_from) ? IDWALK_INDIRECT_USAGE : 0;
+					data.cd_flag = ID_IS_LINKED_DATABLOCK(object->proxy_from) ? IDWALK_CB_INDIRECT_USAGE : 0;
 				}
-				CALLBACK_INVOKE(object->proxy_from, IDWALK_NOP);
+				CALLBACK_INVOKE(object->proxy_from, IDWALK_CB_NOP);
 				data.cd_flag = data_cd_flag;
 
-				CALLBACK_INVOKE(object->poselib, IDWALK_USER);
+				CALLBACK_INVOKE(object->poselib, IDWALK_CB_USER);
 
 				data.cd_flag |= proxy_cd_flag;
 				for (i = 0; i < object->totcol; i++) {
-					CALLBACK_INVOKE(object->mat[i], IDWALK_USER);
+					CALLBACK_INVOKE(object->mat[i], IDWALK_CB_USER);
 				}
 				data.cd_flag = data_cd_flag;
 
-				CALLBACK_INVOKE(object->gpd, IDWALK_USER);
-				CALLBACK_INVOKE(object->dup_group, IDWALK_USER);
+				CALLBACK_INVOKE(object->gpd, IDWALK_CB_USER);
+				CALLBACK_INVOKE(object->dup_group, IDWALK_CB_USER);
 
 				if (object->pd) {
-					CALLBACK_INVOKE(object->pd->tex, IDWALK_USER);
-					CALLBACK_INVOKE(object->pd->f_source, IDWALK_NOP);
+					CALLBACK_INVOKE(object->pd->tex, IDWALK_CB_USER);
+					CALLBACK_INVOKE(object->pd->f_source, IDWALK_CB_NOP);
 				}
 				/* Note that ob->effect is deprecated, so no need to handle it here. */
 
@@ -515,21 +515,21 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 
 					data.cd_flag |= proxy_cd_flag;
 					for (pchan = object->pose->chanbase.first; pchan; pchan = pchan->next) {
-						CALLBACK_INVOKE(pchan->custom, IDWALK_USER);
+						CALLBACK_INVOKE(pchan->custom, IDWALK_CB_USER);
 						BKE_constraints_id_loop(&pchan->constraints, library_foreach_constraintObjectLooper, &data);
 					}
 					data.cd_flag = data_cd_flag;
 				}
 
 				if (object->rigidbody_constraint) {
-					CALLBACK_INVOKE(object->rigidbody_constraint->ob1, IDWALK_NOP);
-					CALLBACK_INVOKE(object->rigidbody_constraint->ob2, IDWALK_NOP);
+					CALLBACK_INVOKE(object->rigidbody_constraint->ob1, IDWALK_CB_NOP);
+					CALLBACK_INVOKE(object->rigidbody_constraint->ob2, IDWALK_CB_NOP);
 				}
 
 				if (object->lodlevels.first) {
 					LodLevel *level;
 					for (level = object->lodlevels.first; level; level = level->next) {
-						CALLBACK_INVOKE(level->source, IDWALK_NOP);
+						CALLBACK_INVOKE(level->source, IDWALK_CB_NOP);
 					}
 				}
 
@@ -541,10 +541,10 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				}
 
 				if (object->soft) {
-					CALLBACK_INVOKE(object->soft->collision_group, IDWALK_NOP);
+					CALLBACK_INVOKE(object->soft->collision_group, IDWALK_CB_NOP);
 
 					if (object->soft->effector_weights) {
-						CALLBACK_INVOKE(object->soft->effector_weights->group, IDWALK_NOP);
+						CALLBACK_INVOKE(object->soft->effector_weights->group, IDWALK_CB_NOP);
 					}
 				}
 
@@ -557,10 +557,10 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_ME:
 			{
 				Mesh *mesh = (Mesh *) id;
-				CALLBACK_INVOKE(mesh->texcomesh, IDWALK_USER);
-				CALLBACK_INVOKE(mesh->key, IDWALK_USER);
+				CALLBACK_INVOKE(mesh->texcomesh, IDWALK_CB_USER);
+				CALLBACK_INVOKE(mesh->key, IDWALK_CB_USER);
 				for (i = 0; i < mesh->totcol; i++) {
-					CALLBACK_INVOKE(mesh->mat[i], IDWALK_USER);
+					CALLBACK_INVOKE(mesh->mat[i], IDWALK_CB_USER);
 				}
 
 				/* XXX Really not happy with this - probably texface should rather use some kind of
@@ -572,7 +572,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 							MTexPoly *txface = (MTexPoly *)mesh->pdata.layers[i].data;
 
 							for (int j = 0; j < mesh->totpoly; j++, txface++) {
-								CALLBACK_INVOKE(txface->tpage, IDWALK_USER_ONE);
+								CALLBACK_INVOKE(txface->tpage, IDWALK_CB_USER_ONE);
 							}
 						}
 					}
@@ -582,7 +582,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 							MTFace *tface = (MTFace *)mesh->fdata.layers[i].data;
 
 							for (int j = 0; j < mesh->totface; j++, tface++) {
-								CALLBACK_INVOKE(tface->tpage, IDWALK_USER_ONE);
+								CALLBACK_INVOKE(tface->tpage, IDWALK_CB_USER_ONE);
 							}
 						}
 					}
@@ -593,17 +593,17 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_CU:
 			{
 				Curve *curve = (Curve *) id;
-				CALLBACK_INVOKE(curve->bevobj, IDWALK_NOP);
-				CALLBACK_INVOKE(curve->taperobj, IDWALK_NOP);
-				CALLBACK_INVOKE(curve->textoncurve, IDWALK_NOP);
-				CALLBACK_INVOKE(curve->key, IDWALK_USER);
+				CALLBACK_INVOKE(curve->bevobj, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(curve->taperobj, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(curve->textoncurve, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(curve->key, IDWALK_CB_USER);
 				for (i = 0; i < curve->totcol; i++) {
-					CALLBACK_INVOKE(curve->mat[i], IDWALK_USER);
+					CALLBACK_INVOKE(curve->mat[i], IDWALK_CB_USER);
 				}
-				CALLBACK_INVOKE(curve->vfont, IDWALK_USER);
-				CALLBACK_INVOKE(curve->vfontb, IDWALK_USER);
-				CALLBACK_INVOKE(curve->vfonti, IDWALK_USER);
-				CALLBACK_INVOKE(curve->vfontbi, IDWALK_USER);
+				CALLBACK_INVOKE(curve->vfont, IDWALK_CB_USER);
+				CALLBACK_INVOKE(curve->vfontb, IDWALK_CB_USER);
+				CALLBACK_INVOKE(curve->vfonti, IDWALK_CB_USER);
+				CALLBACK_INVOKE(curve->vfontbi, IDWALK_CB_USER);
 				break;
 			}
 
@@ -611,7 +611,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			{
 				MetaBall *metaball = (MetaBall *) id;
 				for (i = 0; i < metaball->totcol; i++) {
-					CALLBACK_INVOKE(metaball->mat[i], IDWALK_USER);
+					CALLBACK_INVOKE(metaball->mat[i], IDWALK_CB_USER);
 				}
 				break;
 			}
@@ -628,7 +628,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					/* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
 					library_foreach_ID_as_subdata_link((ID **)&material->nodetree, callback, user_data, flag, &data);
 				}
-				CALLBACK_INVOKE(material->group, IDWALK_USER);
+				CALLBACK_INVOKE(material->group, IDWALK_CB_USER);
 				break;
 			}
 
@@ -639,24 +639,24 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					/* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
 					library_foreach_ID_as_subdata_link((ID **)&texture->nodetree, callback, user_data, flag, &data);
 				}
-				CALLBACK_INVOKE(texture->ima, IDWALK_USER);
+				CALLBACK_INVOKE(texture->ima, IDWALK_CB_USER);
 				if (texture->env) {
-					CALLBACK_INVOKE(texture->env->object, IDWALK_NOP);
-					CALLBACK_INVOKE(texture->env->ima, IDWALK_USER);
+					CALLBACK_INVOKE(texture->env->object, IDWALK_CB_NOP);
+					CALLBACK_INVOKE(texture->env->ima, IDWALK_CB_USER);
 				}
 				if (texture->pd)
-					CALLBACK_INVOKE(texture->pd->object, IDWALK_NOP);
+					CALLBACK_INVOKE(texture->pd->object, IDWALK_CB_NOP);
 				if (texture->vd)
-					CALLBACK_INVOKE(texture->vd->object, IDWALK_NOP);
+					CALLBACK_INVOKE(texture->vd->object, IDWALK_CB_NOP);
 				if (texture->ot)
-					CALLBACK_INVOKE(texture->ot->object, IDWALK_NOP);
+					CALLBACK_INVOKE(texture->ot->object, IDWALK_CB_NOP);
 				break;
 			}
 
 			case ID_LT:
 			{
 				Lattice *lattice = (Lattice *) id;
-				CALLBACK_INVOKE(lattice->key, IDWALK_USER);
+				CALLBACK_INVOKE(lattice->key, IDWALK_CB_USER);
 				break;
 			}
 
@@ -678,7 +678,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_CA:
 			{
 				Camera *camera = (Camera *) id;
-				CALLBACK_INVOKE(camera->dof_ob, IDWALK_NOP);
+				CALLBACK_INVOKE(camera->dof_ob, IDWALK_CB_NOP);
 				break;
 			}
 
@@ -689,14 +689,14 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				 * (see also foreach_libblock_id_users_callback).
 				 */
 				Key *key = (Key *) id;
-				CALLBACK_INVOKE_ID(key->from, IDWALK_NOP);
+				CALLBACK_INVOKE_ID(key->from, IDWALK_CB_NOP);
 				break;
 			}
 
 			case ID_SCR:
 			{
 				bScreen *screen = (bScreen *) id;
-				CALLBACK_INVOKE(screen->scene, IDWALK_USER_ONE);
+				CALLBACK_INVOKE(screen->scene, IDWALK_CB_USER_ONE);
 				break;
 			}
 
@@ -718,7 +718,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_SPK:
 			{
 				Speaker *speaker = (Speaker *) id;
-				CALLBACK_INVOKE(speaker->sound, IDWALK_USER);
+				CALLBACK_INVOKE(speaker->sound, IDWALK_CB_USER);
 				break;
 			}
 
@@ -727,7 +727,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				Group *group = (Group *) id;
 				GroupObject *gob;
 				for (gob = group->gobject.first; gob; gob = gob->next) {
-					CALLBACK_INVOKE(gob->ob, IDWALK_USER_ONE);
+					CALLBACK_INVOKE(gob->ob, IDWALK_CB_USER_ONE);
 				}
 				break;
 			}
@@ -736,9 +736,9 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			{
 				bNodeTree *ntree = (bNodeTree *) id;
 				bNode *node;
-				CALLBACK_INVOKE(ntree->gpd, IDWALK_USER);
+				CALLBACK_INVOKE(ntree->gpd, IDWALK_CB_USER);
 				for (node = ntree->nodes.first; node; node = node->next) {
-					CALLBACK_INVOKE_ID(node->id, IDWALK_USER);
+					CALLBACK_INVOKE_ID(node->id, IDWALK_CB_USER);
 				}
 				break;
 			}
@@ -746,9 +746,9 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_BR:
 			{
 				Brush *brush = (Brush *) id;
-				CALLBACK_INVOKE(brush->toggle_brush, IDWALK_NOP);
-				CALLBACK_INVOKE(brush->clone.image, IDWALK_NOP);
-				CALLBACK_INVOKE(brush->paint_curve, IDWALK_USER);
+				CALLBACK_INVOKE(brush->toggle_brush, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(brush->clone.image, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(brush->paint_curve, IDWALK_CB_USER);
 				library_foreach_mtex(&data, &brush->mtex);
 				library_foreach_mtex(&data, &brush->mask_mtex);
 				break;
@@ -757,10 +757,10 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 			case ID_PA:
 			{
 				ParticleSettings *psett = (ParticleSettings *) id;
-				CALLBACK_INVOKE(psett->dup_group, IDWALK_NOP);
-				CALLBACK_INVOKE(psett->dup_ob, IDWALK_NOP);
-				CALLBACK_INVOKE(psett->bb_ob, IDWALK_NOP);
-				CALLBACK_INVOKE(psett->collision_group, IDWALK_NOP);
+				CALLBACK_INVOKE(psett->dup_group, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(psett->dup_ob, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(psett->bb_ob, IDWALK_CB_NOP);
+				CALLBACK_INVOKE(psett->collision_group, IDWALK_CB_NOP);
 
 				for (i = 0; i < MAX_MTEX; i++) {
 					if (psett->mtex[i]) {
@@ -769,16 +769,16 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				}
 
 				if (psett->effector_weights) {
-					CALLBACK_INVOKE(psett->effector_weights->group, IDWALK_NOP);
+					CALLBACK_INVOKE(psett->effector_weights->group, IDWALK_CB_NOP);
 				}
 
 				if (psett->pd) {
-					CALLBACK_INVOKE(psett->pd->tex, IDWALK_USER);
-					CALLBACK_INVOKE(psett->pd->f_source, IDWALK_NOP);
+					CALLBACK_INVOKE(psett->pd->tex, IDWALK_CB_USER);
+					CALLBACK_INVOKE(psett->pd->f_source, IDWALK_CB_NOP);
 				}
 				if (psett->pd2) {
-					CALLBACK_INVOKE(psett->pd2->tex, IDWALK_USER);
-					CALLBACK_INVOKE(psett->pd2->f_source, IDWALK_NOP);
+					CALLBACK_INVOKE(psett->pd2->tex, IDWALK_CB_USER);
+					CALLBACK_INVOKE(psett->pd2->f_source, IDWALK_CB_NOP);
 				}
 
 				if (psett->boids) {
@@ -789,11 +789,11 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 						for (rule = state->rules.first; rule; rule = rule->next) {
 							if (rule->type == eBoidRuleType_Avoid) {
 								BoidRuleGoalAvoid *gabr = (BoidRuleGoalAvoid *)rule;
-								CALLBACK_INVOKE(gabr->ob, IDWALK_NOP);
+								CALLBACK_INVOKE(gabr->ob, IDWALK_CB_NOP);
 							}
 							else if (rule->type == eBoidRuleType_FollowLeader) {
 								BoidRuleFollowLeader *flbr = (BoidRuleFollowLeader *)rule;
-								CALLBACK_INVOKE(flbr->ob, IDWALK_NOP);
+								CALLBACK_INVOKE(flbr->ob, IDWALK_CB_NOP);
 							}
 						}
 					}
@@ -809,19 +809,19 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				MovieTrackingTrack *track;
 				MovieTrackingPlaneTrack *plane_track;
 
-				CALLBACK_INVOKE(clip->gpd, IDWALK_USER);
+				CALLBACK_INVOKE(clip->gpd, IDWALK_CB_USER);
 
 				for (track = tracking->tracks.first; track; track = track->next) {
-					CALLBACK_INVOKE(track->gpd, IDWALK_USER);
+					CALLBACK_INVOKE(track->gpd, IDWALK_CB_USER);
 				}
 				for (object = tracking->objects.first; object; object = object->next) {
 					for (track = object->tracks.first; track; track = track->next) {
-						CALLBACK_INVOKE(track->gpd, IDWALK_USER);
+						CALLBACK_INVOKE(track->gpd, IDWALK_CB_USER);
 					}
 				}
 
 				for (plane_track = tracking->plane_tracks.first; plane_track; plane_track = plane_track->next) {
-					CALLBACK_INVOKE(plane_track->image, IDWALK_USER);
+					CALLBACK_INVOKE(plane_track->image, IDWALK_CB_USER);
 				}
 				break;
 			}
@@ -836,7 +836,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					for (mask_spline = mask_layer->splines.first; mask_spline; mask_spline = mask_spline->next) {
 						for (i = 0; i < mask_spline->tot_point; i++) {
 							MaskSplinePoint *point = &mask_spline->points[i];
-							CALLBACK_INVOKE_ID(point->parent.id, IDWALK_USER);
+							CALLBACK_INVOKE_ID(point->parent.id, IDWALK_CB_USER);
 						}
 					}
 				}
@@ -861,7 +861,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
 						LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)lsm;
 						if (p->target) {
-							CALLBACK_INVOKE(p->target, IDWALK_NOP);
+							CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
 						}
 					}
 				}
@@ -869,7 +869,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
 						LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)lsm;
 						if (p->target) {
-							CALLBACK_INVOKE(p->target, IDWALK_NOP);
+							CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
 						}
 					}
 				}
@@ -877,7 +877,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 					if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
 						LineStyleThicknessModifier_DistanceFromObject *p = (LineStyleThicknessModifier_DistanceFromObject *)lsm;
 						if (p->target) {
-							CALLBACK_INVOKE(p->target, IDWALK_NOP);
+							CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
 						}
 					}
 				}
@@ -888,7 +888,7 @@ void BKE_library_foreach_ID_link(Main *bmain, ID *id, LibraryIDLinkCallback call
 				bAction *act = (bAction *) id;
 
 				for (TimeMarker *marker = act->markers.first; marker; marker = marker->next) {
-					CALLBACK_INVOKE(marker->camera, IDWALK_NOP);
+					CALLBACK_INVOKE(marker->camera, IDWALK_CB_NOP);
 				}
 				break;
 			}
@@ -931,11 +931,11 @@ FOREACH_FINALIZE:
  */
 void BKE_library_update_ID_link_user(ID *id_dst, ID *id_src, const int cd_flag)
 {
-	if (cd_flag & IDWALK_USER) {
+	if (cd_flag & IDWALK_CB_USER) {
 		id_us_min(id_src);
 		id_us_plus(id_dst);
 	}
-	else if (cd_flag & IDWALK_USER_ONE) {
+	else if (cd_flag & IDWALK_CB_USER_ONE) {
 		id_us_ensure_real(id_dst);
 	}
 }
@@ -1069,7 +1069,7 @@ static int foreach_libblock_id_users_callback(void *user_data, ID *self_id, ID *
 				   (iter->id->tag & LIB_TAG_EXTRAUSER) ? 1 : 0, (iter->id->tag & LIB_TAG_EXTRAUSER_SET) ? 1 : 0,
 				   (cb_flag & IDWALK_INDIRECT_USAGE) ? 1 : 0);
 #endif
-			if (cb_flag & IDWALK_INDIRECT_USAGE) {
+			if (cb_flag & IDWALK_CB_INDIRECT_USAGE) {
 				iter->count_indirect++;
 			}
 			else {
diff --git a/source/blender/blenkernel/intern/library_remap.c b/source/blender/blenkernel/intern/library_remap.c
index ff66c37a09b..91896ebdc66 100644
--- a/source/blender/blenkernel/intern/library_remap.c
+++ b/source/blender/blenkernel/intern/library_remap.c
@@ -158,7 +158,7 @@ enum {
 
 static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id_p, int cb_flag)
 {
-	if (cb_flag & IDWALK_PRIVATE) {
+	if (cb_flag & IDWALK_CB_PRIVATE) {
 		return IDWALK_RET_NOP;
 	}
 
@@ -173,14 +173,14 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
 	}
 
 	if (*id_p && (*id_p == old_id)) {
-		const bool is_indirect = (cb_flag & IDWALK_INDIRECT_USAGE) != 0;
+		const bool is_indirect = (cb_flag & IDWALK_CB_INDIRECT_USAGE) != 0;
 		const bool skip_indirect = (id_remap_data->flag & ID_REMAP_SKIP_INDIRECT_USAGE) != 0;
 		/* Note: proxy usage implies LIB_TAG_EXTERN, so on this aspect it is direct,
 		 *       on the other hand since they get reset to lib data on file open/reload it is indirect too...
 		 *       Edit Mode is also a 'skip direct' case. */
 		const bool is_obj = (GS(id->name) == ID_OB);
 		const bool is_obj_editmode = (is_obj && BKE_object_is_in_editmode((Object *)id));
-		const bool is_never_null = ((cb_flag & IDWALK_NEVER_NULL) && (new_id == NULL) &&
+		const bool is_never_null = ((cb_flag & IDWALK_CB_NEVER_NULL) && (new_id == NULL) &&
 		                            (id_remap_data->flag & ID_REMAP_FORCE_NEVER_NULL_USAGE) == 0);
 		const bool skip_never_null = (id_remap_data->flag & ID_REMAP_SKIP_NEVER_NULL_USAGE) != 0;
 
@@ -189,7 +189,7 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
 		       id->name, old_id->name, old_id, new_id ? new_id->name : "<NONE>", new_id, skip_indirect);
 #endif
 
-		if ((id_remap_data->flag & ID_REMAP_FLAG_NEVER_NULL_USAGE) && (cb_flag & IDWALK_NEVER_NULL)) {
+		if ((id_remap_data->flag & ID_REMAP_FLAG_NEVER_NULL_USAGE) && (cb_flag & IDWALK_CB_NEVER_NULL)) {
 			id->tag |= LIB_TAG_DOIT;
 		}
 
@@ -207,10 +207,10 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
 			else {
 				BLI_assert(0);
 			}
-			if (cb_flag & IDWALK_USER) {
+			if (cb_flag & IDWALK_CB_USER) {
 				id_remap_data->skipped_refcounted++;
 			}
-			else if (cb_flag & IDWALK_USER_ONE) {
+			else if (cb_flag & IDWALK_CB_USER_ONE) {
 				/* No need to count number of times this happens, just a flag is enough. */
 				id_remap_data->status |= ID_REMAP_IS_USER_ONE_SKIPPED;
 			}
@@ -220,13 +220,13 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
 				*id_p = new_id;
 				DAG_id_tag_update_ex(id_remap_data->bmain, id_self, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 			}
-			if (cb_flag & IDWALK_USER) {
+			if (cb_flag & IDWALK_CB_USER) {
 				id_us_min(old_id);
 				/* We do not want to handle LIB_TAG_INDIRECT/LIB_TAG_EXTERN here. */
 				if (new_id)
 					new_id->us++;
 			}
-			else if (cb_flag & IDWALK_USER_ONE) {
+			else if (cb_flag & IDWALK_CB_USER_ONE) {
 				id_us_ensure_real(new_id);
 				/* We cannot affect old_id->us directly, LIB_TAG_EXTRAUSER(_SET) are assumed to be set as needed,
 				 * that extra user is processed in final handling... */
@@ -691,7 +691,7 @@ void BKE_libblock_relink_ex(
 
 static int id_relink_to_newid_looper(void *UNUSED(user_data), ID *UNUSED(self_id), ID **id_pointer, const int cd_flag)
 {
-	if (cd_flag & IDWALK_PRIVATE) {
+	if (cd_flag & IDWALK_CB_PRIVATE) {
 		return IDWALK_RET_NOP;
 	}
 
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index ee435051151..943dc781246 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -4328,12 +4328,12 @@ void BKE_particlesystem_id_loop(ParticleSystem *psys, ParticleSystemIDFunc func,
 {
 	ParticleTarget *pt;
 
-	func(psys, (ID **)&psys->part, userdata, IDWALK_USER | IDWALK_NEVER_NULL);
-	func(psys, (ID **)&psys->target_ob, userdata, IDWALK_NOP);
-	func(psys, (ID **)&psys->parent, userdata, IDWALK_NOP);
+	func(psys, (ID **)&psys->part, userdata, IDWALK_CB_USER | IDWALK_CB_NEVER_NULL);
+	func(psys, (ID **)&psys->target_ob, userdata, IDWALK_CB_NOP);
+	func(psys, (ID **)&psys->parent, userdata, IDWALK_CB_NOP);
 
 	for (pt = psys->targets.first; pt; pt = pt->next) {
-		func(psys, (ID **)&pt->ob, userdata, IDWALK_NOP);
+		func(psys, (ID **)&pt->ob, userdata, IDWALK_CB_NOP);
 	}
 
 	/* Even though psys->part should never be NULL, this can happen as an exception during deletion.
@@ -4343,7 +4343,7 @@ void BKE_particlesystem_id_loop(ParticleSystem *psys, ParticleSystemIDFunc func,
 		int p;
 
 		for (p = 0, pa = psys->particles; p < psys->totpart; p++, pa++) {
-			func(psys, (ID **)&pa->boid->ground, userdata, IDWALK_NOP);
+			func(psys, (ID **)&pa->boid->ground, userdata, IDWALK_CB_NOP);
 		}
 	}
 }
diff --git a/source/blender/blenkernel/intern/rigidbody.c b/source/blender/blenkernel/intern/rigidbody.c
index b5f34a29ebb..5353cc26295 100644
--- a/source/blender/blenkernel/intern/rigidbody.c
+++ b/source/blender/blenkernel/intern/rigidbody.c
@@ -974,14 +974,14 @@ void BKE_rigidbody_world_groups_relink(RigidBodyWorld *rbw)
 
 void BKE_rigidbody_world_id_loop(RigidBodyWorld *rbw, RigidbodyWorldIDFunc func, void *userdata)
 {
-	func(rbw, (ID **)&rbw->group, userdata, IDWALK_NOP);
-	func(rbw, (ID **)&rbw->constraints, userdata, IDWALK_NOP);
-	func(rbw, (ID **)&rbw->effector_weights->group, userdata, IDWALK_NOP);
+	func(rbw, (ID **)&rbw->group, userdata, IDWALK_CB_NOP);
+	func(rbw, (ID **)&rbw->constraints, userdata, IDWALK_CB_NOP);
+	func(rbw, (ID **)&rbw->effector_weights->group, userdata, IDWALK_CB_NOP);
 
 	if (rbw->objects) {
 		int i;
 		for (i = 0; i < rbw->numbodies; i++) {
-			func(rbw, (ID **)&rbw->objects[i], userdata, IDWALK_NOP);
+			func(rbw, (ID **)&rbw->objects[i], userdata, IDWALK_CB_NOP);
 		}
 	}
 }
diff --git a/source/blender/blenkernel/intern/sca.c b/source/blender/blenkernel/intern/sca.c
index fa221348932..7920d8b5696 100644
--- a/source/blender/blenkernel/intern/sca.c
+++ b/source/blender/blenkernel/intern/sca.c
@@ -992,19 +992,19 @@ void BKE_sca_sensors_id_loop(ListBase *senslist, SCASensorIDFunc func, void *use
 	bSensor *sensor;
 
 	for (sensor = senslist->first; sensor; sensor = sensor->next) {
-		func(sensor, (ID **)&sensor->ob, userdata, IDWALK_NOP);
+		func(sensor, (ID **)&sensor->ob, userdata, IDWALK_CB_NOP);
 
 		switch (sensor->type) {
 			case SENS_TOUCH:  /* DEPRECATED */
 			{
 				bTouchSensor *ts = sensor->data;
-				func(sensor, (ID **)&ts->ma, userdata, IDWALK_NOP);
+				func(sensor, (ID **)&ts->ma, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case SENS_MESSAGE:
 			{
 				bMessageSensor *ms = sensor->data;
-				func(sensor, (ID **)&ms->fromObject, userdata, IDWALK_NOP);
+				func(sensor, (ID **)&ms->fromObject, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case SENS_ALWAYS:
@@ -1035,7 +1035,7 @@ void BKE_sca_controllers_id_loop(ListBase *contlist, SCAControllerIDFunc func, v
 			case CONT_PYTHON:
 			{
 				bPythonCont *pc = controller->data;
-				func(controller, (ID **)&pc->text, userdata, IDWALK_NOP);
+				func(controller, (ID **)&pc->text, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case CONT_LOGIC_AND:
@@ -1056,89 +1056,89 @@ void BKE_sca_actuators_id_loop(ListBase *actlist, SCAActuatorIDFunc func, void *
 	bActuator *actuator;
 
 	for (actuator = actlist->first; actuator; actuator = actuator->next) {
-		func(actuator, (ID **)&actuator->ob, userdata, IDWALK_NOP);
+		func(actuator, (ID **)&actuator->ob, userdata, IDWALK_CB_NOP);
 
 		switch (actuator->type) {
 			case ACT_ADD_OBJECT:  /* DEPRECATED */
 			{
 				bAddObjectActuator *aoa = actuator->data;
-				func(actuator, (ID **)&aoa->ob, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&aoa->ob, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_ACTION:
 			{
 				bActionActuator *aa = actuator->data;
-				func(actuator, (ID **)&aa->act, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&aa->act, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_SOUND:
 			{
 				bSoundActuator *sa = actuator->data;
-				func(actuator, (ID **)&sa->sound, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&sa->sound, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_EDIT_OBJECT:
 			{
 				bEditObjectActuator *eoa = actuator->data;
-				func(actuator, (ID **)&eoa->ob, userdata, IDWALK_NOP);
-				func(actuator, (ID **)&eoa->me, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&eoa->ob, userdata, IDWALK_CB_NOP);
+				func(actuator, (ID **)&eoa->me, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_SCENE:
 			{
 				bSceneActuator *sa = actuator->data;
-				func(actuator, (ID **)&sa->scene, userdata, IDWALK_NOP);
-				func(actuator, (ID **)&sa->camera, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&sa->scene, userdata, IDWALK_CB_NOP);
+				func(actuator, (ID **)&sa->camera, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_PROPERTY:
 			{
 				bPropertyActuator *pa = actuator->data;
-				func(actuator, (ID **)&pa->ob, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&pa->ob, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_OBJECT:
 			{
 				bObjectActuator *oa = actuator->data;
-				func(actuator, (ID **)&oa->reference, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&oa->reference, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_CAMERA:
 			{
 				bCameraActuator *ca = actuator->data;
-				func(actuator, (ID **)&ca->ob, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&ca->ob, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_MESSAGE:
 			{
 				bMessageActuator *ma = actuator->data;
-				func(actuator, (ID **)&ma->toObject, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&ma->toObject, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_2DFILTER:
 			{
 				bTwoDFilterActuator *tdfa = actuator->data;
-				func(actuator, (ID **)&tdfa->text, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&tdfa->text, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_PARENT:
 			{
 				bParentActuator *pa = actuator->data;
-				func(actuator, (ID **)&pa->ob, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&pa->ob, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_ARMATURE:
 			{
 				bArmatureActuator *aa = actuator->data;
-				func(actuator, (ID **)&aa->target, userdata, IDWALK_NOP);
-				func(actuator, (ID **)&aa->subtarget, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&aa->target, userdata, IDWALK_CB_NOP);
+				func(actuator, (ID **)&aa->subtarget, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			case ACT_STEERING:
 			{
 				bSteeringActuator *sa = actuator->data;
-				func(actuator, (ID **)&sa->target, userdata, IDWALK_NOP);
-				func(actuator, (ID **)&sa->navmesh, userdata, IDWALK_NOP);
+				func(actuator, (ID **)&sa->target, userdata, IDWALK_CB_NOP);
+				func(actuator, (ID **)&sa->navmesh, userdata, IDWALK_CB_NOP);
 				break;
 			}
 			/* Note: some types seems to be non-implemented? ACT_LAMP, ACT_MATERIAL... */