Cleanup: Rename callback flags from library_query to `IDWALK_CB_...`
authorBastien Montagne <montagne29@wanadoo.fr>
Tue, 31 Jan 2017 08:47:59 +0000 (09:47 +0100)
committerBastien Montagne <montagne29@wanadoo.fr>
Tue, 31 Jan 2017 08:47:59 +0000 (09:47 +0100)
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.

38 files changed:
source/blender/blenkernel/BKE_library_query.h
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/library_query.c
source/blender/blenkernel/intern/library_remap.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/rigidbody.c
source/blender/blenkernel/intern/sca.c
source/blender/blenloader/intern/readfile.c
source/blender/modifiers/intern/MOD_armature.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_boolean.c
source/blender/modifiers/intern/MOD_cast.c
source/blender/modifiers/intern/MOD_cloth.c
source/blender/modifiers/intern/MOD_curve.c
source/blender/modifiers/intern/MOD_datatransfer.c
source/blender/modifiers/intern/MOD_displace.c
source/blender/modifiers/intern/MOD_dynamicpaint.c
source/blender/modifiers/intern/MOD_hook.c
source/blender/modifiers/intern/MOD_lattice.c
source/blender/modifiers/intern/MOD_mask.c
source/blender/modifiers/intern/MOD_meshdeform.c
source/blender/modifiers/intern/MOD_meshsequencecache.c
source/blender/modifiers/intern/MOD_mirror.c
source/blender/modifiers/intern/MOD_normal_edit.c
source/blender/modifiers/intern/MOD_particleinstance.c
source/blender/modifiers/intern/MOD_screw.c
source/blender/modifiers/intern/MOD_shrinkwrap.c
source/blender/modifiers/intern/MOD_simpledeform.c
source/blender/modifiers/intern/MOD_smoke.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/modifiers/intern/MOD_uvwarp.c
source/blender/modifiers/intern/MOD_warp.c
source/blender/modifiers/intern/MOD_wave.c
source/blender/modifiers/intern/MOD_weightvgedit.c
source/blender/modifiers/intern/MOD_weightvgmix.c
source/blender/modifiers/intern/MOD_weightvgproximity.c
source/blender/python/intern/bpy_rna_id_collection.c
source/blender/windowmanager/intern/wm_operators.c

index 693d5e9a28bbec96537012e37b66965f7edb2888..59b38aec3461a4fb91b920a90d2cac838c9b6de8 100644 (file)
@@ -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. */
 };
index daa8c6f5e5c2ba9615d76f767094e3bd447c726f..7350e014d4372368b3adc34c2c59d7cc36e4db2e 100644 (file)
@@ -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;
        }
 
index 03c4b80335036af5fbac8d37dfea8994eba6e912..9aaf2b24c5d57d2cbf53f0e0de7582637243928d 100644 (file)
@@ -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 {
index ff66c37a09b94074ff01e0983434ee545d4106f4..91896ebdc66d997a7fad7d08b098e96861a75d79 100644 (file)
@@ -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;
        }
 
index ee4350511518787766de6140acd8fc3635989c5d..943dc7812461703ecab0703ed1b172c8f787d87f 100644 (file)
@@ -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);
                }
        }
 }
index b5f34a29ebbc4bfe62c88aa5b17151d3aa1ef9ab..5353cc26295046a9d1b1a225173b04f581d350af 100644 (file)
@@ -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);
                }
        }
 }
