Cleanup: unused headers
[blender.git] / source / blender / blenkernel / intern / lib_query.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2014 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdlib.h>
25
26 #include "DNA_anim_types.h"
27 #include "DNA_armature_types.h"
28 #include "DNA_brush_types.h"
29 #include "DNA_camera_types.h"
30 #include "DNA_collection_types.h"
31 #include "DNA_constraint_types.h"
32 #include "DNA_gpencil_types.h"
33 #include "DNA_key_types.h"
34 #include "DNA_light_types.h"
35 #include "DNA_lattice_types.h"
36 #include "DNA_linestyle_types.h"
37 #include "DNA_material_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_meta_types.h"
40 #include "DNA_movieclip_types.h"
41 #include "DNA_mask_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_object_force_types.h"
44 #include "DNA_lightprobe_types.h"
45 #include "DNA_rigidbody_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_sequence_types.h"
48 #include "DNA_screen_types.h"
49 #include "DNA_speaker_types.h"
50 #include "DNA_sound_types.h"
51 #include "DNA_text_types.h"
52 #include "DNA_vfont_types.h"
53 #include "DNA_windowmanager_types.h"
54 #include "DNA_workspace_types.h"
55 #include "DNA_world_types.h"
56
57 #include "BLI_utildefines.h"
58 #include "BLI_ghash.h"
59 #include "BLI_linklist_stack.h"
60
61 #include "BKE_animsys.h"
62 #include "BKE_collection.h"
63 #include "BKE_constraint.h"
64 #include "BKE_fcurve.h"
65 #include "BKE_gpencil_modifier.h"
66 #include "BKE_idprop.h"
67 #include "BKE_lib_id.h"
68 #include "BKE_lib_query.h"
69 #include "BKE_main.h"
70 #include "BKE_modifier.h"
71 #include "BKE_node.h"
72 #include "BKE_particle.h"
73 #include "BKE_rigidbody.h"
74 #include "BKE_sequencer.h"
75 #include "BKE_shader_fx.h"
76 #include "BKE_workspace.h"
77
78 #define FOREACH_FINALIZE _finalize
79 #define FOREACH_FINALIZE_VOID \
80   if (0) { \
81     goto FOREACH_FINALIZE; \
82   } \
83   FOREACH_FINALIZE: \
84   ((void)0)
85
86 #define FOREACH_CALLBACK_INVOKE_ID_PP(_data, id_pp, _cb_flag) \
87   CHECK_TYPE(id_pp, ID **); \
88   if (!((_data)->status & IDWALK_STOP)) { \
89     const int _flag = (_data)->flag; \
90     ID *old_id = *(id_pp); \
91     const int callback_return = (_data)->callback((_data)->user_data, \
92                                                   (_data)->self_id, \
93                                                   id_pp, \
94                                                   (_cb_flag | (_data)->cb_flag) & \
95                                                       ~(_data)->cb_flag_clear); \
96     if (_flag & IDWALK_READONLY) { \
97       BLI_assert(*(id_pp) == old_id); \
98     } \
99     if (old_id && (_flag & IDWALK_RECURSE)) { \
100       if (BLI_gset_add((_data)->ids_handled, old_id)) { \
101         if (!(callback_return & IDWALK_RET_STOP_RECURSION)) { \
102           BLI_LINKSTACK_PUSH((_data)->ids_todo, old_id); \
103         } \
104       } \
105     } \
106     if (callback_return & IDWALK_RET_STOP_ITER) { \
107       (_data)->status |= IDWALK_STOP; \
108       goto FOREACH_FINALIZE; \
109     } \
110   } \
111   else { \
112     goto FOREACH_FINALIZE; \
113   } \
114   ((void)0)
115
116 #define FOREACH_CALLBACK_INVOKE_ID(_data, id, cb_flag) \
117   { \
118     CHECK_TYPE_ANY(id, ID *, void *); \
119     FOREACH_CALLBACK_INVOKE_ID_PP(_data, (ID **)&(id), cb_flag); \
120   } \
121   ((void)0)
122
123 #define FOREACH_CALLBACK_INVOKE(_data, id_super, cb_flag) \
124   { \
125     CHECK_TYPE(&((id_super)->id), ID *); \
126     FOREACH_CALLBACK_INVOKE_ID_PP(_data, (ID **)&(id_super), cb_flag); \
127   } \
128   ((void)0)
129
130 /* status */
131 enum {
132   IDWALK_STOP = 1 << 0,
133 };
134
135 typedef struct LibraryForeachIDData {
136   ID *self_id;
137   int flag;
138   int cb_flag;
139   int cb_flag_clear;
140   LibraryIDLinkCallback callback;
141   void *user_data;
142   int status;
143
144   /* To handle recursion. */
145   GSet *ids_handled; /* All IDs that are either already done, or still in ids_todo stack. */
146   BLI_LINKSTACK_DECLARE(ids_todo, ID *);
147 } LibraryForeachIDData;
148
149 static void library_foreach_ID_link(Main *bmain,
150                                     ID *id,
151                                     LibraryIDLinkCallback callback,
152                                     void *user_data,
153                                     int flag,
154                                     LibraryForeachIDData *inherit_data);
155
156 static void library_foreach_idproperty_ID_link(LibraryForeachIDData *data,
157                                                IDProperty *prop,
158                                                int flag)
159 {
160   if (!prop) {
161     return;
162   }
163
164   switch (prop->type) {
165     case IDP_GROUP: {
166       for (IDProperty *loop = prop->data.group.first; loop; loop = loop->next) {
167         library_foreach_idproperty_ID_link(data, loop, flag);
168       }
169       break;
170     }
171     case IDP_IDPARRAY: {
172       IDProperty *loop = IDP_Array(prop);
173       for (int i = 0; i < prop->len; i++) {
174         library_foreach_idproperty_ID_link(data, &loop[i], flag);
175       }
176       break;
177     }
178     case IDP_ID:
179       FOREACH_CALLBACK_INVOKE_ID(data, prop->data.pointer, flag);
180       break;
181     default:
182       break; /* Nothing to do here with other types of IDProperties... */
183   }
184
185   FOREACH_FINALIZE_VOID;
186 }
187
188 static void library_foreach_rigidbodyworldSceneLooper(struct RigidBodyWorld *UNUSED(rbw),
189                                                       ID **id_pointer,
190                                                       void *user_data,
191                                                       int cb_flag)
192 {
193   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
194   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
195
196   FOREACH_FINALIZE_VOID;
197 }
198
199 static void library_foreach_modifiersForeachIDLink(void *user_data,
200                                                    Object *UNUSED(object),
201                                                    ID **id_pointer,
202                                                    int cb_flag)
203 {
204   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
205   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
206
207   FOREACH_FINALIZE_VOID;
208 }
209
210 static void library_foreach_gpencil_modifiersForeachIDLink(void *user_data,
211                                                            Object *UNUSED(object),
212                                                            ID **id_pointer,
213                                                            int cb_flag)
214 {
215   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
216   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
217
218   FOREACH_FINALIZE_VOID;
219 }
220
221 static void library_foreach_shaderfxForeachIDLink(void *user_data,
222                                                   Object *UNUSED(object),
223                                                   ID **id_pointer,
224                                                   int cb_flag)
225 {
226   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
227   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
228
229   FOREACH_FINALIZE_VOID;
230 }
231
232 static void library_foreach_constraintObjectLooper(bConstraint *UNUSED(con),
233                                                    ID **id_pointer,
234                                                    bool is_reference,
235                                                    void *user_data)
236 {
237   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
238   const int cb_flag = is_reference ? IDWALK_CB_USER : IDWALK_CB_NOP;
239   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
240
241   FOREACH_FINALIZE_VOID;
242 }
243
244 static void library_foreach_particlesystemsObjectLooper(ParticleSystem *UNUSED(psys),
245                                                         ID **id_pointer,
246                                                         void *user_data,
247                                                         int cb_flag)
248 {
249   LibraryForeachIDData *data = (LibraryForeachIDData *)user_data;
250   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pointer, cb_flag);
251
252   FOREACH_FINALIZE_VOID;
253 }
254
255 static void library_foreach_nla_strip(LibraryForeachIDData *data, NlaStrip *strip)
256 {
257   NlaStrip *substrip;
258
259   FOREACH_CALLBACK_INVOKE(data, strip->act, IDWALK_CB_USER);
260
261   for (substrip = strip->strips.first; substrip; substrip = substrip->next) {
262     library_foreach_nla_strip(data, substrip);
263   }
264
265   FOREACH_FINALIZE_VOID;
266 }
267
268 static void library_foreach_animationData(LibraryForeachIDData *data, AnimData *adt)
269 {
270   FCurve *fcu;
271   NlaTrack *nla_track;
272   NlaStrip *nla_strip;
273
274   for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
275     ChannelDriver *driver = fcu->driver;
276     DriverVar *dvar;
277
278     for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
279       /* only used targets */
280       DRIVER_TARGETS_USED_LOOPER_BEGIN (dvar) {
281         FOREACH_CALLBACK_INVOKE_ID(data, dtar->id, IDWALK_CB_NOP);
282       }
283       DRIVER_TARGETS_LOOPER_END;
284     }
285   }
286
287   FOREACH_CALLBACK_INVOKE(data, adt->action, IDWALK_CB_USER);
288   FOREACH_CALLBACK_INVOKE(data, adt->tmpact, IDWALK_CB_USER);
289
290   for (nla_track = adt->nla_tracks.first; nla_track; nla_track = nla_track->next) {
291     for (nla_strip = nla_track->strips.first; nla_strip; nla_strip = nla_strip->next) {
292       library_foreach_nla_strip(data, nla_strip);
293     }
294   }
295
296   FOREACH_FINALIZE_VOID;
297 }
298
299 static void library_foreach_mtex(LibraryForeachIDData *data, MTex *mtex)
300 {
301   FOREACH_CALLBACK_INVOKE(data, mtex->object, IDWALK_CB_NOP);
302   FOREACH_CALLBACK_INVOKE(data, mtex->tex, IDWALK_CB_USER);
303
304   FOREACH_FINALIZE_VOID;
305 }
306
307 static void library_foreach_paint(LibraryForeachIDData *data, Paint *paint)
308 {
309   FOREACH_CALLBACK_INVOKE(data, paint->brush, IDWALK_CB_USER);
310   for (int i = 0; i < paint->tool_slots_len; i++) {
311     FOREACH_CALLBACK_INVOKE(data, paint->tool_slots[i].brush, IDWALK_CB_USER);
312   }
313   FOREACH_CALLBACK_INVOKE(data, paint->palette, IDWALK_CB_USER);
314
315   FOREACH_FINALIZE_VOID;
316 }
317
318 static void library_foreach_bone(LibraryForeachIDData *data, Bone *bone)
319 {
320   library_foreach_idproperty_ID_link(data, bone->prop, IDWALK_CB_USER);
321
322   for (Bone *curbone = bone->childbase.first; curbone; curbone = curbone->next) {
323     library_foreach_bone(data, curbone);
324   }
325
326   FOREACH_FINALIZE_VOID;
327 }
328
329 static void library_foreach_layer_collection(LibraryForeachIDData *data, ListBase *lb)
330 {
331   for (LayerCollection *lc = lb->first; lc; lc = lc->next) {
332     FOREACH_CALLBACK_INVOKE(data, lc->collection, IDWALK_CB_NOP);
333     library_foreach_layer_collection(data, &lc->layer_collections);
334   }
335
336   FOREACH_FINALIZE_VOID;
337 }
338
339 /* Used by both real Collection data-blocks, and the fake horror of master collection from Scene.
340  */
341 static void library_foreach_collection(LibraryForeachIDData *data, Collection *collection)
342 {
343   for (CollectionObject *cob = collection->gobject.first; cob; cob = cob->next) {
344     FOREACH_CALLBACK_INVOKE(data, cob->ob, IDWALK_CB_USER);
345   }
346   for (CollectionChild *child = collection->children.first; child; child = child->next) {
347     FOREACH_CALLBACK_INVOKE(data, child->collection, IDWALK_CB_NEVER_SELF | IDWALK_CB_USER);
348   }
349   for (CollectionParent *parent = collection->parents.first; parent; parent = parent->next) {
350     FOREACH_CALLBACK_INVOKE(data, parent->collection, IDWALK_CB_NEVER_SELF | IDWALK_CB_LOOPBACK);
351   }
352
353   FOREACH_FINALIZE_VOID;
354 }
355
356 static void library_foreach_ID_as_subdata_link(ID **id_pp,
357                                                LibraryIDLinkCallback callback,
358                                                void *user_data,
359                                                int flag,
360                                                LibraryForeachIDData *data)
361 {
362   /* Needed e.g. for callbacks handling relationships... This call shall be absolutely readonly. */
363   ID *id = *id_pp;
364   FOREACH_CALLBACK_INVOKE_ID_PP(data, id_pp, IDWALK_CB_PRIVATE);
365   BLI_assert(id == *id_pp);
366
367   if (flag & IDWALK_RECURSE) {
368     /* Defer handling into main loop, recursively calling BKE_library_foreach_ID_link in
369      * IDWALK_RECURSE case is troublesome, see T49553. */
370     if (BLI_gset_add(data->ids_handled, id)) {
371       BLI_LINKSTACK_PUSH(data->ids_todo, id);
372     }
373   }
374   else {
375     library_foreach_ID_link(NULL, id, callback, user_data, flag, data);
376   }
377
378   FOREACH_FINALIZE_VOID;
379 }
380
381 static void library_foreach_ID_link(Main *bmain,
382                                     ID *id,
383                                     LibraryIDLinkCallback callback,
384                                     void *user_data,
385                                     int flag,
386                                     LibraryForeachIDData *inherit_data)
387 {
388   LibraryForeachIDData data;
389   int i;
390
391   if (flag & IDWALK_RECURSE) {
392     /* For now, recursion implies read-only. */
393     flag |= IDWALK_READONLY;
394
395     data.ids_handled = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
396     BLI_LINKSTACK_INIT(data.ids_todo);
397
398     BLI_gset_add(data.ids_handled, id);
399   }
400   else {
401     data.ids_handled = NULL;
402   }
403   data.flag = flag;
404   data.status = 0;
405   data.callback = callback;
406   data.user_data = user_data;
407
408 #define CALLBACK_INVOKE_ID(check_id, cb_flag) FOREACH_CALLBACK_INVOKE_ID(&data, check_id, cb_flag)
409
410 #define CALLBACK_INVOKE(check_id_super, cb_flag) \
411   FOREACH_CALLBACK_INVOKE(&data, check_id_super, cb_flag)
412
413   for (; id != NULL; id = (flag & IDWALK_RECURSE) ? BLI_LINKSTACK_POP(data.ids_todo) : NULL) {
414     data.self_id = id;
415
416     /* inherit_data is non-NULL when this function is called for some sub-data ID
417      * (like root nodetree of a material).
418      * In that case, we do not want to generate those 'generic flags' from our current sub-data ID
419      * (the node tree), but re-use those generated for the 'owner' ID (the material). */
420     if (inherit_data == NULL) {
421       data.cb_flag = ID_IS_LINKED(id) ? IDWALK_CB_INDIRECT_USAGE : 0;
422       /* When an ID is not in Main database, it should never refcount IDs it is using.
423        * Exceptions: NodeTrees (yeeahhh!) directly used by Materials. */
424       data.cb_flag_clear = (id->tag & LIB_TAG_NO_MAIN) ? IDWALK_CB_USER | IDWALK_CB_USER_ONE : 0;
425     }
426     else {
427       data.cb_flag = inherit_data->cb_flag;
428       data.cb_flag_clear = inherit_data->cb_flag_clear;
429     }
430
431     if (bmain != NULL && bmain->relations != NULL && (flag & IDWALK_READONLY)) {
432       /* Note that this is minor optimization, even in worst cases (like id being an object with
433        * lots of drivers and constraints and modifiers, or material etc. with huge node tree),
434        * but we might as well use it (Main->relations is always assumed valid,
435        * it's responsibility of code creating it to free it,
436        * especially if/when it starts modifying Main database). */
437       MainIDRelationsEntry *entry = BLI_ghash_lookup(bmain->relations->id_user_to_used, id);
438       for (; entry != NULL; entry = entry->next) {
439         FOREACH_CALLBACK_INVOKE_ID_PP(&data, entry->id_pointer, entry->usage_flag);
440       }
441       continue;
442     }
443
444     if (id->override_library != NULL) {
445       CALLBACK_INVOKE_ID(id->override_library->reference,
446                          IDWALK_CB_USER | IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE);
447       CALLBACK_INVOKE_ID(id->override_library->storage,
448                          IDWALK_CB_USER | IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE);
449     }
450
451     library_foreach_idproperty_ID_link(&data, id->properties, IDWALK_CB_USER);
452
453     AnimData *adt = BKE_animdata_from_id(id);
454     if (adt) {
455       library_foreach_animationData(&data, adt);
456     }
457
458     switch ((ID_Type)GS(id->name)) {
459       case ID_LI: {
460         Library *lib = (Library *)id;
461         CALLBACK_INVOKE(lib->parent, IDWALK_CB_NEVER_SELF);
462         break;
463       }
464       case ID_SCE: {
465         Scene *scene = (Scene *)id;
466         ToolSettings *toolsett = scene->toolsettings;
467
468         CALLBACK_INVOKE(scene->camera, IDWALK_CB_NOP);
469         CALLBACK_INVOKE(scene->world, IDWALK_CB_USER);
470         CALLBACK_INVOKE(scene->set, IDWALK_CB_NEVER_SELF);
471         CALLBACK_INVOKE(scene->clip, IDWALK_CB_USER);
472         CALLBACK_INVOKE(scene->gpd, IDWALK_CB_USER);
473         CALLBACK_INVOKE(scene->r.bake.cage_object, IDWALK_CB_NOP);
474         if (scene->nodetree) {
475           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
476           library_foreach_ID_as_subdata_link(
477               (ID **)&scene->nodetree, callback, user_data, flag, &data);
478         }
479         if (scene->ed) {
480           Sequence *seq;
481           SEQP_BEGIN (scene->ed, seq) {
482             CALLBACK_INVOKE(seq->scene, IDWALK_CB_NEVER_SELF);
483             CALLBACK_INVOKE(seq->scene_camera, IDWALK_CB_NOP);
484             CALLBACK_INVOKE(seq->clip, IDWALK_CB_USER);
485             CALLBACK_INVOKE(seq->mask, IDWALK_CB_USER);
486             CALLBACK_INVOKE(seq->sound, IDWALK_CB_USER);
487             library_foreach_idproperty_ID_link(&data, seq->prop, IDWALK_CB_USER);
488             for (SequenceModifierData *smd = seq->modifiers.first; smd; smd = smd->next) {
489               CALLBACK_INVOKE(smd->mask_id, IDWALK_CB_USER);
490             }
491
492             if (seq->type == SEQ_TYPE_TEXT && seq->effectdata) {
493               TextVars *text_data = seq->effectdata;
494               CALLBACK_INVOKE(text_data->text_font, IDWALK_CB_USER);
495             }
496           }
497           SEQ_END;
498         }
499
500         library_foreach_collection(&data, scene->master_collection);
501
502         ViewLayer *view_layer;
503         for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
504           CALLBACK_INVOKE(view_layer->mat_override, IDWALK_CB_USER);
505
506           for (Base *base = view_layer->object_bases.first; base; base = base->next) {
507             CALLBACK_INVOKE(base->object, IDWALK_CB_NOP);
508           }
509
510           library_foreach_layer_collection(&data, &view_layer->layer_collections);
511
512           for (FreestyleModuleConfig *fmc = view_layer->freestyle_config.modules.first; fmc;
513                fmc = fmc->next) {
514             if (fmc->script) {
515               CALLBACK_INVOKE(fmc->script, IDWALK_CB_NOP);
516             }
517           }
518
519           for (FreestyleLineSet *fls = view_layer->freestyle_config.linesets.first; fls;
520                fls = fls->next) {
521             if (fls->group) {
522               CALLBACK_INVOKE(fls->group, IDWALK_CB_USER);
523             }
524
525             if (fls->linestyle) {
526               CALLBACK_INVOKE(fls->linestyle, IDWALK_CB_USER);
527             }
528           }
529         }
530
531         for (TimeMarker *marker = scene->markers.first; marker; marker = marker->next) {
532           CALLBACK_INVOKE(marker->camera, IDWALK_CB_NOP);
533         }
534
535         if (toolsett) {
536           CALLBACK_INVOKE(toolsett->particle.scene, IDWALK_CB_NOP);
537           CALLBACK_INVOKE(toolsett->particle.object, IDWALK_CB_NOP);
538           CALLBACK_INVOKE(toolsett->particle.shape_object, IDWALK_CB_NOP);
539
540           library_foreach_paint(&data, &toolsett->imapaint.paint);
541           CALLBACK_INVOKE(toolsett->imapaint.stencil, IDWALK_CB_USER);
542           CALLBACK_INVOKE(toolsett->imapaint.clone, IDWALK_CB_USER);
543           CALLBACK_INVOKE(toolsett->imapaint.canvas, IDWALK_CB_USER);
544
545           if (toolsett->vpaint) {
546             library_foreach_paint(&data, &toolsett->vpaint->paint);
547           }
548           if (toolsett->wpaint) {
549             library_foreach_paint(&data, &toolsett->wpaint->paint);
550           }
551           if (toolsett->sculpt) {
552             library_foreach_paint(&data, &toolsett->sculpt->paint);
553             CALLBACK_INVOKE(toolsett->sculpt->gravity_object, IDWALK_CB_NOP);
554           }
555           if (toolsett->uvsculpt) {
556             library_foreach_paint(&data, &toolsett->uvsculpt->paint);
557           }
558           if (toolsett->gp_paint) {
559             library_foreach_paint(&data, &toolsett->gp_paint->paint);
560           }
561
562           CALLBACK_INVOKE(toolsett->gp_sculpt.guide.reference_object, IDWALK_CB_NOP);
563         }
564
565         if (scene->rigidbody_world) {
566           BKE_rigidbody_world_id_loop(
567               scene->rigidbody_world, library_foreach_rigidbodyworldSceneLooper, &data);
568         }
569
570         break;
571       }
572
573       case ID_OB: {
574         Object *object = (Object *)id;
575         ParticleSystem *psys;
576
577         /* Object is special, proxies make things hard... */
578         const int data_cb_flag = data.cb_flag;
579         const int proxy_cb_flag = ((data.flag & IDWALK_NO_INDIRECT_PROXY_DATA_USAGE) == 0 &&
580                                    (object->proxy || object->proxy_group)) ?
581                                       IDWALK_CB_INDIRECT_USAGE :
582                                       0;
583
584         /* object data special case */
585         data.cb_flag |= proxy_cb_flag;
586         if (object->type == OB_EMPTY) {
587           /* empty can have NULL or Image */
588           CALLBACK_INVOKE_ID(object->data, IDWALK_CB_USER);
589         }
590         else {
591           /* when set, this can't be NULL */
592           if (object->data) {
593             CALLBACK_INVOKE_ID(object->data, IDWALK_CB_USER | IDWALK_CB_NEVER_NULL);
594           }
595         }
596         data.cb_flag = data_cb_flag;
597
598         CALLBACK_INVOKE(object->parent, IDWALK_CB_NEVER_SELF);
599         CALLBACK_INVOKE(object->track, IDWALK_CB_NEVER_SELF);
600         /* object->proxy is refcounted, but not object->proxy_group... *sigh* */
601         CALLBACK_INVOKE(object->proxy, IDWALK_CB_USER | IDWALK_CB_NEVER_SELF);
602         CALLBACK_INVOKE(object->proxy_group, IDWALK_CB_NOP);
603
604         /* Special case!
605          * Since this field is set/owned by 'user' of this ID (and not ID itself),
606          * it is only indirect usage if proxy object is linked... Twisted. */
607         if (object->proxy_from) {
608           data.cb_flag = ID_IS_LINKED(object->proxy_from) ? IDWALK_CB_INDIRECT_USAGE : 0;
609         }
610         CALLBACK_INVOKE(object->proxy_from, IDWALK_CB_LOOPBACK | IDWALK_CB_NEVER_SELF);
611         data.cb_flag = data_cb_flag;
612
613         CALLBACK_INVOKE(object->poselib, IDWALK_CB_USER);
614
615         data.cb_flag |= proxy_cb_flag;
616         for (i = 0; i < object->totcol; i++) {
617           CALLBACK_INVOKE(object->mat[i], IDWALK_CB_USER);
618         }
619         data.cb_flag = data_cb_flag;
620
621         /* Note that ob->gpd is deprecated, so no need to handle it here. */
622         CALLBACK_INVOKE(object->instance_collection, IDWALK_CB_USER);
623
624         if (object->pd) {
625           CALLBACK_INVOKE(object->pd->tex, IDWALK_CB_USER);
626           CALLBACK_INVOKE(object->pd->f_source, IDWALK_CB_NOP);
627         }
628         /* Note that ob->effect is deprecated, so no need to handle it here. */
629
630         if (object->pose) {
631           bPoseChannel *pchan;
632
633           data.cb_flag |= proxy_cb_flag;
634           for (pchan = object->pose->chanbase.first; pchan; pchan = pchan->next) {
635             library_foreach_idproperty_ID_link(&data, pchan->prop, IDWALK_CB_USER);
636             CALLBACK_INVOKE(pchan->custom, IDWALK_CB_USER);
637             BKE_constraints_id_loop(
638                 &pchan->constraints, library_foreach_constraintObjectLooper, &data);
639           }
640           data.cb_flag = data_cb_flag;
641         }
642
643         if (object->rigidbody_constraint) {
644           CALLBACK_INVOKE(object->rigidbody_constraint->ob1, IDWALK_CB_NEVER_SELF);
645           CALLBACK_INVOKE(object->rigidbody_constraint->ob2, IDWALK_CB_NEVER_SELF);
646         }
647
648         if (object->lodlevels.first) {
649           LodLevel *level;
650           for (level = object->lodlevels.first; level; level = level->next) {
651             CALLBACK_INVOKE(level->source, IDWALK_CB_NEVER_SELF);
652           }
653         }
654
655         modifiers_foreachIDLink(object, library_foreach_modifiersForeachIDLink, &data);
656         BKE_gpencil_modifiers_foreachIDLink(
657             object, library_foreach_gpencil_modifiersForeachIDLink, &data);
658         BKE_constraints_id_loop(
659             &object->constraints, library_foreach_constraintObjectLooper, &data);
660         BKE_shaderfx_foreachIDLink(object, library_foreach_shaderfxForeachIDLink, &data);
661
662         for (psys = object->particlesystem.first; psys; psys = psys->next) {
663           BKE_particlesystem_id_loop(psys, library_foreach_particlesystemsObjectLooper, &data);
664         }
665
666         if (object->soft) {
667           CALLBACK_INVOKE(object->soft->collision_group, IDWALK_CB_NOP);
668
669           if (object->soft->effector_weights) {
670             CALLBACK_INVOKE(object->soft->effector_weights->group, IDWALK_CB_NOP);
671           }
672         }
673         break;
674       }
675
676       case ID_AR: {
677         bArmature *arm = (bArmature *)id;
678
679         for (Bone *bone = arm->bonebase.first; bone; bone = bone->next) {
680           library_foreach_bone(&data, bone);
681         }
682         break;
683       }
684
685       case ID_ME: {
686         Mesh *mesh = (Mesh *)id;
687         CALLBACK_INVOKE(mesh->texcomesh, IDWALK_CB_NEVER_SELF);
688         CALLBACK_INVOKE(mesh->key, IDWALK_CB_USER);
689         for (i = 0; i < mesh->totcol; i++) {
690           CALLBACK_INVOKE(mesh->mat[i], IDWALK_CB_USER);
691         }
692         break;
693       }
694
695       case ID_CU: {
696         Curve *curve = (Curve *)id;
697         CALLBACK_INVOKE(curve->bevobj, IDWALK_CB_NOP);
698         CALLBACK_INVOKE(curve->taperobj, IDWALK_CB_NOP);
699         CALLBACK_INVOKE(curve->textoncurve, IDWALK_CB_NOP);
700         CALLBACK_INVOKE(curve->key, IDWALK_CB_USER);
701         for (i = 0; i < curve->totcol; i++) {
702           CALLBACK_INVOKE(curve->mat[i], IDWALK_CB_USER);
703         }
704         CALLBACK_INVOKE(curve->vfont, IDWALK_CB_USER);
705         CALLBACK_INVOKE(curve->vfontb, IDWALK_CB_USER);
706         CALLBACK_INVOKE(curve->vfonti, IDWALK_CB_USER);
707         CALLBACK_INVOKE(curve->vfontbi, IDWALK_CB_USER);
708         break;
709       }
710
711       case ID_MB: {
712         MetaBall *metaball = (MetaBall *)id;
713         for (i = 0; i < metaball->totcol; i++) {
714           CALLBACK_INVOKE(metaball->mat[i], IDWALK_CB_USER);
715         }
716         break;
717       }
718
719       case ID_MA: {
720         Material *material = (Material *)id;
721         if (material->nodetree) {
722           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
723           library_foreach_ID_as_subdata_link(
724               (ID **)&material->nodetree, callback, user_data, flag, &data);
725         }
726         if (material->texpaintslot != NULL) {
727           CALLBACK_INVOKE(material->texpaintslot->ima, IDWALK_CB_NOP);
728         }
729         if (material->gp_style != NULL) {
730           CALLBACK_INVOKE(material->gp_style->sima, IDWALK_CB_USER);
731           CALLBACK_INVOKE(material->gp_style->ima, IDWALK_CB_USER);
732         }
733         break;
734       }
735
736       case ID_TE: {
737         Tex *texture = (Tex *)id;
738         if (texture->nodetree) {
739           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
740           library_foreach_ID_as_subdata_link(
741               (ID **)&texture->nodetree, callback, user_data, flag, &data);
742         }
743         CALLBACK_INVOKE(texture->ima, IDWALK_CB_USER);
744         break;
745       }
746
747       case ID_LT: {
748         Lattice *lattice = (Lattice *)id;
749         CALLBACK_INVOKE(lattice->key, IDWALK_CB_USER);
750         break;
751       }
752
753       case ID_LA: {
754         Light *lamp = (Light *)id;
755         if (lamp->nodetree) {
756           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
757           library_foreach_ID_as_subdata_link(
758               (ID **)&lamp->nodetree, callback, user_data, flag, &data);
759         }
760         break;
761       }
762
763       case ID_CA: {
764         Camera *camera = (Camera *)id;
765         CALLBACK_INVOKE(camera->dof.focus_object, IDWALK_CB_NOP);
766         for (CameraBGImage *bgpic = camera->bg_images.first; bgpic; bgpic = bgpic->next) {
767           if (bgpic->source == CAM_BGIMG_SOURCE_IMAGE) {
768             CALLBACK_INVOKE(bgpic->ima, IDWALK_CB_USER);
769           }
770           else if (bgpic->source == CAM_BGIMG_SOURCE_MOVIE) {
771             CALLBACK_INVOKE(bgpic->clip, IDWALK_CB_USER);
772           }
773         }
774
775         break;
776       }
777
778       case ID_KE: {
779         Key *key = (Key *)id;
780         CALLBACK_INVOKE_ID(key->from, IDWALK_CB_LOOPBACK);
781         break;
782       }
783
784       case ID_WO: {
785         World *world = (World *)id;
786         if (world->nodetree) {
787           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
788           library_foreach_ID_as_subdata_link(
789               (ID **)&world->nodetree, callback, user_data, flag, &data);
790         }
791         break;
792       }
793
794       case ID_SPK: {
795         Speaker *speaker = (Speaker *)id;
796         CALLBACK_INVOKE(speaker->sound, IDWALK_CB_USER);
797         break;
798       }
799
800       case ID_LP: {
801         LightProbe *probe = (LightProbe *)id;
802         CALLBACK_INVOKE(probe->image, IDWALK_CB_USER);
803         CALLBACK_INVOKE(probe->visibility_grp, IDWALK_CB_NOP);
804         break;
805       }
806
807       case ID_GR: {
808         Collection *collection = (Collection *)id;
809         library_foreach_collection(&data, collection);
810         break;
811       }
812
813       case ID_NT: {
814         bNodeTree *ntree = (bNodeTree *)id;
815         bNode *node;
816         bNodeSocket *sock;
817
818         CALLBACK_INVOKE(ntree->gpd, IDWALK_CB_USER);
819
820         for (node = ntree->nodes.first; node; node = node->next) {
821           CALLBACK_INVOKE_ID(node->id, IDWALK_CB_USER);
822
823           library_foreach_idproperty_ID_link(&data, node->prop, IDWALK_CB_USER);
824           for (sock = node->inputs.first; sock; sock = sock->next) {
825             library_foreach_idproperty_ID_link(&data, sock->prop, IDWALK_CB_USER);
826           }
827           for (sock = node->outputs.first; sock; sock = sock->next) {
828             library_foreach_idproperty_ID_link(&data, sock->prop, IDWALK_CB_USER);
829           }
830         }
831
832         for (sock = ntree->inputs.first; sock; sock = sock->next) {
833           library_foreach_idproperty_ID_link(&data, sock->prop, IDWALK_CB_USER);
834         }
835         for (sock = ntree->outputs.first; sock; sock = sock->next) {
836           library_foreach_idproperty_ID_link(&data, sock->prop, IDWALK_CB_USER);
837         }
838         break;
839       }
840
841       case ID_BR: {
842         Brush *brush = (Brush *)id;
843         CALLBACK_INVOKE(brush->toggle_brush, IDWALK_CB_NOP);
844         CALLBACK_INVOKE(brush->clone.image, IDWALK_CB_NOP);
845         CALLBACK_INVOKE(brush->paint_curve, IDWALK_CB_USER);
846         if (brush->gpencil_settings) {
847           CALLBACK_INVOKE(brush->gpencil_settings->material, IDWALK_CB_USER);
848         }
849         library_foreach_mtex(&data, &brush->mtex);
850         library_foreach_mtex(&data, &brush->mask_mtex);
851         break;
852       }
853
854       case ID_PA: {
855         ParticleSettings *psett = (ParticleSettings *)id;
856         CALLBACK_INVOKE(psett->instance_collection, IDWALK_CB_USER);
857         CALLBACK_INVOKE(psett->instance_object, IDWALK_CB_NOP);
858         CALLBACK_INVOKE(psett->bb_ob, IDWALK_CB_NOP);
859         CALLBACK_INVOKE(psett->collision_group, IDWALK_CB_NOP);
860
861         for (i = 0; i < MAX_MTEX; i++) {
862           if (psett->mtex[i]) {
863             library_foreach_mtex(&data, psett->mtex[i]);
864           }
865         }
866
867         if (psett->effector_weights) {
868           CALLBACK_INVOKE(psett->effector_weights->group, IDWALK_CB_NOP);
869         }
870
871         if (psett->pd) {
872           CALLBACK_INVOKE(psett->pd->tex, IDWALK_CB_USER);
873           CALLBACK_INVOKE(psett->pd->f_source, IDWALK_CB_NOP);
874         }
875         if (psett->pd2) {
876           CALLBACK_INVOKE(psett->pd2->tex, IDWALK_CB_USER);
877           CALLBACK_INVOKE(psett->pd2->f_source, IDWALK_CB_NOP);
878         }
879
880         if (psett->boids) {
881           BoidState *state;
882           BoidRule *rule;
883
884           for (state = psett->boids->states.first; state; state = state->next) {
885             for (rule = state->rules.first; rule; rule = rule->next) {
886               if (rule->type == eBoidRuleType_Avoid) {
887                 BoidRuleGoalAvoid *gabr = (BoidRuleGoalAvoid *)rule;
888                 CALLBACK_INVOKE(gabr->ob, IDWALK_CB_NOP);
889               }
890               else if (rule->type == eBoidRuleType_FollowLeader) {
891                 BoidRuleFollowLeader *flbr = (BoidRuleFollowLeader *)rule;
892                 CALLBACK_INVOKE(flbr->ob, IDWALK_CB_NOP);
893               }
894             }
895           }
896         }
897
898         for (ParticleDupliWeight *dw = psett->instance_weights.first; dw; dw = dw->next) {
899           CALLBACK_INVOKE(dw->ob, IDWALK_CB_NOP);
900         }
901         break;
902       }
903
904       case ID_MC: {
905         MovieClip *clip = (MovieClip *)id;
906         MovieTracking *tracking = &clip->tracking;
907         MovieTrackingObject *object;
908         MovieTrackingTrack *track;
909         MovieTrackingPlaneTrack *plane_track;
910
911         CALLBACK_INVOKE(clip->gpd, IDWALK_CB_USER);
912
913         for (track = tracking->tracks.first; track; track = track->next) {
914           CALLBACK_INVOKE(track->gpd, IDWALK_CB_USER);
915         }
916         for (object = tracking->objects.first; object; object = object->next) {
917           for (track = object->tracks.first; track; track = track->next) {
918             CALLBACK_INVOKE(track->gpd, IDWALK_CB_USER);
919           }
920         }
921
922         for (plane_track = tracking->plane_tracks.first; plane_track;
923              plane_track = plane_track->next) {
924           CALLBACK_INVOKE(plane_track->image, IDWALK_CB_USER);
925         }
926         break;
927       }
928
929       case ID_MSK: {
930         Mask *mask = (Mask *)id;
931         MaskLayer *mask_layer;
932         for (mask_layer = mask->masklayers.first; mask_layer; mask_layer = mask_layer->next) {
933           MaskSpline *mask_spline;
934
935           for (mask_spline = mask_layer->splines.first; mask_spline;
936                mask_spline = mask_spline->next) {
937             for (i = 0; i < mask_spline->tot_point; i++) {
938               MaskSplinePoint *point = &mask_spline->points[i];
939               CALLBACK_INVOKE_ID(point->parent.id, IDWALK_CB_USER);
940             }
941           }
942         }
943         break;
944       }
945
946       case ID_LS: {
947         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
948         LineStyleModifier *lsm;
949         for (i = 0; i < MAX_MTEX; i++) {
950           if (linestyle->mtex[i]) {
951             library_foreach_mtex(&data, linestyle->mtex[i]);
952           }
953         }
954         if (linestyle->nodetree) {
955           /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
956           library_foreach_ID_as_subdata_link(
957               (ID **)&linestyle->nodetree, callback, user_data, flag, &data);
958         }
959
960         for (lsm = linestyle->color_modifiers.first; lsm; lsm = lsm->next) {
961           if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
962             LineStyleColorModifier_DistanceFromObject *p =
963                 (LineStyleColorModifier_DistanceFromObject *)lsm;
964             if (p->target) {
965               CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
966             }
967           }
968         }
969         for (lsm = linestyle->alpha_modifiers.first; lsm; lsm = lsm->next) {
970           if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
971             LineStyleAlphaModifier_DistanceFromObject *p =
972                 (LineStyleAlphaModifier_DistanceFromObject *)lsm;
973             if (p->target) {
974               CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
975             }
976           }
977         }
978         for (lsm = linestyle->thickness_modifiers.first; lsm; lsm = lsm->next) {
979           if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
980             LineStyleThicknessModifier_DistanceFromObject *p =
981                 (LineStyleThicknessModifier_DistanceFromObject *)lsm;
982             if (p->target) {
983               CALLBACK_INVOKE(p->target, IDWALK_CB_NOP);
984             }
985           }
986         }
987         break;
988       }
989       case ID_AC: {
990         bAction *act = (bAction *)id;
991
992         for (TimeMarker *marker = act->markers.first; marker; marker = marker->next) {
993           CALLBACK_INVOKE(marker->camera, IDWALK_CB_NOP);
994         }
995         break;
996       }
997
998       case ID_WM: {
999         wmWindowManager *wm = (wmWindowManager *)id;
1000
1001         for (wmWindow *win = wm->windows.first; win; win = win->next) {
1002           ID *workspace = (ID *)BKE_workspace_active_get(win->workspace_hook);
1003
1004           CALLBACK_INVOKE(win->scene, IDWALK_CB_USER_ONE);
1005
1006           CALLBACK_INVOKE_ID(workspace, IDWALK_CB_NOP);
1007           /* allow callback to set a different workspace */
1008           BKE_workspace_active_set(win->workspace_hook, (WorkSpace *)workspace);
1009         }
1010         break;
1011       }
1012
1013       case ID_WS: {
1014         WorkSpace *workspace = (WorkSpace *)id;
1015         ListBase *layouts = BKE_workspace_layouts_get(workspace);
1016
1017         for (WorkSpaceLayout *layout = layouts->first; layout; layout = layout->next) {
1018           bScreen *screen = BKE_workspace_layout_screen_get(layout);
1019
1020           /* CALLBACK_INVOKE expects an actual pointer, not a variable holding the pointer.
1021            * However we can't access layout->screen here
1022            * since we are outside the workspace project. */
1023           CALLBACK_INVOKE(screen, IDWALK_CB_USER);
1024           /* allow callback to set a different screen */
1025           BKE_workspace_layout_screen_set(layout, screen);
1026         }
1027         break;
1028       }
1029       case ID_GD: {
1030         bGPdata *gpencil = (bGPdata *)id;
1031         /* materials */
1032         for (i = 0; i < gpencil->totcol; i++) {
1033           CALLBACK_INVOKE(gpencil->mat[i], IDWALK_CB_USER);
1034         }
1035
1036         for (bGPDlayer *gplayer = gpencil->layers.first; gplayer != NULL;
1037              gplayer = gplayer->next) {
1038           CALLBACK_INVOKE(gplayer->parent, IDWALK_CB_NOP);
1039         }
1040
1041         break;
1042       }
1043
1044       /* Nothing needed for those... */
1045       case ID_SCR:
1046       case ID_IM:
1047       case ID_VF:
1048       case ID_TXT:
1049       case ID_SO:
1050       case ID_PAL:
1051       case ID_PC:
1052       case ID_CF:
1053         break;
1054
1055       /* Deprecated. */
1056       case ID_IP:
1057         break;
1058     }
1059   }
1060
1061 FOREACH_FINALIZE:
1062   if (data.ids_handled) {
1063     BLI_gset_free(data.ids_handled, NULL);
1064     BLI_LINKSTACK_FREE(data.ids_todo);
1065   }
1066
1067 #undef CALLBACK_INVOKE_ID
1068 #undef CALLBACK_INVOKE
1069 }
1070
1071 #undef FOREACH_CALLBACK_INVOKE_ID
1072 #undef FOREACH_CALLBACK_INVOKE
1073
1074 /**
1075  * Loop over all of the ID's this data-block links to.
1076  */
1077 void BKE_library_foreach_ID_link(
1078     Main *bmain, ID *id, LibraryIDLinkCallback callback, void *user_data, int flag)
1079 {
1080   library_foreach_ID_link(bmain, id, callback, user_data, flag, NULL);
1081 }
1082
1083 /**
1084  * re-usable function, use when replacing ID's
1085  */
1086 void BKE_library_update_ID_link_user(ID *id_dst, ID *id_src, const int cb_flag)
1087 {
1088   if (cb_flag & IDWALK_CB_USER) {
1089     id_us_min(id_src);
1090     id_us_plus(id_dst);
1091   }
1092   else if (cb_flag & IDWALK_CB_USER_ONE) {
1093     id_us_ensure_real(id_dst);
1094   }
1095 }
1096
1097 /**
1098  * Say whether given \a id_type_owner can use (in any way) a data-block of \a id_type_used.
1099  *
1100  * This is a 'simplified' abstract version of #BKE_library_foreach_ID_link() above,
1101  * quite useful to reduce* useless iterations in some cases.
1102  */
1103 /* XXX This has to be fully rethink, basing check on ID type is not really working anymore
1104  * (and even worth once IDProps will support ID pointers),
1105  * we'll have to do some quick checks on IDs themselves... */
1106 bool BKE_library_id_can_use_idtype(ID *id_owner, const short id_type_used)
1107 {
1108   /* any type of ID can be used in custom props. */
1109   if (id_owner->properties) {
1110     return true;
1111   }
1112
1113   const short id_type_owner = GS(id_owner->name);
1114
1115   /* IDProps of armature bones and nodes, and bNode->id can use virtually any type of ID. */
1116   if (ELEM(id_type_owner, ID_NT, ID_AR)) {
1117     return true;
1118   }
1119
1120   if (ntreeFromID(id_owner)) {
1121     return true;
1122   }
1123
1124   if (BKE_animdata_from_id(id_owner)) {
1125     /* AnimationData can use virtually any kind of data-blocks, through drivers especially. */
1126     return true;
1127   }
1128
1129   switch ((ID_Type)id_type_owner) {
1130     case ID_LI:
1131       return ELEM(id_type_used, ID_LI);
1132     case ID_SCE:
1133       return (ELEM(id_type_used,
1134                    ID_OB,
1135                    ID_WO,
1136                    ID_SCE,
1137                    ID_MC,
1138                    ID_MA,
1139                    ID_GR,
1140                    ID_TXT,
1141                    ID_LS,
1142                    ID_MSK,
1143                    ID_SO,
1144                    ID_GD,
1145                    ID_BR,
1146                    ID_PAL,
1147                    ID_IM,
1148                    ID_NT));
1149     case ID_OB:
1150       /* Could be more specific, but simpler to just always say 'yes' here. */
1151       return true;
1152     case ID_ME:
1153       return ELEM(id_type_used, ID_ME, ID_KE, ID_MA, ID_IM);
1154     case ID_CU:
1155       return ELEM(id_type_used, ID_OB, ID_KE, ID_MA, ID_VF);
1156     case ID_MB:
1157       return ELEM(id_type_used, ID_MA);
1158     case ID_MA:
1159       return (ELEM(id_type_used, ID_TE, ID_GR));
1160     case ID_TE:
1161       return (ELEM(id_type_used, ID_IM, ID_OB));
1162     case ID_LT:
1163       return ELEM(id_type_used, ID_KE);
1164     case ID_LA:
1165       return (ELEM(id_type_used, ID_TE));
1166     case ID_CA:
1167       return ELEM(id_type_used, ID_OB);
1168     case ID_KE:
1169       /* Warning! key->from, could be more types in future? */
1170       return ELEM(id_type_used, ID_ME, ID_CU, ID_LT);
1171     case ID_SCR:
1172       return ELEM(id_type_used, ID_SCE);
1173     case ID_WO:
1174       return (ELEM(id_type_used, ID_TE));
1175     case ID_SPK:
1176       return ELEM(id_type_used, ID_SO);
1177     case ID_GR:
1178       return ELEM(id_type_used, ID_OB, ID_GR);
1179     case ID_NT:
1180       /* Could be more specific, but node.id has no type restriction... */
1181       return true;
1182     case ID_BR:
1183       return ELEM(id_type_used, ID_BR, ID_IM, ID_PC, ID_TE, ID_MA);
1184     case ID_PA:
1185       return ELEM(id_type_used, ID_OB, ID_GR, ID_TE);
1186     case ID_MC:
1187       return ELEM(id_type_used, ID_GD, ID_IM);
1188     case ID_MSK:
1189       /* WARNING! mask->parent.id, not typed. */
1190       return ELEM(id_type_used, ID_MC);
1191     case ID_LS:
1192       return (ELEM(id_type_used, ID_TE, ID_OB));
1193     case ID_LP:
1194       return ELEM(id_type_used, ID_IM);
1195     case ID_GD:
1196       return ELEM(id_type_used, ID_MA);
1197     case ID_WS:
1198       return ELEM(id_type_used, ID_SCR, ID_SCE);
1199     case ID_IM:
1200     case ID_VF:
1201     case ID_TXT:
1202     case ID_SO:
1203     case ID_AR:
1204     case ID_AC:
1205     case ID_WM:
1206     case ID_PAL:
1207     case ID_PC:
1208     case ID_CF:
1209       /* Those types never use/reference other IDs... */
1210       return false;
1211     case ID_IP:
1212       /* Deprecated... */
1213       return false;
1214   }
1215   return false;
1216 }
1217
1218 /* ***** ID users iterator. ***** */
1219 typedef struct IDUsersIter {
1220   ID *id;
1221
1222   ListBase *lb_array[MAX_LIBARRAY];
1223   int lb_idx;
1224
1225   ID *curr_id;
1226   int count_direct, count_indirect; /* Set by callback. */
1227 } IDUsersIter;
1228
1229 static int foreach_libblock_id_users_callback(void *user_data,
1230                                               ID *UNUSED(self_id),
1231                                               ID **id_p,
1232                                               int cb_flag)
1233 {
1234   IDUsersIter *iter = user_data;
1235
1236   if (*id_p) {
1237     /* 'Loopback' ID pointers (the ugly 'from' ones, Object->proxy_from and Key->from).
1238      * Those are not actually ID usage, we can ignore them here.
1239      */
1240     if (cb_flag & IDWALK_CB_LOOPBACK) {
1241       return IDWALK_RET_NOP;
1242     }
1243
1244     if (*id_p == iter->id) {
1245 #if 0
1246       printf(
1247           "%s uses %s (refcounted: %d, userone: %d, used_one: %d, used_one_active: %d, "
1248           "indirect_usage: %d)\n",
1249           iter->curr_id->name,
1250           iter->id->name,
1251           (cb_flag & IDWALK_USER) ? 1 : 0,
1252           (cb_flag & IDWALK_USER_ONE) ? 1 : 0,
1253           (iter->id->tag & LIB_TAG_EXTRAUSER) ? 1 : 0,
1254           (iter->id->tag & LIB_TAG_EXTRAUSER_SET) ? 1 : 0,
1255           (cb_flag & IDWALK_INDIRECT_USAGE) ? 1 : 0);
1256 #endif
1257       if (cb_flag & IDWALK_CB_INDIRECT_USAGE) {
1258         iter->count_indirect++;
1259       }
1260       else {
1261         iter->count_direct++;
1262       }
1263     }
1264   }
1265
1266   return IDWALK_RET_NOP;
1267 }
1268
1269 /**
1270  * Return the number of times given \a id_user uses/references \a id_used.
1271  *
1272  * \note This only checks for pointer references of an ID, shallow usages
1273  * (like e.g. by RNA paths, as done for FCurves) are not detected at all.
1274  *
1275  * \param id_user: the ID which is supposed to use (reference) \a id_used.
1276  * \param id_used: the ID which is supposed to be used (referenced) by \a id_user.
1277  * \return the number of direct usages/references of \a id_used by \a id_user.
1278  */
1279 int BKE_library_ID_use_ID(ID *id_user, ID *id_used)
1280 {
1281   IDUsersIter iter;
1282
1283   /* We do not care about iter.lb_array/lb_idx here... */
1284   iter.id = id_used;
1285   iter.curr_id = id_user;
1286   iter.count_direct = iter.count_indirect = 0;
1287
1288   BKE_library_foreach_ID_link(
1289       NULL, iter.curr_id, foreach_libblock_id_users_callback, (void *)&iter, IDWALK_READONLY);
1290
1291   return iter.count_direct + iter.count_indirect;
1292 }
1293
1294 static bool library_ID_is_used(Main *bmain, void *idv, const bool check_linked)
1295 {
1296   IDUsersIter iter;
1297   ListBase *lb_array[MAX_LIBARRAY];
1298   ID *id = idv;
1299   int i = set_listbasepointers(bmain, lb_array);
1300   bool is_defined = false;
1301
1302   iter.id = id;
1303   iter.count_direct = iter.count_indirect = 0;
1304   while (i-- && !is_defined) {
1305     ID *id_curr = lb_array[i]->first;
1306
1307     if (!id_curr || !BKE_library_id_can_use_idtype(id_curr, GS(id->name))) {
1308       continue;
1309     }
1310
1311     for (; id_curr && !is_defined; id_curr = id_curr->next) {
1312       if (id_curr == id) {
1313         /* We are not interested in self-usages (mostly from drivers or bone constraints...). */
1314         continue;
1315       }
1316       iter.curr_id = id_curr;
1317       BKE_library_foreach_ID_link(
1318           bmain, id_curr, foreach_libblock_id_users_callback, &iter, IDWALK_READONLY);
1319
1320       is_defined = ((check_linked ? iter.count_indirect : iter.count_direct) != 0);
1321     }
1322   }
1323
1324   return is_defined;
1325 }
1326
1327 /**
1328  * Check whether given ID is used locally (i.e. by another non-linked ID).
1329  */
1330 bool BKE_library_ID_is_locally_used(Main *bmain, void *idv)
1331 {
1332   return library_ID_is_used(bmain, idv, false);
1333 }
1334
1335 /**
1336  * Check whether given ID is used indirectly (i.e. by another linked ID).
1337  */
1338 bool BKE_library_ID_is_indirectly_used(Main *bmain, void *idv)
1339 {
1340   return library_ID_is_used(bmain, idv, true);
1341 }
1342
1343 /**
1344  * Combine #BKE_library_ID_is_locally_used() and #BKE_library_ID_is_indirectly_used()
1345  * in a single call.
1346  */
1347 void BKE_library_ID_test_usages(Main *bmain, void *idv, bool *is_used_local, bool *is_used_linked)
1348 {
1349   IDUsersIter iter;
1350   ListBase *lb_array[MAX_LIBARRAY];
1351   ID *id = idv;
1352   int i = set_listbasepointers(bmain, lb_array);
1353   bool is_defined = false;
1354
1355   iter.id = id;
1356   iter.count_direct = iter.count_indirect = 0;
1357   while (i-- && !is_defined) {
1358     ID *id_curr = lb_array[i]->first;
1359
1360     if (!id_curr || !BKE_library_id_can_use_idtype(id_curr, GS(id->name))) {
1361       continue;
1362     }
1363
1364     for (; id_curr && !is_defined; id_curr = id_curr->next) {
1365       if (id_curr == id) {
1366         /* We are not interested in self-usages (mostly from drivers or bone constraints...). */
1367         continue;
1368       }
1369       iter.curr_id = id_curr;
1370       BKE_library_foreach_ID_link(
1371           bmain, id_curr, foreach_libblock_id_users_callback, &iter, IDWALK_READONLY);
1372
1373       is_defined = (iter.count_direct != 0 && iter.count_indirect != 0);
1374     }
1375   }
1376
1377   *is_used_local = (iter.count_direct != 0);
1378   *is_used_linked = (iter.count_indirect != 0);
1379 }
1380
1381 /* ***** IDs usages.checking/tagging. ***** */
1382 static int foreach_libblock_used_linked_data_tag_clear_cb(void *user_data,
1383                                                           ID *self_id,
1384                                                           ID **id_p,
1385                                                           int cb_flag)
1386 {
1387   bool *is_changed = user_data;
1388
1389   if (*id_p) {
1390     /* The infamous 'from' pointers (Key.from, Object.proxy_from, ...).
1391      * those are not actually ID usage, so we ignore them here. */
1392     if (cb_flag & IDWALK_CB_LOOPBACK) {
1393       return IDWALK_RET_NOP;
1394     }
1395
1396     /* If checked id is used by an assumed used ID,
1397      * then it is also used and not part of any linked archipelago. */
1398     if (!(self_id->tag & LIB_TAG_DOIT) && ((*id_p)->tag & LIB_TAG_DOIT)) {
1399       (*id_p)->tag &= ~LIB_TAG_DOIT;
1400       *is_changed = true;
1401     }
1402   }
1403
1404   return IDWALK_RET_NOP;
1405 }
1406
1407 /**
1408  * Detect orphaned linked data blocks (i.e. linked data not used (directly or indirectly)
1409  * in any way by any local data), including complex cases like 'linked archipelagoes', i.e.
1410  * linked data-blocks that use each other in loops,
1411  * which prevents their deletion by 'basic' usage checks.
1412  *
1413  * \param do_init_tag: if \a true, all linked data are checked, if \a false,
1414  * only linked data-blocks already tagged with #LIB_TAG_DOIT are checked.
1415  */
1416 void BKE_library_unused_linked_data_set_tag(Main *bmain, const bool do_init_tag)
1417 {
1418   ID *id;
1419
1420   if (do_init_tag) {
1421     FOREACH_MAIN_ID_BEGIN (bmain, id) {
1422       if (id->lib && (id->tag & LIB_TAG_INDIRECT) != 0) {
1423         id->tag |= LIB_TAG_DOIT;
1424       }
1425       else {
1426         id->tag &= ~LIB_TAG_DOIT;
1427       }
1428     }
1429     FOREACH_MAIN_ID_END;
1430   }
1431
1432   for (bool do_loop = true; do_loop;) {
1433     do_loop = false;
1434     FOREACH_MAIN_ID_BEGIN (bmain, id) {
1435       /* We only want to check that ID if it is currently known as used... */
1436       if ((id->tag & LIB_TAG_DOIT) == 0) {
1437         BKE_library_foreach_ID_link(
1438             bmain, id, foreach_libblock_used_linked_data_tag_clear_cb, &do_loop, IDWALK_READONLY);
1439       }
1440     }
1441     FOREACH_MAIN_ID_END;
1442   }
1443 }
1444
1445 /**
1446  * Untag linked data blocks used by other untagged linked data-blocks.
1447  * Used to detect data-blocks that we can forcefully make local
1448  * (instead of copying them to later get rid of original):
1449  * All data-blocks we want to make local are tagged by caller,
1450  * after this function has ran caller knows data-blocks still tagged can directly be made local,
1451  * since they are only used by other data-blocks that will also be made fully local.
1452  */
1453 void BKE_library_indirectly_used_data_tag_clear(Main *bmain)
1454 {
1455   ListBase *lb_array[MAX_LIBARRAY];
1456
1457   bool do_loop = true;
1458   while (do_loop) {
1459     int i = set_listbasepointers(bmain, lb_array);
1460     do_loop = false;
1461
1462     while (i--) {
1463       for (ID *id = lb_array[i]->first; id; id = id->next) {
1464         if (id->lib == NULL || id->tag & LIB_TAG_DOIT) {
1465           /* Local or non-indirectly-used ID (so far), no need to check it further. */
1466           continue;
1467         }
1468         BKE_library_foreach_ID_link(
1469             bmain, id, foreach_libblock_used_linked_data_tag_clear_cb, &do_loop, IDWALK_READONLY);
1470       }
1471     }
1472   }
1473 }