index fa2213489326693f9fa40ea30feaf992ddc9c936..7920d8b56967094c965ea29267f9899309fee125 100644 (file)
@@ -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... */
index dce079ff20d17b38f4b21d538bf9a38ac5b13c81..3e480d8e457ed060300a1977a03eae39ed2b2fd9 100644 (file)
@@ -4713,7 +4713,7 @@ static void lib_link_modifiers__linkModifiers(
        FileData *fd = userData;
 
        *idpoin = newlibadr(fd, ob->id.lib, *idpoin);
-       if (*idpoin != NULL && (cd_flag & IDWALK_USER) != 0) {
+       if (*idpoin != NULL && (cd_flag & IDWALK_CB_USER) != 0) {
                id_us_plus_no_lib(*idpoin);
        }
 }
index 567505ea45ddfcdc1350bd34f6875b4c4dec8d67..2400dbcb89815d58a3bb2cf8a7bd1dd423030468 100644 (file)
@@ -96,7 +96,7 @@ static void foreachObjectLink(
 {
        ArmatureModifierData *amd = (ArmatureModifierData *) md;
 
-       walk(userData, ob, &amd->object, IDWALK_NOP);
+       walk(userData, ob, &amd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index b049457e6401beb345e043ede385f5421b40e218..2b739dc00931c64b08b86d0e0af62f597513068c 100644 (file)
@@ -95,10 +95,10 @@ static void foreachObjectLink(
 {
        ArrayModifierData *amd = (ArrayModifierData *) md;
 
-       walk(userData, ob, &amd->start_cap, IDWALK_NOP);
-       walk(userData, ob, &amd->end_cap, IDWALK_NOP);
-       walk(userData, ob, &amd->curve_ob, IDWALK_NOP);
-       walk(userData, ob, &amd->offset_ob, IDWALK_NOP);
+       walk(userData, ob, &amd->start_cap, IDWALK_CB_NOP);
+       walk(userData, ob, &amd->end_cap, IDWALK_CB_NOP);
+       walk(userData, ob, &amd->curve_ob, IDWALK_CB_NOP);
+       walk(userData, ob, &amd->offset_ob, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index da0f5aa3923742f74182ea1934c38c7ba71ada25..f828bc688577184befb54d5e1a5b17db0b489fa5 100644 (file)
@@ -101,7 +101,7 @@ static void foreachObjectLink(
 {
        BooleanModifierData *bmd = (BooleanModifierData *) md;
 
-       walk(userData, ob, &bmd->object, IDWALK_NOP);
+       walk(userData, ob, &bmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 2fe27730370a73fc7c53e24d27c9e80f20c2bab1..ddcf1852dc6395d9e5ee22a192f02db8d27d64ee 100644 (file)
@@ -102,7 +102,7 @@ static void foreachObjectLink(
 {
        CastModifierData *cmd = (CastModifierData *) md;
 
-       walk(userData, ob, &cmd->object, IDWALK_NOP);
+       walk(userData, ob, &cmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index ac75b4dbee910a65fd70e92331a89b849cf4041f..e8c39770a14ba75f6bb5766332efda1fe9ce8d48 100644 (file)
@@ -234,11 +234,11 @@ static void foreachIDLink(ModifierData *md, Object *ob,
        ClothModifierData *clmd = (ClothModifierData *) md;
 
        if (clmd->coll_parms) {
-               walk(userData, ob, (ID **)&clmd->coll_parms->group, IDWALK_NOP);
+               walk(userData, ob, (ID **)&clmd->coll_parms->group, IDWALK_CB_NOP);
        }
 
        if (clmd->sim_parms && clmd->sim_parms->effector_weights) {
-               walk(userData, ob, (ID **)&clmd->sim_parms->effector_weights->group, IDWALK_NOP);
+               walk(userData, ob, (ID **)&clmd->sim_parms->effector_weights->group, IDWALK_CB_NOP);
        }
 }
 
index 9bc96e593fd000cdff487468490146bb18420c8d..09444476bfe2bfb4c45958bfc7e7d27563394d7c 100644 (file)
@@ -89,7 +89,7 @@ static void foreachObjectLink(
 {
        CurveModifierData *cmd = (CurveModifierData *) md;
 
-       walk(userData, ob, &cmd->object, IDWALK_NOP);
+       walk(userData, ob, &cmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 1e69ba87f9c406ee961ba456d95aca3a16768451..a22108936024b1cba730bc20bf867b49221b59a1 100644 (file)
@@ -124,7 +124,7 @@ static void foreachObjectLink(
         ObjectWalkFunc walk, void *userData)
 {
        DataTransferModifierData *dtmd = (DataTransferModifierData *) md;
-       walk(userData, ob, &dtmd->ob_source, IDWALK_NOP);
+       walk(userData, ob, &dtmd->ob_source, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 059e096ddb4b3479ebf1eb86d9f554605b0cb4fe..08d118a202645741cfa721cec08fc98ffe4837cd 100644 (file)
@@ -132,7 +132,7 @@ static void foreachObjectLink(ModifierData *md, Object *ob,
 {
        DisplaceModifierData *dmd = (DisplaceModifierData *) md;
 
-       walk(userData, ob, &dmd->map_object, IDWALK_NOP);
+       walk(userData, ob, &dmd->map_object, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob,
@@ -140,7 +140,7 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 {
        DisplaceModifierData *dmd = (DisplaceModifierData *) md;
 
-       walk(userData, ob, (ID **)&dmd->texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&dmd->texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index b49a407da780346530d491fb233eebcdec3f1476..05068b9b59773a87ab172769601089d9e7b10b04 100644 (file)
@@ -181,15 +181,15 @@ static void foreachIDLink(ModifierData *md, Object *ob,
                DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
 
                for (; surface; surface = surface->next) {
-                       walk(userData, ob, (ID **)&surface->brush_group, IDWALK_NOP);
-                       walk(userData, ob, (ID **)&surface->init_texture, IDWALK_USER);
+                       walk(userData, ob, (ID **)&surface->brush_group, IDWALK_CB_NOP);
+                       walk(userData, ob, (ID **)&surface->init_texture, IDWALK_CB_USER);
                        if (surface->effector_weights) {
-                               walk(userData, ob, (ID **)&surface->effector_weights->group, IDWALK_NOP);
+                               walk(userData, ob, (ID **)&surface->effector_weights->group, IDWALK_CB_NOP);
                        }
                }
        }
        if (pmd->brush) {
-               walk(userData, ob, (ID **)&pmd->brush->mat, IDWALK_USER);
+               walk(userData, ob, (ID **)&pmd->brush->mat, IDWALK_CB_USER);
        }
 }
 
index 9186b10d8ca4a833a28cdf45d1bc87dd5dc90d51..56c494ff3c0287a4e169dad65591f5a1829eaec5 100644 (file)
@@ -115,7 +115,7 @@ static void foreachObjectLink(
 {
        HookModifierData *hmd = (HookModifierData *) md;
 
-       walk(userData, ob, &hmd->object, IDWALK_NOP);
+       walk(userData, ob, &hmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 7d4701e3ef27918b299e402e89a55ea6a92ee282..dc246084dca2737b8b7408d33f4b2c73ad69bf09 100644 (file)
@@ -88,7 +88,7 @@ static void foreachObjectLink(
 {
        LatticeModifierData *lmd = (LatticeModifierData *) md;
 
-       walk(userData, ob, &lmd->object, IDWALK_NOP);
+       walk(userData, ob, &lmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 5e01a20d93b70334477769ed6e5109b3ee3a5d01..dcc7fe4d4f19dee76f026de6a4a7b34814695b04 100644 (file)
@@ -74,7 +74,7 @@ static void foreachObjectLink(
         ObjectWalkFunc walk, void *userData)
 {
        MaskModifierData *mmd = (MaskModifierData *)md;
-       walk(userData, ob, &mmd->ob_arm, IDWALK_NOP);
+       walk(userData, ob, &mmd->ob_arm, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 3f34319d25f81938c5f1cff40dc0a5d3b7f3dec3..406ce398ee057041782e191ff3e2e059b10dc207 100644 (file)
@@ -119,7 +119,7 @@ static void foreachObjectLink(
 {
        MeshDeformModifierData *mmd = (MeshDeformModifierData *) md;
 
-       walk(userData, ob, &mmd->object, IDWALK_NOP);
+       walk(userData, ob, &mmd->object, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 2f00a7c71b09129dbbcb2f7de0c3ffd3373e38c8..d956763fc1fc8df9a74f4385a4671dade79aab4d 100644 (file)
@@ -151,7 +151,7 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 {
        MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
 
-       walk(userData, ob, (ID **)&mcmd->cache_file, IDWALK_USER);
+       walk(userData, ob, (ID **)&mcmd->cache_file, IDWALK_CB_USER);
 }
 
 
index 88facb22e0eecfcffeecd00838e72ace12ad394e..dd127cc255c3f3560d122cd95ee8fb1ce209ace3 100644 (file)
@@ -72,7 +72,7 @@ static void foreachObjectLink(
 {
        MirrorModifierData *mmd = (MirrorModifierData *) md;
 
-       walk(userData, ob, &mmd->mirror_ob, IDWALK_NOP);
+       walk(userData, ob, &mmd->mirror_ob, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index 454c97451a8afe82c3a5ffeb8037acb1945a9f10..20eae751ca415d828037ee3dcf603abec5086741 100644 (file)
@@ -501,7 +501,7 @@ static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk,
 {
        NormalEditModifierData *enmd = (NormalEditModifierData *) md;
 
-       walk(userData, ob, &enmd->target, IDWALK_NOP);
+       walk(userData, ob, &enmd->target, IDWALK_CB_NOP);
 }
 
 static bool isDisabled(ModifierData *md, int UNUSED(useRenderParams))
index 4e78e758dc3568b8f7af629c5ccd61716b85057d..fbf5a9582543ff6c91bb94e070311decae8aa9e2 100644 (file)
@@ -145,7 +145,7 @@ static void foreachObjectLink(ModifierData *md, Object *ob,
 {
        ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *) md;
 
-       walk(userData, ob, &pimd->ob, IDWALK_NOP);
+       walk(userData, ob, &pimd->ob, IDWALK_CB_NOP);
 }
 
 static int particle_skip(ParticleInstanceModifierData *pimd, ParticleSystem *psys, int p)
index 290e19736bb8d4c34d19f330320d22e958c9bd1c..87859cd240aebc9ee61a501c8ecf4c7d12badf85 100644 (file)
@@ -1093,7 +1093,7 @@ static void foreachObjectLink(
 {
        ScrewModifierData *ltmd = (ScrewModifierData *) md;
 
-       walk(userData, ob, &ltmd->ob_axis, IDWALK_NOP);
+       walk(userData, ob, &ltmd->ob_axis, IDWALK_CB_NOP);
 }
 
 ModifierTypeInfo modifierType_Screw = {
index 633311c2b870f10683f26da71d712d185ea5ce61..a14747bc153b77ae5665739343fa1ba2a64aa4c5 100644 (file)
@@ -101,8 +101,8 @@ static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk,
 {
        ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *) md;
 
-       walk(userData, ob, &smd->target, IDWALK_NOP);
-       walk(userData, ob, &smd->auxTarget, IDWALK_NOP);
+       walk(userData, ob, &smd->target, IDWALK_CB_NOP);
+       walk(userData, ob, &smd->auxTarget, IDWALK_CB_NOP);
 }
 
 static void deformVerts(ModifierData *md, Object *ob,
index c68f26511917af16bc0d737102c4b1949a81f150..379eaea5b0c521007e8950af854e814d2f3107fd 100644 (file)
@@ -290,7 +290,7 @@ static void foreachObjectLink(
         ObjectWalkFunc walk, void *userData)
 {
        SimpleDeformModifierData *smd  = (SimpleDeformModifierData *)md;
-       walk(userData, ob, &smd->origin, IDWALK_NOP);
+       walk(userData, ob, &smd->origin, IDWALK_CB_NOP);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest,
index a7b23ae24036701888c767c26158fd614919633b..c105a3ab3a7e0dd9c6f723c7fd0810bed58eeb33 100644 (file)
@@ -174,17 +174,17 @@ static void foreachIDLink(ModifierData *md, Object *ob,
        SmokeModifierData *smd = (SmokeModifierData *) md;
 
        if (smd->type == MOD_SMOKE_TYPE_DOMAIN && smd->domain) {
-               walk(userData, ob, (ID **)&smd->domain->coll_group, IDWALK_NOP);
-               walk(userData, ob, (ID **)&smd->domain->fluid_group, IDWALK_NOP);
-               walk(userData, ob, (ID **)&smd->domain->eff_group, IDWALK_NOP);
+               walk(userData, ob, (ID **)&smd->domain->coll_group, IDWALK_CB_NOP);
+               walk(userData, ob, (ID **)&smd->domain->fluid_group, IDWALK_CB_NOP);
+               walk(userData, ob, (ID **)&smd->domain->eff_group, IDWALK_CB_NOP);
 
                if (smd->domain->effector_weights) {
-                       walk(userData, ob, (ID **)&smd->domain->effector_weights->group, IDWALK_NOP);
+                       walk(userData, ob, (ID **)&smd->domain->effector_weights->group, IDWALK_CB_NOP);
                }
        }
 
        if (smd->type == MOD_SMOKE_TYPE_FLOW && smd->flow) {
-               walk(userData, ob, (ID **)&smd->flow->noise_texture, IDWALK_USER);
+               walk(userData, ob, (ID **)&smd->flow->noise_texture, IDWALK_CB_USER);
        }
 }
 
index fb7668d16e0dec21706f3059e7734650cde0d258..78dc1ea8bcb2968b821c2ceee96ade28f7f62cb5 100644 (file)
@@ -92,7 +92,7 @@ static void foreachObjectLink(ModifierData *md, Object *ob,
        int i;
 
        for (i = 0; i < MOD_UVPROJECT_MAXPROJECTORS; ++i)
-               walk(userData, ob, &umd->projectors[i], IDWALK_NOP);
+               walk(userData, ob, &umd->projectors[i], IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob,
@@ -100,7 +100,7 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 {
        UVProjectModifierData *umd = (UVProjectModifierData *) md;
 
-       walk(userData, ob, (ID **)&umd->image, IDWALK_USER);
+       walk(userData, ob, (ID **)&umd->image, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index 89994c3ae22392ebd1da40db83a8d3342d823d6b..b3fc3842635c2c865be38d1867a526a0cc9b32cd 100644 (file)
@@ -221,8 +221,8 @@ static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk,
 {
        UVWarpModifierData *umd = (UVWarpModifierData *) md;
 
-       walk(userData, ob, &umd->object_dst, IDWALK_NOP);
-       walk(userData, ob, &umd->object_src, IDWALK_NOP);
+       walk(userData, ob, &umd->object_dst, IDWALK_CB_NOP);
+       walk(userData, ob, &umd->object_src, IDWALK_CB_NOP);
 }
 
 static void uv_warp_deps_object_bone(DagForest *forest, DagNode *obNode,
index b38de140a91c63ca7aa77cb92f9d8430a9a29113..92d44257d03f2ceda352b978b408eb2d8eda0ea0 100644 (file)
@@ -116,16 +116,16 @@ static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk,
 {
        WarpModifierData *wmd = (WarpModifierData *) md;
 
-       walk(userData, ob, &wmd->object_from, IDWALK_NOP);
-       walk(userData, ob, &wmd->object_to, IDWALK_NOP);
-       walk(userData, ob, &wmd->map_object, IDWALK_NOP);
+       walk(userData, ob, &wmd->object_from, IDWALK_CB_NOP);
+       walk(userData, ob, &wmd->object_to, IDWALK_CB_NOP);
+       walk(userData, ob, &wmd->map_object, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
 {
        WarpModifierData *wmd = (WarpModifierData *) md;
 
-       walk(userData, ob, (ID **)&wmd->texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&wmd->texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index 683649ed1c01db3da8a0336ef3cdcd47af380843..f0c4940816e4d7055c1bcf9b07407714904f164c 100644 (file)
@@ -111,8 +111,8 @@ static void foreachObjectLink(
 {
        WaveModifierData *wmd = (WaveModifierData *) md;
 
-       walk(userData, ob, &wmd->objectcenter, IDWALK_NOP);
-       walk(userData, ob, &wmd->map_object, IDWALK_NOP);
+       walk(userData, ob, &wmd->objectcenter, IDWALK_CB_NOP);
+       walk(userData, ob, &wmd->map_object, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob,
@@ -120,7 +120,7 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 {
        WaveModifierData *wmd = (WaveModifierData *) md;
 
-       walk(userData, ob, (ID **)&wmd->texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&wmd->texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index 93567aed2c4147eb6c6fa17ae77aa5d5f9f41cba..2a822ac07b5e4d045b25e024eef3e10d8585afa9 100644 (file)
@@ -126,14 +126,14 @@ static bool dependsOnTime(ModifierData *md)
 static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk, void *userData)
 {
        WeightVGEditModifierData *wmd = (WeightVGEditModifierData *) md;
-       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_NOP);
+       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
 {
        WeightVGEditModifierData *wmd = (WeightVGEditModifierData *) md;
 
-       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index 170fbbed7f1a20c02efd7c3d6cc0f17d34b42b11..9bff7bf11f141affbf34970468851c8fc54832f9 100644 (file)
@@ -175,14 +175,14 @@ static bool dependsOnTime(ModifierData *md)
 static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk, void *userData)
 {
        WeightVGMixModifierData *wmd = (WeightVGMixModifierData *) md;
-       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_NOP);
+       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
 {
        WeightVGMixModifierData *wmd = (WeightVGMixModifierData *) md;
 
-       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index af59f11ba153631fc236ef21f72a1481faf18c34..2c87838aeab83e89fb8ed3b3e331b10533314b1c 100644 (file)
@@ -325,15 +325,15 @@ static bool dependsOnTime(ModifierData *md)
 static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk, void *userData)
 {
        WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *) md;
-       walk(userData, ob, &wmd->proximity_ob_target, IDWALK_NOP);
-       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_NOP);
+       walk(userData, ob, &wmd->proximity_ob_target, IDWALK_CB_NOP);
+       walk(userData, ob, &wmd->mask_tex_map_obj, IDWALK_CB_NOP);
 }
 
 static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
 {
        WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *) md;
 
-       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_USER);
+       walk(userData, ob, (ID **)&wmd->mask_texture, IDWALK_CB_USER);
 
        foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
index a7bd5afd4225c1d20ea84907573d6a6680f611ca..72705ffb3fb44e73e2627954d282445331a96524 100644 (file)
@@ -263,7 +263,7 @@ static PyObject *bpy_user_map(PyObject *UNUSED(self), PyObject *args, PyObject *
                        }
 
                        data_cb.id_curr = id;
-                       BKE_library_foreach_ID_link(NULL, id, foreach_libblock_id_user_map_callback, &data_cb, IDWALK_NOP);
+                       BKE_library_foreach_ID_link(NULL, id, foreach_libblock_id_user_map_callback, &data_cb, IDWALK_CB_NOP);
 
                        if (data_cb.py_id_curr) {
                                Py_DECREF(data_cb.py_id_curr);
index 682f4dc3b23950f692865877c5020b932e395568..a3f403e0bb34690e9b6b55bc9521127a4dc93759 100644 (file)
@@ -3912,7 +3912,7 @@ static void previews_id_ensure(bContext *C, Scene *scene, ID *id)
 
 static int previews_id_ensure_callback(void *userdata, ID *UNUSED(self_id), ID **idptr, int cd_flag)
 {
-       if (cd_flag & IDWALK_PRIVATE) {
+       if (cd_flag & IDWALK_CB_PRIVATE) {
                return IDWALK_RET_NOP;
        }