Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / library.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  *
23  * Contains management of ID's and libraries
24  * allocate and free of all library data
25  */
26
27 #include <stdio.h>
28 #include <ctype.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <stddef.h>
32 #include <assert.h>
33
34 #include "CLG_log.h"
35
36 #include "MEM_guardedalloc.h"
37
38 /* all types are needed here, in order to do memory operations */
39 #include "DNA_anim_types.h"
40 #include "DNA_armature_types.h"
41 #include "DNA_brush_types.h"
42 #include "DNA_cachefile_types.h"
43 #include "DNA_camera_types.h"
44 #include "DNA_collection_types.h"
45 #include "DNA_gpencil_types.h"
46 #include "DNA_ipo_types.h"
47 #include "DNA_key_types.h"
48 #include "DNA_light_types.h"
49 #include "DNA_lattice_types.h"
50 #include "DNA_linestyle_types.h"
51 #include "DNA_material_types.h"
52 #include "DNA_mesh_types.h"
53 #include "DNA_meta_types.h"
54 #include "DNA_modifier_types.h"
55 #include "DNA_movieclip_types.h"
56 #include "DNA_mask_types.h"
57 #include "DNA_node_types.h"
58 #include "DNA_object_types.h"
59 #include "DNA_lightprobe_types.h"
60 #include "DNA_scene_types.h"
61 #include "DNA_screen_types.h"
62 #include "DNA_speaker_types.h"
63 #include "DNA_sound_types.h"
64 #include "DNA_text_types.h"
65 #include "DNA_vfont_types.h"
66 #include "DNA_windowmanager_types.h"
67 #include "DNA_world_types.h"
68 #include "DNA_workspace_types.h"
69
70 #include "BLI_blenlib.h"
71 #include "BLI_utildefines.h"
72 #include "BLI_ghash.h"
73 #include "BLI_linklist.h"
74 #include "BLI_memarena.h"
75 #include "BLI_string_utils.h"
76
77 #include "BLT_translation.h"
78
79 #include "BKE_action.h"
80 #include "BKE_animsys.h"
81 #include "BKE_armature.h"
82 #include "BKE_bpath.h"
83 #include "BKE_brush.h"
84 #include "BKE_camera.h"
85 #include "BKE_cachefile.h"
86 #include "BKE_collection.h"
87 #include "BKE_context.h"
88 #include "BKE_curve.h"
89 #include "BKE_font.h"
90 #include "BKE_global.h"
91 #include "BKE_gpencil.h"
92 #include "BKE_idcode.h"
93 #include "BKE_idprop.h"
94 #include "BKE_image.h"
95 #include "BKE_key.h"
96 #include "BKE_light.h"
97 #include "BKE_lattice.h"
98 #include "BKE_library.h"
99 #include "BKE_library_query.h"
100 #include "BKE_library_remap.h"
101 #include "BKE_linestyle.h"
102 #include "BKE_mesh.h"
103 #include "BKE_mesh_runtime.h"
104 #include "BKE_material.h"
105 #include "BKE_main.h"
106 #include "BKE_mball.h"
107 #include "BKE_mask.h"
108 #include "BKE_movieclip.h"
109 #include "BKE_node.h"
110 #include "BKE_object.h"
111 #include "BKE_paint.h"
112 #include "BKE_particle.h"
113 #include "BKE_packedFile.h"
114 #include "BKE_lightprobe.h"
115 #include "BKE_rigidbody.h"
116 #include "BKE_sound.h"
117 #include "BKE_speaker.h"
118 #include "BKE_scene.h"
119 #include "BKE_text.h"
120 #include "BKE_texture.h"
121 #include "BKE_world.h"
122
123 #include "DEG_depsgraph.h"
124
125 #include "RNA_access.h"
126
127 #include "IMB_imbuf.h"
128 #include "IMB_imbuf_types.h"
129
130 #include "atomic_ops.h"
131
132 //#define DEBUG_TIME
133
134 #ifdef DEBUG_TIME
135 #  include "PIL_time_utildefines.h"
136 #endif
137
138 static CLG_LogRef LOG = {"bke.library"};
139
140 /* GS reads the memory pointed at in a specific ordering.
141  * only use this definition, makes little and big endian systems
142  * work fine, in conjunction with MAKE_ID */
143
144 /* ************* general ************************ */
145
146 /* this has to be called from each make_local_* func, we could call
147  * from id_make_local() but then the make local functions would not be self
148  * contained.
149  * also note that the id _must_ have a library - campbell */
150 void BKE_id_lib_local_paths(Main *bmain, Library *lib, ID *id)
151 {
152   const char *bpath_user_data[2] = {BKE_main_blendfile_path(bmain), lib->filepath};
153
154   BKE_bpath_traverse_id(bmain,
155                         id,
156                         BKE_bpath_relocate_visitor,
157                         BKE_BPATH_TRAVERSE_SKIP_MULTIFILE,
158                         (void *)bpath_user_data);
159 }
160
161 void id_lib_extern(ID *id)
162 {
163   if (id && ID_IS_LINKED(id)) {
164     BLI_assert(BKE_idcode_is_linkable(GS(id->name)));
165     if (id->tag & LIB_TAG_INDIRECT) {
166       id->tag &= ~LIB_TAG_INDIRECT;
167       id->tag |= LIB_TAG_EXTERN;
168       id->lib->parent = NULL;
169     }
170   }
171 }
172
173 /* ensure we have a real user */
174 /* Note: Now that we have flags, we could get rid of the 'fake_user' special case, flags are enough to ensure
175  *       we always have a real user.
176  *       However, ID_REAL_USERS is used in several places outside of core library.c, so think we can wait later
177  *       to make this change... */
178 void id_us_ensure_real(ID *id)
179 {
180   if (id) {
181     const int limit = ID_FAKE_USERS(id);
182     id->tag |= LIB_TAG_EXTRAUSER;
183     if (id->us <= limit) {
184       if (id->us < limit || ((id->us == limit) && (id->tag & LIB_TAG_EXTRAUSER_SET))) {
185         CLOG_ERROR(&LOG,
186                    "ID user count error: %s (from '%s')",
187                    id->name,
188                    id->lib ? id->lib->filepath : "[Main]");
189         BLI_assert(0);
190       }
191       id->us = limit + 1;
192       id->tag |= LIB_TAG_EXTRAUSER_SET;
193     }
194   }
195 }
196
197 void id_us_clear_real(ID *id)
198 {
199   if (id && (id->tag & LIB_TAG_EXTRAUSER)) {
200     if (id->tag & LIB_TAG_EXTRAUSER_SET) {
201       id->us--;
202       BLI_assert(id->us >= ID_FAKE_USERS(id));
203     }
204     id->tag &= ~(LIB_TAG_EXTRAUSER | LIB_TAG_EXTRAUSER_SET);
205   }
206 }
207
208 /**
209  * Same as \a id_us_plus, but does not handle lib indirect -> extern.
210  * Only used by readfile.c so far, but simpler/safer to keep it here nonetheless.
211  */
212 void id_us_plus_no_lib(ID *id)
213 {
214   if (id) {
215     if ((id->tag & LIB_TAG_EXTRAUSER) && (id->tag & LIB_TAG_EXTRAUSER_SET)) {
216       BLI_assert(id->us >= 1);
217       /* No need to increase count, just tag extra user as no more set.
218        * Avoids annoying & inconsistent +1 in user count. */
219       id->tag &= ~LIB_TAG_EXTRAUSER_SET;
220     }
221     else {
222       BLI_assert(id->us >= 0);
223       id->us++;
224     }
225   }
226 }
227
228 void id_us_plus(ID *id)
229 {
230   if (id) {
231     id_us_plus_no_lib(id);
232     id_lib_extern(id);
233   }
234 }
235
236 /* decrements the user count for *id. */
237 void id_us_min(ID *id)
238 {
239   if (id) {
240     const int limit = ID_FAKE_USERS(id);
241
242     if (id->us <= limit) {
243       CLOG_ERROR(&LOG,
244                  "ID user decrement error: %s (from '%s'): %d <= %d",
245                  id->name,
246                  id->lib ? id->lib->filepath : "[Main]",
247                  id->us,
248                  limit);
249       BLI_assert(0);
250       id->us = limit;
251     }
252     else {
253       id->us--;
254     }
255
256     if ((id->us == limit) && (id->tag & LIB_TAG_EXTRAUSER)) {
257       /* We need an extra user here, but never actually incremented user count for it so far, do it now. */
258       id_us_ensure_real(id);
259     }
260   }
261 }
262
263 void id_fake_user_set(ID *id)
264 {
265   if (id && !(id->flag & LIB_FAKEUSER)) {
266     id->flag |= LIB_FAKEUSER;
267     id_us_plus(id);
268   }
269 }
270
271 void id_fake_user_clear(ID *id)
272 {
273   if (id && (id->flag & LIB_FAKEUSER)) {
274     id->flag &= ~LIB_FAKEUSER;
275     id_us_min(id);
276   }
277 }
278
279 void BKE_id_clear_newpoin(ID *id)
280 {
281   if (id->newid) {
282     id->newid->tag &= ~LIB_TAG_NEW;
283   }
284   id->newid = NULL;
285 }
286
287 static int id_expand_local_callback(void *UNUSED(user_data),
288                                     struct ID *id_self,
289                                     struct ID **id_pointer,
290                                     int cb_flag)
291 {
292   if (cb_flag & IDWALK_CB_PRIVATE) {
293     return IDWALK_RET_NOP;
294   }
295
296   /* Can happen that we get unlinkable ID here, e.g. with shapekey referring to itself (through drivers)...
297    * Just skip it, shape key can only be either indirectly linked, or fully local, period.
298    * And let's curse one more time that stupid useless shapekey ID type! */
299   if (*id_pointer && *id_pointer != id_self && BKE_idcode_is_linkable(GS((*id_pointer)->name))) {
300     id_lib_extern(*id_pointer);
301   }
302
303   return IDWALK_RET_NOP;
304 }
305
306 /**
307  * Expand ID usages of given id as 'extern' (and no more indirect) linked data. Used by ID copy/make_local functions.
308  */
309 void BKE_id_expand_local(Main *bmain, ID *id)
310 {
311   BKE_library_foreach_ID_link(bmain, id, id_expand_local_callback, NULL, IDWALK_READONLY);
312 }
313
314 /**
315  * Ensure new (copied) ID is fully made local.
316  */
317 void BKE_id_copy_ensure_local(Main *bmain, const ID *old_id, ID *new_id)
318 {
319   if (ID_IS_LINKED(old_id)) {
320     BKE_id_expand_local(bmain, new_id);
321     BKE_id_lib_local_paths(bmain, old_id->lib, new_id);
322   }
323 }
324
325 /**
326  * Generic 'make local' function, works for most of datablock types...
327  */
328 void BKE_id_make_local_generic(Main *bmain,
329                                ID *id,
330                                const bool id_in_mainlist,
331                                const bool lib_local)
332 {
333   bool is_local = false, is_lib = false;
334
335   /* - only lib users: do nothing (unless force_local is set)
336    * - only local users: set flag
337    * - mixed: make copy
338    * In case we make a whole lib's content local, we always want to localize, and we skip remapping (done later).
339    */
340
341   if (!ID_IS_LINKED(id)) {
342     return;
343   }
344
345   BKE_library_ID_test_usages(bmain, id, &is_local, &is_lib);
346
347   if (lib_local || is_local) {
348     if (!is_lib) {
349       id_clear_lib_data_ex(bmain, id, id_in_mainlist);
350       BKE_id_expand_local(bmain, id);
351     }
352     else {
353       ID *id_new;
354
355       /* Should not fail in expected usecases, but a few ID types cannot be copied (LIB, WM, SCR...). */
356       if (BKE_id_copy(bmain, id, &id_new)) {
357         id_new->us = 0;
358
359         /* setting newid is mandatory for complex make_lib_local logic... */
360         ID_NEW_SET(id, id_new);
361         Key *key = BKE_key_from_id(id), *key_new = BKE_key_from_id(id);
362         if (key && key_new) {
363           ID_NEW_SET(key, key_new);
364         }
365         bNodeTree *ntree = ntreeFromID(id), *ntree_new = ntreeFromID(id_new);
366         if (ntree && ntree_new) {
367           ID_NEW_SET(ntree, ntree_new);
368         }
369
370         if (!lib_local) {
371           BKE_libblock_remap(bmain, id, id_new, ID_REMAP_SKIP_INDIRECT_USAGE);
372         }
373       }
374     }
375   }
376 }
377
378 /**
379  * Calls the appropriate make_local method for the block, unless test is set.
380  *
381  * \note Always set ID->newid pointer in case it gets duplicated...
382  *
383  * \param lib_local: Special flag used when making a whole library's content local, it needs specific handling.
384  *
385  * \return true if the block can be made local.
386  */
387 bool id_make_local(Main *bmain, ID *id, const bool test, const bool lib_local)
388 {
389   /* We don't care whether ID is directly or indirectly linked in case we are making a whole lib local... */
390   if (!lib_local && (id->tag & LIB_TAG_INDIRECT)) {
391     return false;
392   }
393
394   switch ((ID_Type)GS(id->name)) {
395     case ID_SCE:
396       if (!test) {
397         BKE_scene_make_local(bmain, (Scene *)id, lib_local);
398       }
399       return true;
400     case ID_OB:
401       if (!test) {
402         BKE_object_make_local(bmain, (Object *)id, lib_local);
403       }
404       return true;
405     case ID_ME:
406       if (!test) {
407         BKE_mesh_make_local(bmain, (Mesh *)id, lib_local);
408       }
409       return true;
410     case ID_CU:
411       if (!test) {
412         BKE_curve_make_local(bmain, (Curve *)id, lib_local);
413       }
414       return true;
415     case ID_MB:
416       if (!test) {
417         BKE_mball_make_local(bmain, (MetaBall *)id, lib_local);
418       }
419       return true;
420     case ID_MA:
421       if (!test) {
422         BKE_material_make_local(bmain, (Material *)id, lib_local);
423       }
424       return true;
425     case ID_TE:
426       if (!test) {
427         BKE_texture_make_local(bmain, (Tex *)id, lib_local);
428       }
429       return true;
430     case ID_IM:
431       if (!test) {
432         BKE_image_make_local(bmain, (Image *)id, lib_local);
433       }
434       return true;
435     case ID_LT:
436       if (!test) {
437         BKE_lattice_make_local(bmain, (Lattice *)id, lib_local);
438       }
439       return true;
440     case ID_LA:
441       if (!test) {
442         BKE_light_make_local(bmain, (Light *)id, lib_local);
443       }
444       return true;
445     case ID_CA:
446       if (!test) {
447         BKE_camera_make_local(bmain, (Camera *)id, lib_local);
448       }
449       return true;
450     case ID_SPK:
451       if (!test) {
452         BKE_speaker_make_local(bmain, (Speaker *)id, lib_local);
453       }
454       return true;
455     case ID_LP:
456       if (!test) {
457         BKE_lightprobe_make_local(bmain, (LightProbe *)id, lib_local);
458       }
459       return true;
460     case ID_WO:
461       if (!test) {
462         BKE_world_make_local(bmain, (World *)id, lib_local);
463       }
464       return true;
465     case ID_VF:
466       if (!test) {
467         BKE_vfont_make_local(bmain, (VFont *)id, lib_local);
468       }
469       return true;
470     case ID_TXT:
471       if (!test) {
472         BKE_text_make_local(bmain, (Text *)id, lib_local);
473       }
474       return true;
475     case ID_SO:
476       if (!test) {
477         BKE_sound_make_local(bmain, (bSound *)id, lib_local);
478       }
479       return true;
480     case ID_GR:
481       if (!test) {
482         BKE_collection_make_local(bmain, (Collection *)id, lib_local);
483       }
484       return true;
485     case ID_AR:
486       if (!test) {
487         BKE_armature_make_local(bmain, (bArmature *)id, lib_local);
488       }
489       return true;
490     case ID_AC:
491       if (!test) {
492         BKE_action_make_local(bmain, (bAction *)id, lib_local);
493       }
494       return true;
495     case ID_NT:
496       if (!test) {
497         ntreeMakeLocal(bmain, (bNodeTree *)id, true, lib_local);
498       }
499       return true;
500     case ID_BR:
501       if (!test) {
502         BKE_brush_make_local(bmain, (Brush *)id, lib_local);
503       }
504       return true;
505     case ID_PA:
506       if (!test) {
507         BKE_particlesettings_make_local(bmain, (ParticleSettings *)id, lib_local);
508       }
509       return true;
510     case ID_GD:
511       if (!test) {
512         BKE_gpencil_make_local(bmain, (bGPdata *)id, lib_local);
513       }
514       return true;
515     case ID_MC:
516       if (!test) {
517         BKE_movieclip_make_local(bmain, (MovieClip *)id, lib_local);
518       }
519       return true;
520     case ID_MSK:
521       if (!test) {
522         BKE_mask_make_local(bmain, (Mask *)id, lib_local);
523       }
524       return true;
525     case ID_LS:
526       if (!test) {
527         BKE_linestyle_make_local(bmain, (FreestyleLineStyle *)id, lib_local);
528       }
529       return true;
530     case ID_PAL:
531       if (!test) {
532         BKE_palette_make_local(bmain, (Palette *)id, lib_local);
533       }
534       return true;
535     case ID_PC:
536       if (!test) {
537         BKE_paint_curve_make_local(bmain, (PaintCurve *)id, lib_local);
538       }
539       return true;
540     case ID_CF:
541       if (!test) {
542         BKE_cachefile_make_local(bmain, (CacheFile *)id, lib_local);
543       }
544       return true;
545     case ID_WS:
546     case ID_SCR:
547       /* A bit special: can be appended but not linked. Return false
548        * since supporting make-local doesn't make much sense. */
549       return false;
550     case ID_LI:
551     case ID_KE:
552     case ID_WM:
553       return false; /* can't be linked */
554     case ID_IP:
555       return false; /* deprecated */
556   }
557
558   return false;
559 }
560
561 struct IDCopyLibManagementData {
562   const ID *id_src;
563   ID *id_dst;
564   int flag;
565 };
566
567 /* Increases usercount as required, and remap self ID pointers. */
568 static int id_copy_libmanagement_cb(void *user_data,
569                                     ID *UNUSED(id_self),
570                                     ID **id_pointer,
571                                     int cb_flag)
572 {
573   struct IDCopyLibManagementData *data = user_data;
574   ID *id = *id_pointer;
575
576   /* Remap self-references to new copied ID. */
577   if (id == data->id_src) {
578     /* We cannot use id_self here, it is not *always* id_dst (thanks to $£!+@#&/? nodetrees). */
579     id = *id_pointer = data->id_dst;
580   }
581
582   /* Increase used IDs refcount if needed and required. */
583   if ((data->flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0 && (cb_flag & IDWALK_CB_USER)) {
584     id_us_plus(id);
585   }
586
587   return IDWALK_RET_NOP;
588 }
589
590 bool BKE_id_copy_is_allowed(const ID *id)
591 {
592 #define LIB_ID_TYPES_NOCOPY \
593   ID_LI, ID_SCR, ID_WM, ID_WS, /* Not supported */ \
594       ID_IP                    /* Deprecated */
595
596   return !ELEM(GS(id->name), LIB_ID_TYPES_NOCOPY);
597
598 #undef LIB_ID_TYPES_NOCOPY
599 }
600
601 /**
602  * Generic entry point for copying a datablock (new API).
603  *
604  * \note Copy is only affecting given data-block (no ID used by copied one will be affected, besides usercount).
605  *       There is only one exception, if LIB_ID_COPY_ACTIONS is defined, actions used by animdata will be duplicated.
606  *
607  * \note Usercount of new copy is always set to 1.
608  *
609  * \param bmain: Main database, may be NULL only if LIB_ID_CREATE_NO_MAIN is specified.
610  * \param id: Source datablock.
611  * \param r_newid: Pointer to new (copied) ID pointer.
612  * \param flag: Set of copy options, see DNA_ID.h enum for details (leave to zero for default, full copy).
613  * \return False when copying that ID type is not supported, true otherwise.
614  */
615 bool BKE_id_copy_ex(Main *bmain, const ID *id, ID **r_newid, const int flag)
616 {
617   BLI_assert(r_newid != NULL);
618   /* Make sure destination pointer is all good. */
619   if ((flag & LIB_ID_CREATE_NO_ALLOCATE) == 0) {
620     *r_newid = NULL;
621   }
622   else {
623     if (*r_newid != NULL) {
624       /* Allow some garbage non-initialized memory to go in, and clean it up here. */
625       const size_t size = BKE_libblock_get_alloc_info(GS(id->name), NULL);
626       memset(*r_newid, 0, size);
627     }
628   }
629
630   /* Early output is source is NULL. */
631   if (id == NULL) {
632     return false;
633   }
634   if (!BKE_id_copy_is_allowed(id)) {
635     return false;
636   }
637
638   BKE_libblock_copy_ex(bmain, id, r_newid, flag);
639
640   switch ((ID_Type)GS(id->name)) {
641     case ID_SCE:
642       BKE_scene_copy_data(bmain, (Scene *)*r_newid, (Scene *)id, flag);
643       break;
644     case ID_OB:
645       BKE_object_copy_data(bmain, (Object *)*r_newid, (Object *)id, flag);
646       break;
647     case ID_ME:
648       BKE_mesh_copy_data(bmain, (Mesh *)*r_newid, (Mesh *)id, flag);
649       break;
650     case ID_CU:
651       BKE_curve_copy_data(bmain, (Curve *)*r_newid, (Curve *)id, flag);
652       break;
653     case ID_MB:
654       BKE_mball_copy_data(bmain, (MetaBall *)*r_newid, (MetaBall *)id, flag);
655       break;
656     case ID_MA:
657       BKE_material_copy_data(bmain, (Material *)*r_newid, (Material *)id, flag);
658       break;
659     case ID_TE:
660       BKE_texture_copy_data(bmain, (Tex *)*r_newid, (Tex *)id, flag);
661       break;
662     case ID_IM:
663       BKE_image_copy_data(bmain, (Image *)*r_newid, (Image *)id, flag);
664       break;
665     case ID_LT:
666       BKE_lattice_copy_data(bmain, (Lattice *)*r_newid, (Lattice *)id, flag);
667       break;
668     case ID_LA:
669       BKE_light_copy_data(bmain, (Light *)*r_newid, (Light *)id, flag);
670       break;
671     case ID_SPK:
672       BKE_speaker_copy_data(bmain, (Speaker *)*r_newid, (Speaker *)id, flag);
673       break;
674     case ID_LP:
675       BKE_lightprobe_copy_data(bmain, (LightProbe *)*r_newid, (LightProbe *)id, flag);
676       break;
677     case ID_CA:
678       BKE_camera_copy_data(bmain, (Camera *)*r_newid, (Camera *)id, flag);
679       break;
680     case ID_KE:
681       BKE_key_copy_data(bmain, (Key *)*r_newid, (Key *)id, flag);
682       break;
683     case ID_WO:
684       BKE_world_copy_data(bmain, (World *)*r_newid, (World *)id, flag);
685       break;
686     case ID_TXT:
687       BKE_text_copy_data(bmain, (Text *)*r_newid, (Text *)id, flag);
688       break;
689     case ID_GR:
690       BKE_collection_copy_data(bmain, (Collection *)*r_newid, (Collection *)id, flag);
691       break;
692     case ID_AR:
693       BKE_armature_copy_data(bmain, (bArmature *)*r_newid, (bArmature *)id, flag);
694       break;
695     case ID_AC:
696       BKE_action_copy_data(bmain, (bAction *)*r_newid, (bAction *)id, flag);
697       break;
698     case ID_NT:
699       BKE_node_tree_copy_data(bmain, (bNodeTree *)*r_newid, (bNodeTree *)id, flag);
700       break;
701     case ID_BR:
702       BKE_brush_copy_data(bmain, (Brush *)*r_newid, (Brush *)id, flag);
703       break;
704     case ID_PA:
705       BKE_particlesettings_copy_data(
706           bmain, (ParticleSettings *)*r_newid, (ParticleSettings *)id, flag);
707       break;
708     case ID_GD:
709       BKE_gpencil_copy_data((bGPdata *)*r_newid, (bGPdata *)id, flag);
710       break;
711     case ID_MC:
712       BKE_movieclip_copy_data(bmain, (MovieClip *)*r_newid, (MovieClip *)id, flag);
713       break;
714     case ID_MSK:
715       BKE_mask_copy_data(bmain, (Mask *)*r_newid, (Mask *)id, flag);
716       break;
717     case ID_LS:
718       BKE_linestyle_copy_data(
719           bmain, (FreestyleLineStyle *)*r_newid, (FreestyleLineStyle *)id, flag);
720       break;
721     case ID_PAL:
722       BKE_palette_copy_data(bmain, (Palette *)*r_newid, (Palette *)id, flag);
723       break;
724     case ID_PC:
725       BKE_paint_curve_copy_data(bmain, (PaintCurve *)*r_newid, (PaintCurve *)id, flag);
726       break;
727     case ID_CF:
728       BKE_cachefile_copy_data(bmain, (CacheFile *)*r_newid, (CacheFile *)id, flag);
729       break;
730     case ID_SO:
731       BKE_sound_copy_data(bmain, (bSound *)*r_newid, (bSound *)id, flag);
732       break;
733     case ID_VF:
734       BKE_vfont_copy_data(bmain, (VFont *)*r_newid, (VFont *)id, flag);
735       break;
736     case ID_LI:
737     case ID_SCR:
738     case ID_WM:
739     case ID_WS:
740     case ID_IP:
741       BLI_assert(0); /* Should have been rejected at start of function! */
742       break;
743   }
744
745   /* Update ID refcount, remap pointers to self in new ID. */
746   struct IDCopyLibManagementData data = {
747       .id_src = id,
748       .id_dst = *r_newid,
749       .flag = flag,
750   };
751   BKE_library_foreach_ID_link(bmain, *r_newid, id_copy_libmanagement_cb, &data, IDWALK_NOP);
752
753   /* Do not make new copy local in case we are copying outside of main...
754    * XXX TODO: is this behavior OK, or should we need own flag to control that? */
755   if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
756     BLI_assert((flag & LIB_ID_COPY_KEEP_LIB) == 0);
757     BKE_id_copy_ensure_local(bmain, id, *r_newid);
758   }
759   else {
760     (*r_newid)->lib = id->lib;
761   }
762
763   return true;
764 }
765
766 /**
767  * Invokes the appropriate copy method for the block and returns the result in
768  * newid, unless test. Returns true if the block can be copied.
769  */
770 bool BKE_id_copy(Main *bmain, const ID *id, ID **newid)
771 {
772   return BKE_id_copy_ex(bmain, id, newid, LIB_ID_COPY_DEFAULT);
773 }
774
775 /** Does a mere memory swap over the whole IDs data (including type-specific memory).
776  * \note Most internal ID data itself is not swapped (only IDProperties are). */
777 void BKE_id_swap(Main *bmain, ID *id_a, ID *id_b)
778 {
779   BLI_assert(GS(id_a->name) == GS(id_b->name));
780
781   const ID id_a_back = *id_a;
782   const ID id_b_back = *id_b;
783
784 #define CASE_SWAP(_gs, _type) \
785   case _gs: \
786     SWAP(_type, *(_type *)id_a, *(_type *)id_b); \
787     break
788
789   switch ((ID_Type)GS(id_a->name)) {
790     CASE_SWAP(ID_SCE, Scene);
791     CASE_SWAP(ID_LI, Library);
792     CASE_SWAP(ID_OB, Object);
793     CASE_SWAP(ID_ME, Mesh);
794     CASE_SWAP(ID_CU, Curve);
795     CASE_SWAP(ID_MB, MetaBall);
796     CASE_SWAP(ID_MA, Material);
797     CASE_SWAP(ID_TE, Tex);
798     CASE_SWAP(ID_IM, Image);
799     CASE_SWAP(ID_LT, Lattice);
800     CASE_SWAP(ID_LA, Light);
801     CASE_SWAP(ID_LP, LightProbe);
802     CASE_SWAP(ID_CA, Camera);
803     CASE_SWAP(ID_KE, Key);
804     CASE_SWAP(ID_WO, World);
805     CASE_SWAP(ID_SCR, bScreen);
806     CASE_SWAP(ID_VF, VFont);
807     CASE_SWAP(ID_TXT, Text);
808     CASE_SWAP(ID_SPK, Speaker);
809     CASE_SWAP(ID_SO, bSound);
810     CASE_SWAP(ID_GR, Collection);
811     CASE_SWAP(ID_AR, bArmature);
812     CASE_SWAP(ID_AC, bAction);
813     CASE_SWAP(ID_NT, bNodeTree);
814     CASE_SWAP(ID_BR, Brush);
815     CASE_SWAP(ID_PA, ParticleSettings);
816     CASE_SWAP(ID_WM, wmWindowManager);
817     CASE_SWAP(ID_WS, WorkSpace);
818     CASE_SWAP(ID_GD, bGPdata);
819     CASE_SWAP(ID_MC, MovieClip);
820     CASE_SWAP(ID_MSK, Mask);
821     CASE_SWAP(ID_LS, FreestyleLineStyle);
822     CASE_SWAP(ID_PAL, Palette);
823     CASE_SWAP(ID_PC, PaintCurve);
824     CASE_SWAP(ID_CF, CacheFile);
825     case ID_IP:
826       break; /* Deprecated. */
827   }
828
829 #undef CASE_SWAP
830
831   /* Restore original ID's internal data. */
832   *id_a = id_a_back;
833   *id_b = id_b_back;
834
835   /* Exception: IDProperties. */
836   id_a->properties = id_b_back.properties;
837   id_b->properties = id_a_back.properties;
838
839   /* Swap will have broken internal references to itself, restore them. */
840   BKE_libblock_relink_ex(bmain, id_a, id_b, id_a, false);
841   BKE_libblock_relink_ex(bmain, id_b, id_a, id_b, false);
842 }
843
844 /** Does *not* set ID->newid pointer. */
845 bool id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
846 {
847   ID *newid = NULL;
848   PointerRNA idptr;
849
850   if (id) {
851     /* if property isn't editable, we're going to have an extra block hanging around until we save */
852     if (RNA_property_editable(ptr, prop)) {
853       Main *bmain = CTX_data_main(C);
854       /* copy animation actions too */
855       if (BKE_id_copy_ex(bmain, id, &newid, LIB_ID_COPY_DEFAULT | LIB_ID_COPY_ACTIONS) && newid) {
856         /* us is 1 by convention with new IDs, but RNA_property_pointer_set
857          * will also increment it, decrement it here. */
858         id_us_min(newid);
859
860         /* assign copy */
861         RNA_id_pointer_create(newid, &idptr);
862         RNA_property_pointer_set(ptr, prop, idptr);
863         RNA_property_update(C, ptr, prop);
864
865         /* tag grease pencil datablock and disable onion */
866         if (GS(id->name) == ID_GD) {
867           DEG_id_tag_update(id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
868           DEG_id_tag_update(newid, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
869           bGPdata *gpd = (bGPdata *)newid;
870           gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
871         }
872
873         return true;
874       }
875     }
876   }
877
878   return false;
879 }
880
881 static int libblock_management_us_plus(void *UNUSED(user_data),
882                                        ID *UNUSED(id_self),
883                                        ID **id_pointer,
884                                        int cb_flag)
885 {
886   if (cb_flag & IDWALK_CB_USER) {
887     id_us_plus(*id_pointer);
888   }
889   if (cb_flag & IDWALK_CB_USER_ONE) {
890     id_us_ensure_real(*id_pointer);
891   }
892
893   return IDWALK_RET_NOP;
894 }
895
896 static int libblock_management_us_min(void *UNUSED(user_data),
897                                       ID *UNUSED(id_self),
898                                       ID **id_pointer,
899                                       int cb_flag)
900 {
901   if (cb_flag & IDWALK_CB_USER) {
902     id_us_min(*id_pointer);
903   }
904   /* We can do nothing in IDWALK_CB_USER_ONE case! */
905
906   return IDWALK_RET_NOP;
907 }
908
909 /** Add a 'NO_MAIN' datablock to given main (also sets usercounts of its IDs if needed). */
910 void BKE_libblock_management_main_add(Main *bmain, void *idv)
911 {
912   ID *id = idv;
913
914   BLI_assert(bmain != NULL);
915   if ((id->tag & LIB_TAG_NO_MAIN) == 0) {
916     return;
917   }
918
919   if ((id->tag & LIB_TAG_NOT_ALLOCATED) != 0) {
920     /* We cannot add non-allocated ID to Main! */
921     return;
922   }
923
924   /* We cannot allow non-userrefcounting IDs in Main database! */
925   if ((id->tag & LIB_TAG_NO_USER_REFCOUNT) != 0) {
926     BKE_library_foreach_ID_link(bmain, id, libblock_management_us_plus, NULL, IDWALK_NOP);
927   }
928
929   ListBase *lb = which_libbase(bmain, GS(id->name));
930   BKE_main_lock(bmain);
931   BLI_addtail(lb, id);
932   BKE_id_new_name_validate(lb, id, NULL);
933   /* alphabetic insertion: is in new_id */
934   id->tag &= ~(LIB_TAG_NO_MAIN | LIB_TAG_NO_USER_REFCOUNT);
935   bmain->is_memfile_undo_written = false;
936   BKE_main_unlock(bmain);
937 }
938
939 /** Remove a datablock from given main (set it to 'NO_MAIN' status). */
940 void BKE_libblock_management_main_remove(Main *bmain, void *idv)
941 {
942   ID *id = idv;
943
944   BLI_assert(bmain != NULL);
945   if ((id->tag & LIB_TAG_NO_MAIN) != 0) {
946     return;
947   }
948
949   /* For now, allow userrefcounting IDs to get out of Main - can be handy in some cases... */
950
951   ListBase *lb = which_libbase(bmain, GS(id->name));
952   BKE_main_lock(bmain);
953   BLI_remlink(lb, id);
954   id->tag |= LIB_TAG_NO_MAIN;
955   bmain->is_memfile_undo_written = false;
956   BKE_main_unlock(bmain);
957 }
958
959 void BKE_libblock_management_usercounts_set(Main *bmain, void *idv)
960 {
961   ID *id = idv;
962
963   if ((id->tag & LIB_TAG_NO_USER_REFCOUNT) == 0) {
964     return;
965   }
966
967   BKE_library_foreach_ID_link(bmain, id, libblock_management_us_plus, NULL, IDWALK_NOP);
968   id->tag &= ~LIB_TAG_NO_USER_REFCOUNT;
969 }
970
971 void BKE_libblock_management_usercounts_clear(Main *bmain, void *idv)
972 {
973   ID *id = idv;
974
975   /* We do not allow IDs in Main database to not be userrefcounting. */
976   if ((id->tag & LIB_TAG_NO_USER_REFCOUNT) != 0 || (id->tag & LIB_TAG_NO_MAIN) != 0) {
977     return;
978   }
979
980   BKE_library_foreach_ID_link(bmain, id, libblock_management_us_min, NULL, IDWALK_NOP);
981   id->tag |= LIB_TAG_NO_USER_REFCOUNT;
982 }
983
984 /**
985  * Clear or set given tags for all ids in listbase (runtime tags).
986  */
987 void BKE_main_id_tag_listbase(ListBase *lb, const int tag, const bool value)
988 {
989   ID *id;
990   if (value) {
991     for (id = lb->first; id; id = id->next) {
992       id->tag |= tag;
993     }
994   }
995   else {
996     const int ntag = ~tag;
997     for (id = lb->first; id; id = id->next) {
998       id->tag &= ntag;
999     }
1000   }
1001 }
1002
1003 /**
1004  * Clear or set given tags for all ids of given type in bmain (runtime tags).
1005  */
1006 void BKE_main_id_tag_idcode(struct Main *mainvar,
1007                             const short type,
1008                             const int tag,
1009                             const bool value)
1010 {
1011   ListBase *lb = which_libbase(mainvar, type);
1012
1013   BKE_main_id_tag_listbase(lb, tag, value);
1014 }
1015
1016 /**
1017  * Clear or set given tags for all ids in bmain (runtime tags).
1018  */
1019 void BKE_main_id_tag_all(struct Main *mainvar, const int tag, const bool value)
1020 {
1021   ListBase *lbarray[MAX_LIBARRAY];
1022   int a;
1023
1024   a = set_listbasepointers(mainvar, lbarray);
1025   while (a--) {
1026     BKE_main_id_tag_listbase(lbarray[a], tag, value);
1027   }
1028 }
1029
1030 /**
1031  * Clear or set given flags for all ids in listbase (persistent flags).
1032  */
1033 void BKE_main_id_flag_listbase(ListBase *lb, const int flag, const bool value)
1034 {
1035   ID *id;
1036   if (value) {
1037     for (id = lb->first; id; id = id->next) {
1038       id->tag |= flag;
1039     }
1040   }
1041   else {
1042     const int nflag = ~flag;
1043     for (id = lb->first; id; id = id->next) {
1044       id->tag &= nflag;
1045     }
1046   }
1047 }
1048
1049 /**
1050  * Clear or set given flags for all ids in bmain (persistent flags).
1051  */
1052 void BKE_main_id_flag_all(Main *bmain, const int flag, const bool value)
1053 {
1054   ListBase *lbarray[MAX_LIBARRAY];
1055   int a;
1056   a = set_listbasepointers(bmain, lbarray);
1057   while (a--) {
1058     BKE_main_id_flag_listbase(lbarray[a], flag, value);
1059   }
1060 }
1061
1062 void BKE_main_id_repair_duplicate_names_listbase(ListBase *lb)
1063 {
1064   int lb_len = 0;
1065   for (ID *id = lb->first; id; id = id->next) {
1066     if (id->lib == NULL) {
1067       lb_len += 1;
1068     }
1069   }
1070   if (lb_len <= 1) {
1071     return;
1072   }
1073
1074   /* Fill an array because renaming sorts. */
1075   ID **id_array = MEM_mallocN(sizeof(*id_array) * lb_len, __func__);
1076   GSet *gset = BLI_gset_str_new_ex(__func__, lb_len);
1077   int i = 0;
1078   for (ID *id = lb->first; id; id = id->next) {
1079     if (id->lib == NULL) {
1080       id_array[i] = id;
1081       i++;
1082     }
1083   }
1084   for (i = 0; i < lb_len; i++) {
1085     if (!BLI_gset_add(gset, id_array[i]->name + 2)) {
1086       BKE_id_new_name_validate(lb, id_array[i], NULL);
1087     }
1088   }
1089   BLI_gset_free(gset, NULL);
1090   MEM_freeN(id_array);
1091 }
1092
1093 void BKE_main_lib_objects_recalc_all(Main *bmain)
1094 {
1095   Object *ob;
1096
1097   /* flag for full recalc */
1098   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1099     if (ID_IS_LINKED(ob)) {
1100       DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1101     }
1102   }
1103
1104   DEG_id_type_tag(bmain, ID_OB);
1105 }
1106
1107 /* *********** ALLOC AND FREE *****************
1108  *
1109  * BKE_libblock_free(ListBase *lb, ID *id )
1110  * provide a list-basis and datablock, but only ID is read
1111  *
1112  * void *BKE_libblock_alloc(ListBase *lb, type, name)
1113  * inserts in list and returns a new ID
1114  *
1115  * **************************** */
1116
1117 /**
1118  * Get allocation size fo a given datablock type and optionally allocation name.
1119  */
1120 size_t BKE_libblock_get_alloc_info(short type, const char **name)
1121 {
1122 #define CASE_RETURN(id_code, type) \
1123   case id_code: \
1124     do { \
1125       if (name != NULL) { \
1126         *name = #type; \
1127       } \
1128       return sizeof(type); \
1129     } while (0)
1130
1131   switch ((ID_Type)type) {
1132     CASE_RETURN(ID_SCE, Scene);
1133     CASE_RETURN(ID_LI, Library);
1134     CASE_RETURN(ID_OB, Object);
1135     CASE_RETURN(ID_ME, Mesh);
1136     CASE_RETURN(ID_CU, Curve);
1137     CASE_RETURN(ID_MB, MetaBall);
1138     CASE_RETURN(ID_MA, Material);
1139     CASE_RETURN(ID_TE, Tex);
1140     CASE_RETURN(ID_IM, Image);
1141     CASE_RETURN(ID_LT, Lattice);
1142     CASE_RETURN(ID_LA, Light);
1143     CASE_RETURN(ID_CA, Camera);
1144     CASE_RETURN(ID_IP, Ipo);
1145     CASE_RETURN(ID_KE, Key);
1146     CASE_RETURN(ID_WO, World);
1147     CASE_RETURN(ID_SCR, bScreen);
1148     CASE_RETURN(ID_VF, VFont);
1149     CASE_RETURN(ID_TXT, Text);
1150     CASE_RETURN(ID_SPK, Speaker);
1151     CASE_RETURN(ID_LP, LightProbe);
1152     CASE_RETURN(ID_SO, bSound);
1153     CASE_RETURN(ID_GR, Collection);
1154     CASE_RETURN(ID_AR, bArmature);
1155     CASE_RETURN(ID_AC, bAction);
1156     CASE_RETURN(ID_NT, bNodeTree);
1157     CASE_RETURN(ID_BR, Brush);
1158     CASE_RETURN(ID_PA, ParticleSettings);
1159     CASE_RETURN(ID_WM, wmWindowManager);
1160     CASE_RETURN(ID_GD, bGPdata);
1161     CASE_RETURN(ID_MC, MovieClip);
1162     CASE_RETURN(ID_MSK, Mask);
1163     CASE_RETURN(ID_LS, FreestyleLineStyle);
1164     CASE_RETURN(ID_PAL, Palette);
1165     CASE_RETURN(ID_PC, PaintCurve);
1166     CASE_RETURN(ID_CF, CacheFile);
1167     CASE_RETURN(ID_WS, WorkSpace);
1168   }
1169   return 0;
1170 #undef CASE_RETURN
1171 }
1172
1173 /**
1174  * Allocates and returns memory of the right size for the specified block type,
1175  * initialized to zero.
1176  */
1177 void *BKE_libblock_alloc_notest(short type)
1178 {
1179   const char *name;
1180   size_t size = BKE_libblock_get_alloc_info(type, &name);
1181   if (size != 0) {
1182     return MEM_callocN(size, name);
1183   }
1184   BLI_assert(!"Request to allocate unknown data type");
1185   return NULL;
1186 }
1187
1188 /**
1189  * Allocates and returns a block of the specified type, with the specified name
1190  * (adjusted as necessary to ensure uniqueness), and appended to the specified list.
1191  * The user count is set to 1, all other content (apart from name and links) being
1192  * initialized to zero.
1193  */
1194 void *BKE_libblock_alloc(Main *bmain, short type, const char *name, const int flag)
1195 {
1196   BLI_assert((flag & LIB_ID_CREATE_NO_ALLOCATE) == 0);
1197
1198   ID *id = BKE_libblock_alloc_notest(type);
1199
1200   if (id) {
1201     if ((flag & LIB_ID_CREATE_NO_MAIN) != 0) {
1202       id->tag |= LIB_TAG_NO_MAIN;
1203     }
1204     if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) != 0) {
1205       id->tag |= LIB_TAG_NO_USER_REFCOUNT;
1206     }
1207
1208     id->icon_id = 0;
1209     *((short *)id->name) = type;
1210     if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1211       id->us = 1;
1212     }
1213     if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
1214       ListBase *lb = which_libbase(bmain, type);
1215
1216       BKE_main_lock(bmain);
1217       BLI_addtail(lb, id);
1218       BKE_id_new_name_validate(lb, id, name);
1219       bmain->is_memfile_undo_written = false;
1220       /* alphabetic insertion: is in new_id */
1221       BKE_main_unlock(bmain);
1222
1223       /* TODO to be removed from here! */
1224       if ((flag & LIB_ID_CREATE_NO_DEG_TAG) == 0) {
1225         DEG_id_type_tag(bmain, type);
1226       }
1227     }
1228     else {
1229       BLI_strncpy(id->name + 2, name, sizeof(id->name) - 2);
1230     }
1231   }
1232
1233   return id;
1234 }
1235
1236 /**
1237  * Initialize an ID of given type, such that it has valid 'empty' data.
1238  * ID is assumed to be just calloc'ed.
1239  */
1240 void BKE_libblock_init_empty(ID *id)
1241 {
1242   /* Note that only ID types that are not valid when filled of zero should have a callback here. */
1243   switch ((ID_Type)GS(id->name)) {
1244     case ID_SCE:
1245       BKE_scene_init((Scene *)id);
1246       break;
1247     case ID_LI:
1248       /* Nothing to do. */
1249       break;
1250     case ID_OB: {
1251       Object *ob = (Object *)id;
1252       ob->type = OB_EMPTY;
1253       BKE_object_init(ob);
1254       break;
1255     }
1256     case ID_ME:
1257       BKE_mesh_init((Mesh *)id);
1258       break;
1259     case ID_CU:
1260       BKE_curve_init((Curve *)id);
1261       break;
1262     case ID_MB:
1263       BKE_mball_init((MetaBall *)id);
1264       break;
1265     case ID_MA:
1266       BKE_material_init((Material *)id);
1267       break;
1268     case ID_TE:
1269       BKE_texture_default((Tex *)id);
1270       break;
1271     case ID_IM:
1272       BKE_image_init((Image *)id);
1273       break;
1274     case ID_LT:
1275       BKE_lattice_init((Lattice *)id);
1276       break;
1277     case ID_LA:
1278       BKE_light_init((Light *)id);
1279       break;
1280     case ID_SPK:
1281       BKE_speaker_init((Speaker *)id);
1282       break;
1283     case ID_LP:
1284       BKE_lightprobe_init((LightProbe *)id);
1285       break;
1286     case ID_CA:
1287       BKE_camera_init((Camera *)id);
1288       break;
1289     case ID_WO:
1290       BKE_world_init((World *)id);
1291       break;
1292     case ID_SCR:
1293       /* Nothing to do. */
1294       break;
1295     case ID_VF:
1296       BKE_vfont_init((VFont *)id);
1297       break;
1298     case ID_TXT:
1299       BKE_text_init((Text *)id);
1300       break;
1301     case ID_SO:
1302       /* Another fuzzy case, think NULLified content is OK here... */
1303       break;
1304     case ID_GR:
1305       /* Nothing to do. */
1306       break;
1307     case ID_AR:
1308       /* Nothing to do. */
1309       break;
1310     case ID_AC:
1311       /* Nothing to do. */
1312       break;
1313     case ID_NT:
1314       ntreeInitDefault((bNodeTree *)id);
1315       break;
1316     case ID_BR:
1317       BKE_brush_init((Brush *)id);
1318       break;
1319     case ID_PA:
1320       /* Nothing to do. */
1321       break;
1322     case ID_PC:
1323       /* Nothing to do. */
1324       break;
1325     case ID_GD:
1326       /* Nothing to do. */
1327       break;
1328     case ID_MSK:
1329       /* Nothing to do. */
1330       break;
1331     case ID_LS:
1332       BKE_linestyle_init((FreestyleLineStyle *)id);
1333       break;
1334     case ID_CF:
1335       BKE_cachefile_init((CacheFile *)id);
1336       break;
1337     case ID_KE:
1338       /* Shapekeys are a complex topic too - they depend on their 'user' data type...
1339        * They are not linkable, though, so it should never reach here anyway. */
1340       BLI_assert(0);
1341       break;
1342     case ID_WM:
1343       /* We should never reach this. */
1344       BLI_assert(0);
1345       break;
1346     case ID_IP:
1347       /* Should not be needed - animation from lib pre-2.5 is broken anyway. */
1348       BLI_assert(0);
1349       break;
1350     case ID_PAL:
1351       BKE_palette_init((Palette *)id);
1352       break;
1353     default:
1354       BLI_assert(0); /* Should never reach this point... */
1355   }
1356 }
1357
1358 /** Generic helper to create a new empty datablock of given type in given \a bmain database.
1359  *
1360  * \param name: can be NULL, in which case we get default name for this ID type. */
1361 void *BKE_id_new(Main *bmain, const short type, const char *name)
1362 {
1363   BLI_assert(bmain != NULL);
1364
1365   if (name == NULL) {
1366     name = DATA_(BKE_idcode_to_name(type));
1367   }
1368
1369   ID *id = BKE_libblock_alloc(bmain, type, name, 0);
1370   BKE_libblock_init_empty(id);
1371
1372   return id;
1373 }
1374
1375 /** Generic helper to create a new temporary empty datablock of given type, *outside* of any Main database.
1376  *
1377  * \param name: can be NULL, in which case we get default name for this ID type. */
1378 void *BKE_id_new_nomain(const short type, const char *name)
1379 {
1380   if (name == NULL) {
1381     name = DATA_(BKE_idcode_to_name(type));
1382   }
1383
1384   ID *id = BKE_libblock_alloc(NULL,
1385                               type,
1386                               name,
1387                               LIB_ID_CREATE_NO_MAIN | LIB_ID_CREATE_NO_USER_REFCOUNT |
1388                                   LIB_ID_CREATE_NO_DEG_TAG);
1389   BKE_libblock_init_empty(id);
1390
1391   return id;
1392 }
1393
1394 void BKE_libblock_copy_ex(Main *bmain, const ID *id, ID **r_newid, const int flag)
1395 {
1396   ID *new_id = *r_newid;
1397
1398   /* Grrrrrrrrr... Not adding 'root' nodetrees to bmain.... grrrrrrrrrrrrrrrrrrrr! */
1399   /* This is taken from original ntree copy code, might be weak actually? */
1400   const bool use_nodetree_alloc_exception = ((GS(id->name) == ID_NT) && (bmain != NULL) &&
1401                                              (BLI_findindex(&bmain->nodetrees, id) < 0));
1402
1403   BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) != 0 || bmain != NULL);
1404   BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) != 0 || (flag & LIB_ID_CREATE_NO_ALLOCATE) == 0);
1405   BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) == 0 || (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) != 0);
1406   /* Never implicitly copy shapekeys when generating temp data outside of Main database. */
1407   BLI_assert((flag & LIB_ID_CREATE_NO_MAIN) == 0 || (flag & LIB_ID_COPY_SHAPEKEY) == 0);
1408
1409   if ((flag & LIB_ID_CREATE_NO_ALLOCATE) != 0) {
1410     /* r_newid already contains pointer to allocated memory. */
1411     /* TODO do we want to memset(0) whole mem before filling it? */
1412     BLI_strncpy(new_id->name, id->name, sizeof(new_id->name));
1413     new_id->us = 0;
1414     new_id->tag |= LIB_TAG_NOT_ALLOCATED | LIB_TAG_NO_MAIN | LIB_TAG_NO_USER_REFCOUNT;
1415     /* TODO Do we want/need to copy more from ID struct itself? */
1416   }
1417   else {
1418     new_id = BKE_libblock_alloc(bmain,
1419                                 GS(id->name),
1420                                 id->name + 2,
1421                                 flag | (use_nodetree_alloc_exception ? LIB_ID_CREATE_NO_MAIN : 0));
1422   }
1423   BLI_assert(new_id != NULL);
1424
1425   const size_t id_len = BKE_libblock_get_alloc_info(GS(new_id->name), NULL);
1426   const size_t id_offset = sizeof(ID);
1427   if ((int)id_len - (int)id_offset > 0) { /* signed to allow neg result */ /* XXX ????? */
1428     const char *cp = (const char *)id;
1429     char *cpn = (char *)new_id;
1430
1431     memcpy(cpn + id_offset, cp + id_offset, id_len - id_offset);
1432   }
1433
1434   if (id->properties) {
1435     new_id->properties = IDP_CopyProperty_ex(id->properties, flag);
1436   }
1437
1438   /* XXX Again... We need a way to control what we copy in a much more refined way.
1439    * We cannot always copy this, some internal copying will die on it! */
1440   /* For now, upper level code will have to do that itself when required. */
1441 #if 0
1442   if (id->override != NULL) {
1443     BKE_override_copy(new_id, id);
1444   }
1445 #endif
1446
1447   if (id_can_have_animdata(new_id)) {
1448     IdAdtTemplate *iat = (IdAdtTemplate *)new_id;
1449
1450     /* the duplicate should get a copy of the animdata */
1451     if ((flag & LIB_ID_COPY_NO_ANIMDATA) == 0) {
1452       BLI_assert((flag & LIB_ID_COPY_ACTIONS) == 0 || (flag & LIB_ID_CREATE_NO_MAIN) == 0);
1453       iat->adt = BKE_animdata_copy(bmain, iat->adt, flag);
1454     }
1455     else {
1456       iat->adt = NULL;
1457     }
1458   }
1459
1460   if ((flag & LIB_ID_CREATE_NO_DEG_TAG) == 0 && (flag & LIB_ID_CREATE_NO_MAIN) == 0) {
1461     DEG_id_type_tag(bmain, GS(new_id->name));
1462   }
1463
1464   *r_newid = new_id;
1465 }
1466
1467 /* used everywhere in blenkernel */
1468 void *BKE_libblock_copy(Main *bmain, const ID *id)
1469 {
1470   ID *idn;
1471
1472   BKE_libblock_copy_ex(bmain, id, &idn, 0);
1473
1474   return idn;
1475 }
1476
1477 /* XXX TODO: get rid of this useless wrapper at some point... */
1478 void *BKE_libblock_copy_for_localize(const ID *id)
1479 {
1480   ID *idn;
1481   BKE_libblock_copy_ex(NULL, id, &idn, LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA);
1482   return idn;
1483 }
1484
1485 void BKE_library_free(Library *lib)
1486 {
1487   if (lib->packedfile) {
1488     freePackedFile(lib->packedfile);
1489   }
1490 }
1491
1492 /* ***************** ID ************************ */
1493 ID *BKE_libblock_find_name(struct Main *bmain, const short type, const char *name)
1494 {
1495   ListBase *lb = which_libbase(bmain, type);
1496   BLI_assert(lb != NULL);
1497   return BLI_findstring(lb, name, offsetof(ID, name) + 2);
1498 }
1499
1500 void id_sort_by_name(ListBase *lb, ID *id)
1501 {
1502   ID *idtest;
1503
1504   /* insert alphabetically */
1505   if (lb->first != lb->last) {
1506     BLI_remlink(lb, id);
1507
1508     idtest = lb->first;
1509     while (idtest) {
1510       if (BLI_strcasecmp(idtest->name, id->name) > 0 || (idtest->lib && !id->lib)) {
1511         BLI_insertlinkbefore(lb, idtest, id);
1512         break;
1513       }
1514       idtest = idtest->next;
1515     }
1516     /* as last */
1517     if (idtest == NULL) {
1518       BLI_addtail(lb, id);
1519     }
1520   }
1521 }
1522
1523 /**
1524  * Check to see if there is an ID with the same name as 'name'.
1525  * Returns the ID if so, if not, returns NULL
1526  */
1527 static ID *is_dupid(ListBase *lb, ID *id, const char *name)
1528 {
1529   ID *idtest = NULL;
1530
1531   for (idtest = lb->first; idtest; idtest = idtest->next) {
1532     /* if idtest is not a lib */
1533     if (id != idtest && !ID_IS_LINKED(idtest)) {
1534       /* do not test alphabetic! */
1535       /* optimized */
1536       if (idtest->name[2] == name[0]) {
1537         if (STREQ(name, idtest->name + 2)) {
1538           break;
1539         }
1540       }
1541     }
1542   }
1543
1544   return idtest;
1545 }
1546
1547 /**
1548  * Check to see if an ID name is already used, and find a new one if so.
1549  * Return true if created a new name (returned in name).
1550  *
1551  * Normally the ID that's being check is already in the ListBase, so ID *id
1552  * points at the new entry.  The Python Library module needs to know what
1553  * the name of a datablock will be before it is appended; in this case ID *id
1554  * id is NULL
1555  */
1556
1557 static bool check_for_dupid(ListBase *lb, ID *id, char *name)
1558 {
1559   ID *idtest;
1560   int nr = 0, a;
1561   size_t left_len;
1562 #define MAX_IN_USE 64
1563   bool in_use[MAX_IN_USE];
1564   /* to speed up finding unused numbers within [1 .. MAX_IN_USE - 1] */
1565
1566   char left[MAX_ID_NAME + 8], leftest[MAX_ID_NAME + 8];
1567
1568   while (true) {
1569
1570     /* phase 1: id already exists? */
1571     idtest = is_dupid(lb, id, name);
1572
1573     /* if there is no double, done */
1574     if (idtest == NULL) {
1575       return false;
1576     }
1577
1578     /* we have a dup; need to make a new name */
1579     /* quick check so we can reuse one of first MAX_IN_USE - 1 ids if vacant */
1580     memset(in_use, false, sizeof(in_use));
1581
1582     /* get name portion, number portion ("name.number") */
1583     left_len = BLI_split_name_num(left, &nr, name, '.');
1584
1585     /* if new name will be too long, truncate it */
1586     if (nr > 999 && left_len > (MAX_ID_NAME - 8)) { /* assumption: won't go beyond 9999 */
1587       left[MAX_ID_NAME - 8] = '\0';
1588       left_len = MAX_ID_NAME - 8;
1589     }
1590     else if (left_len > (MAX_ID_NAME - 7)) {
1591       left[MAX_ID_NAME - 7] = '\0';
1592       left_len = MAX_ID_NAME - 7;
1593     }
1594
1595     /* Code above may have generated invalid utf-8 string, due to raw truncation.
1596      * Ensure we get a valid one now! */
1597     left_len -= (size_t)BLI_utf8_invalid_strip(left, left_len);
1598
1599     for (idtest = lb->first; idtest; idtest = idtest->next) {
1600       int nrtest;
1601       if ((id != idtest) && !ID_IS_LINKED(idtest) && (*name == *(idtest->name + 2)) &&
1602           STREQLEN(name, idtest->name + 2, left_len) &&
1603           (BLI_split_name_num(leftest, &nrtest, idtest->name + 2, '.') == left_len)) {
1604         /* will get here at least once, otherwise is_dupid call above would have returned NULL */
1605         if (nrtest < MAX_IN_USE) {
1606           in_use[nrtest] = true; /* mark as used */
1607         }
1608         if (nr <= nrtest) {
1609           nr = nrtest + 1; /* track largest unused */
1610         }
1611       }
1612     }
1613     /* At this point, 'nr' will typically be at least 1. (but not always) */
1614     // BLI_assert(nr >= 1);
1615
1616     /* decide which value of nr to use */
1617     for (a = 0; a < MAX_IN_USE; a++) {
1618       if (a >= nr) {
1619         break; /* stop when we've checked up to biggest */ /* redundant check */
1620       }
1621       if (!in_use[a]) { /* found an unused value */
1622         nr = a;
1623         /* can only be zero if all potential duplicate names had
1624          * nonzero numeric suffixes, which means name itself has
1625          * nonzero numeric suffix (else no name conflict and wouldn't
1626          * have got here), which means name[left_len] is not a null */
1627         break;
1628       }
1629     }
1630     /* At this point, nr is either the lowest unused number within [0 .. MAX_IN_USE - 1],
1631      * or 1 greater than the largest used number if all those low ones are taken.
1632      * We can't be bothered to look for the lowest unused number beyond (MAX_IN_USE - 1). */
1633
1634     /* If the original name has no numeric suffix,
1635      * rather than just chopping and adding numbers,
1636      * shave off the end chars until we have a unique name.
1637      * Check the null terminators match as well so we don't get Cube.000 -> Cube.00 */
1638     if (nr == 0 && name[left_len] == '\0') {
1639       size_t len;
1640       /* FIXME: this code will never be executed, because either nr will be
1641        * at least 1, or name will not end at left_len! */
1642       BLI_assert(0);
1643
1644       len = left_len - 1;
1645       idtest = is_dupid(lb, id, name);
1646
1647       while (idtest && len > 1) {
1648         name[len--] = '\0';
1649         idtest = is_dupid(lb, id, name);
1650       }
1651       if (idtest == NULL) {
1652         return true;
1653       }
1654       /* otherwise just continue and use a number suffix */
1655     }
1656
1657     if (nr > 999 && left_len > (MAX_ID_NAME - 8)) {
1658       /* this would overflow name buffer */
1659       left[MAX_ID_NAME - 8] = 0;
1660       /* left_len = MAX_ID_NAME - 8; */ /* for now this isn't used again */
1661       memcpy(name, left, sizeof(char) * (MAX_ID_NAME - 7));
1662       continue;
1663     }
1664     /* this format specifier is from hell... */
1665     BLI_snprintf(name, sizeof(id->name) - 2, "%s.%.3d", left, nr);
1666
1667     return true;
1668   }
1669
1670 #undef MAX_IN_USE
1671 }
1672
1673 /**
1674  * Ensures given ID has a unique name in given listbase.
1675  *
1676  * Only for local IDs (linked ones already have a unique ID in their library).
1677  *
1678  * \return true if a new name had to be created.
1679  */
1680 bool BKE_id_new_name_validate(ListBase *lb, ID *id, const char *tname)
1681 {
1682   bool result;
1683   char name[MAX_ID_NAME - 2];
1684
1685   /* if library, don't rename */
1686   if (ID_IS_LINKED(id)) {
1687     return false;
1688   }
1689
1690   /* if no name given, use name of current ID
1691    * else make a copy (tname args can be const) */
1692   if (tname == NULL) {
1693     tname = id->name + 2;
1694   }
1695
1696   BLI_strncpy(name, tname, sizeof(name));
1697
1698   if (name[0] == '\0') {
1699     /* Disallow empty names. */
1700     BLI_strncpy(name, DATA_(BKE_idcode_to_name(GS(id->name))), sizeof(name));
1701   }
1702   else {
1703     /* disallow non utf8 chars,
1704      * the interface checks for this but new ID's based on file names don't */
1705     BLI_utf8_invalid_strip(name, strlen(name));
1706   }
1707
1708   result = check_for_dupid(lb, id, name);
1709   strcpy(id->name + 2, name);
1710
1711   /* This was in 2.43 and previous releases
1712    * however all data in blender should be sorted, not just duplicate names
1713    * sorting should not hurt, but noting just incase it alters the way other
1714    * functions work, so sort every time */
1715 #if 0
1716   if (result)
1717     id_sort_by_name(lb, id);
1718 #endif
1719
1720   id_sort_by_name(lb, id);
1721
1722   return result;
1723 }
1724
1725 /**
1726  * Pull an ID out of a library (make it local). Only call this for IDs that
1727  * don't have other library users.
1728  */
1729 void id_clear_lib_data_ex(Main *bmain, ID *id, const bool id_in_mainlist)
1730 {
1731   bNodeTree *ntree = NULL;
1732   Key *key = NULL;
1733
1734   BKE_id_lib_local_paths(bmain, id->lib, id);
1735
1736   id_fake_user_clear(id);
1737
1738   id->lib = NULL;
1739   id->tag &= ~(LIB_TAG_INDIRECT | LIB_TAG_EXTERN);
1740   if (id_in_mainlist) {
1741     if (BKE_id_new_name_validate(which_libbase(bmain, GS(id->name)), id, NULL)) {
1742       bmain->is_memfile_undo_written = false;
1743     }
1744   }
1745
1746   /* Internal bNodeTree blocks inside datablocks also stores id->lib, make sure this stays in sync. */
1747   if ((ntree = ntreeFromID(id))) {
1748     id_clear_lib_data_ex(bmain, &ntree->id, false); /* Datablocks' nodetree is never in Main. */
1749   }
1750
1751   /* Same goes for shapekeys. */
1752   if ((key = BKE_key_from_id(id))) {
1753     id_clear_lib_data_ex(bmain, &key->id, id_in_mainlist); /* sigh, why are keys in Main? */
1754   }
1755 }
1756
1757 void id_clear_lib_data(Main *bmain, ID *id)
1758 {
1759   id_clear_lib_data_ex(bmain, id, true);
1760 }
1761
1762 /* next to indirect usage in read/writefile also in editobject.c scene.c */
1763 void BKE_main_id_clear_newpoins(Main *bmain)
1764 {
1765   ID *id;
1766
1767   FOREACH_MAIN_ID_BEGIN (bmain, id) {
1768     id->newid = NULL;
1769     id->tag &= ~LIB_TAG_NEW;
1770   }
1771   FOREACH_MAIN_ID_END;
1772 }
1773
1774 static void library_make_local_copying_check(ID *id,
1775                                              GSet *loop_tags,
1776                                              MainIDRelations *id_relations,
1777                                              GSet *done_ids)
1778 {
1779   if (BLI_gset_haskey(done_ids, id)) {
1780     return; /* Already checked, nothing else to do. */
1781   }
1782
1783   MainIDRelationsEntry *entry = BLI_ghash_lookup(id_relations->id_used_to_user, id);
1784   BLI_gset_insert(loop_tags, id);
1785   for (; entry != NULL; entry = entry->next) {
1786     ID *par_id =
1787         (ID *)entry->id_pointer; /* used_to_user stores ID pointer, not pointer to ID pointer... */
1788
1789     /* Our oh-so-beloved 'from' pointers... */
1790     if (entry->usage_flag & IDWALK_CB_LOOPBACK) {
1791       /* We totally disregard Object->proxy_from 'usage' here, this one would only generate fake positives. */
1792       if (GS(par_id->name) == ID_OB) {
1793         BLI_assert(((Object *)par_id)->proxy_from == (Object *)id);
1794         continue;
1795       }
1796
1797       /* Shapekeys are considered 'private' to their owner ID here, and never tagged (since they cannot be linked),
1798        * so we have to switch effective parent to their owner. */
1799       if (GS(par_id->name) == ID_KE) {
1800         par_id = ((Key *)par_id)->from;
1801       }
1802     }
1803
1804     if (par_id->lib == NULL) {
1805       /* Local user, early out to avoid some gset querying... */
1806       continue;
1807     }
1808     if (!BLI_gset_haskey(done_ids, par_id)) {
1809       if (BLI_gset_haskey(loop_tags, par_id)) {
1810         /* We are in a 'dependency loop' of IDs, this does not say us anything, skip it.
1811          * Note that this is the situation that can lead to archipelagoes of linked data-blocks
1812          * (since all of them have non-local users, they would all be duplicated, leading to a loop of unused
1813          * linked data-blocks that cannot be freed since they all use each other...). */
1814         continue;
1815       }
1816       /* Else, recursively check that user ID. */
1817       library_make_local_copying_check(par_id, loop_tags, id_relations, done_ids);
1818     }
1819
1820     if (par_id->tag & LIB_TAG_DOIT) {
1821       /* This user will be fully local in future, so far so good, nothing to do here but check next user. */
1822     }
1823     else {
1824       /* This user won't be fully local in future, so current ID won't be either. And we are done checking it. */
1825       id->tag &= ~LIB_TAG_DOIT;
1826       break;
1827     }
1828   }
1829   BLI_gset_add(done_ids, id);
1830   BLI_gset_remove(loop_tags, id, NULL);
1831 }
1832
1833 /** Make linked datablocks local.
1834  *
1835  * \param bmain: Almost certainly global main.
1836  * \param lib: If not NULL, only make local datablocks from this library.
1837  * \param untagged_only: If true, only make local datablocks not tagged with LIB_TAG_PRE_EXISTING.
1838  * \param set_fake: If true, set fake user on all localized datablocks (except group and objects ones).
1839  */
1840 /* Note: Old (2.77) version was simply making (tagging) datablocks as local, without actually making any check whether
1841  * they were also indirectly used or not...
1842  *
1843  * Current version uses regular id_make_local callback, with advanced pre-processing step to detect all cases of
1844  * IDs currently indirectly used, but which will be used by local data only once this function is finished.
1845  * This allows to avoid any unneeded duplication of IDs, and hence all time lost afterwards to remove
1846  * orphaned linked data-blocks...
1847  */
1848 void BKE_library_make_local(Main *bmain,
1849                             const Library *lib,
1850                             GHash *old_to_new_ids,
1851                             const bool untagged_only,
1852                             const bool set_fake)
1853 {
1854   ListBase *lbarray[MAX_LIBARRAY];
1855
1856   LinkNode *todo_ids = NULL;
1857   LinkNode *copied_ids = NULL;
1858   MemArena *linklist_mem = BLI_memarena_new(512 * sizeof(*todo_ids), __func__);
1859
1860   GSet *done_ids = BLI_gset_ptr_new(__func__);
1861
1862 #ifdef DEBUG_TIME
1863   TIMEIT_START(make_local);
1864 #endif
1865
1866   BKE_main_relations_create(bmain);
1867
1868 #ifdef DEBUG_TIME
1869   printf("Pre-compute current ID relations: Done.\n");
1870   TIMEIT_VALUE_PRINT(make_local);
1871 #endif
1872
1873   /* Step 1: Detect datablocks to make local. */
1874   for (int a = set_listbasepointers(bmain, lbarray); a--;) {
1875     ID *id = lbarray[a]->first;
1876
1877     /* Do not explicitly make local non-linkable IDs (shapekeys, in fact), they are assumed to be handled
1878      * by real datablocks responsible of them. */
1879     const bool do_skip = (id && !BKE_idcode_is_linkable(GS(id->name)));
1880
1881     for (; id; id = id->next) {
1882       ID *ntree = (ID *)ntreeFromID(id);
1883
1884       id->tag &= ~LIB_TAG_DOIT;
1885       if (ntree != NULL) {
1886         ntree->tag &= ~LIB_TAG_DOIT;
1887       }
1888
1889       if (id->lib == NULL) {
1890         id->tag &= ~(LIB_TAG_EXTERN | LIB_TAG_INDIRECT | LIB_TAG_NEW);
1891       }
1892       /* The check on the fourth line (LIB_TAG_PRE_EXISTING) is done so its possible to tag data you don't want to
1893        * be made local, used for appending data, so any libdata already linked wont become local (very nasty
1894        * to discover all your links are lost after appending).
1895        * Also, never ever make proxified objects local, would not make any sense. */
1896       /* Some more notes:
1897        *   - Shapekeys are never tagged here (since they are not linkable).
1898        *   - Nodetrees used in materials etc. have to be tagged manually, since they do not exist in Main (!).
1899        * This is ok-ish on 'make local' side of things (since those are handled by their 'owner' IDs),
1900        * but complicates slightly the pre-processing of relations between IDs at step 2... */
1901       else if (!do_skip && id->tag & (LIB_TAG_EXTERN | LIB_TAG_INDIRECT | LIB_TAG_NEW) &&
1902                ELEM(lib, NULL, id->lib) &&
1903                !(GS(id->name) == ID_OB && ((Object *)id)->proxy_from != NULL) &&
1904                ((untagged_only == false) || !(id->tag & LIB_TAG_PRE_EXISTING))) {
1905         BLI_linklist_prepend_arena(&todo_ids, id, linklist_mem);
1906         id->tag |= LIB_TAG_DOIT;
1907
1908         /* Tag those nasty non-ID nodetrees, but do not add them to todo list, making them local is handled
1909          * by 'owner' ID. This is needed for library_make_local_copying_check() to work OK at step 2. */
1910         if (ntree != NULL) {
1911           ntree->tag |= LIB_TAG_DOIT;
1912         }
1913       }
1914       else {
1915         /* Linked ID that we won't be making local (needed info for step 2, see below). */
1916         BLI_gset_add(done_ids, id);
1917       }
1918     }
1919   }
1920
1921 #ifdef DEBUG_TIME
1922   printf("Step 1: Detect datablocks to make local: Done.\n");
1923   TIMEIT_VALUE_PRINT(make_local);
1924 #endif
1925
1926   /* Step 2: Check which datablocks we can directly make local (because they are only used by already, or future,
1927    * local data), others will need to be duplicated. */
1928   GSet *loop_tags = BLI_gset_ptr_new(__func__);
1929   for (LinkNode *it = todo_ids; it; it = it->next) {
1930     library_make_local_copying_check(it->link, loop_tags, bmain->relations, done_ids);
1931     BLI_assert(BLI_gset_len(loop_tags) == 0);
1932   }
1933   BLI_gset_free(loop_tags, NULL);
1934   BLI_gset_free(done_ids, NULL);
1935
1936   /* Next step will most likely add new IDs, better to get rid of this mapping now. */
1937   BKE_main_relations_free(bmain);
1938
1939 #ifdef DEBUG_TIME
1940   printf("Step 2: Check which datablocks we can directly make local: Done.\n");
1941   TIMEIT_VALUE_PRINT(make_local);
1942 #endif
1943
1944   /* Step 3: Make IDs local, either directly (quick and simple), or using generic process,
1945    * which involves more complex checks and might instead create a local copy of original linked ID. */
1946   for (LinkNode *it = todo_ids, *it_next; it; it = it_next) {
1947     it_next = it->next;
1948     ID *id = it->link;
1949
1950     if (id->tag & LIB_TAG_DOIT) {
1951       /* We know all users of this object are local or will be made fully local, even if currently there are
1952        * some indirect usages. So instead of making a copy that we'll likely get rid of later, directly make
1953        * that data block local. Saves a tremendous amount of time with complex scenes... */
1954       id_clear_lib_data_ex(bmain, id, true);
1955       BKE_id_expand_local(bmain, id);
1956       id->tag &= ~LIB_TAG_DOIT;
1957     }
1958     else {
1959       /* In this specific case, we do want to make ID local even if it has no local usage yet... */
1960       if (GS(id->name) == ID_OB) {
1961         /* Special case for objects because we don't want proxy pointers to be
1962          * cleared yet. This will happen down the road in this function.
1963          */
1964         BKE_object_make_local_ex(bmain, (Object *)id, true, false);
1965       }
1966       else {
1967         id_make_local(bmain, id, false, true);
1968       }
1969
1970       if (id->newid) {
1971         /* Reuse already allocated LinkNode (transferring it from todo_ids to copied_ids). */
1972         BLI_linklist_prepend_nlink(&copied_ids, id, it);
1973       }
1974     }
1975
1976     if (set_fake) {
1977       if (!ELEM(GS(id->name), ID_OB, ID_GR)) {
1978         /* do not set fake user on objects, groups (instancing) */
1979         id_fake_user_set(id);
1980       }
1981     }
1982   }
1983
1984 #ifdef DEBUG_TIME
1985   printf("Step 3: Make IDs local: Done.\n");
1986   TIMEIT_VALUE_PRINT(make_local);
1987 #endif
1988
1989   /* At this point, we are done with directly made local IDs. Now we have to handle duplicated ones, since their
1990    * remaining linked original counterpart may not be needed anymore... */
1991   todo_ids = NULL;
1992
1993   /* Step 4: We have to remap local usages of old (linked) ID to new (local) ID in a separated loop,
1994    * as lbarray ordering is not enough to ensure us we did catch all dependencies
1995    * (e.g. if making local a parent object before its child...). See T48907. */
1996   /* TODO This is now the biggest step by far (in term of processing time). We may be able to gain here by
1997    * using again main->relations mapping, but... this implies BKE_libblock_remap & co to be able to update
1998    * main->relations on the fly. Have to think about it a bit more, and see whether new code is OK first, anyway. */
1999   for (LinkNode *it = copied_ids; it; it = it->next) {
2000     ID *id = it->link;
2001
2002     BLI_assert(id->newid != NULL);
2003     BLI_assert(id->lib != NULL);
2004
2005     BKE_libblock_remap(bmain, id, id->newid, ID_REMAP_SKIP_INDIRECT_USAGE);
2006     if (old_to_new_ids) {
2007       BLI_ghash_insert(old_to_new_ids, id, id->newid);
2008     }
2009
2010     /* Special hack for groups... Thing is, since we can't instantiate them here, we need to ensure
2011      * they remain 'alive' (only instantiation is a real group 'user'... *sigh* See T49722. */
2012     if (GS(id->name) == ID_GR && (id->tag & LIB_TAG_INDIRECT) != 0) {
2013       id_us_ensure_real(id->newid);
2014     }
2015   }
2016
2017 #ifdef DEBUG_TIME
2018   printf("Step 4: Remap local usages of old (linked) ID to new (local) ID: Done.\n");
2019   TIMEIT_VALUE_PRINT(make_local);
2020 #endif
2021
2022   /* Step 5: proxy 'remapping' hack. */
2023   for (LinkNode *it = copied_ids; it; it = it->next) {
2024     ID *id = it->link;
2025
2026     /* Attempt to re-link copied proxy objects. This allows appending of an entire scene
2027      * from another blend file into this one, even when that blend file contains proxified
2028      * armatures that have local references. Since the proxified object needs to be linked
2029      * (not local), this will only work when the "Localize all" checkbox is disabled.
2030      * TL;DR: this is a dirty hack on top of an already weak feature (proxies). */
2031     if (GS(id->name) == ID_OB && ((Object *)id)->proxy != NULL) {
2032       Object *ob = (Object *)id;
2033       Object *ob_new = (Object *)id->newid;
2034       bool is_local = false, is_lib = false;
2035
2036       /* Proxies only work when the proxified object is linked-in from a library. */
2037       if (ob->proxy->id.lib == NULL) {
2038         CLOG_WARN(&LOG,
2039                   "proxy object %s will loose its link to %s, because the "
2040                   "proxified object is local.",
2041                   id->newid->name,
2042                   ob->proxy->id.name);
2043         continue;
2044       }
2045
2046       BKE_library_ID_test_usages(bmain, id, &is_local, &is_lib);
2047
2048       /* We can only switch the proxy'ing to a made-local proxy if it is no longer
2049        * referred to from a library. Not checking for local use; if new local proxy
2050        * was not used locally would be a nasty bug! */
2051       if (is_local || is_lib) {
2052         CLOG_WARN(&LOG,
2053                   "made-local proxy object %s will loose its link to %s, "
2054                   "because the linked-in proxy is referenced (is_local=%i, is_lib=%i).",
2055                   id->newid->name,
2056                   ob->proxy->id.name,
2057                   is_local,
2058                   is_lib);
2059       }
2060       else {
2061         /* we can switch the proxy'ing from the linked-in to the made-local proxy.
2062          * BKE_object_make_proxy() shouldn't be used here, as it allocates memory that
2063          * was already allocated by BKE_object_make_local_ex() (which called BKE_object_copy). */
2064         ob_new->proxy = ob->proxy;
2065         ob_new->proxy_group = ob->proxy_group;
2066         ob_new->proxy_from = ob->proxy_from;
2067         ob_new->proxy->proxy_from = ob_new;
2068         ob->proxy = ob->proxy_from = ob->proxy_group = NULL;
2069       }
2070     }
2071   }
2072
2073 #ifdef DEBUG_TIME
2074   printf("Step 5: Proxy 'remapping' hack: Done.\n");
2075   TIMEIT_VALUE_PRINT(make_local);
2076 #endif
2077
2078   /* This is probably more of a hack than something we should do here, but...
2079    * Issue is, the whole copying + remapping done in complex cases above may leave pose channels of armatures
2080    * in complete invalid state (more precisely, the bone pointers of the pchans - very crappy cross-datablocks
2081    * relationship), se we tag it to be fully recomputed, but this does not seems to be enough in some cases,
2082    * and evaluation code ends up trying to evaluate a not-yet-updated armature object's deformations.
2083    * Try "make all local" in 04_01_H.lighting.blend from Agent327 without this, e.g. */
2084   for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2085     if (ob->data != NULL && ob->type == OB_ARMATURE && ob->pose != NULL &&
2086         ob->pose->flag & POSE_RECALC) {
2087       BKE_pose_rebuild(bmain, ob, ob->data, true);
2088     }
2089   }
2090
2091   /* Reset rigid body objects. */
2092   for (LinkNode *it = copied_ids; it; it = it->next) {
2093     ID *id = it->link;
2094     if (GS(id->name) == ID_OB) {
2095       Object *ob = (Object *)id;
2096
2097       /* If there was ever any rigidbody settings in the object, we reset it. */
2098       if (ob->rigidbody_object) {
2099         for (Scene *scene_iter = bmain->scenes.first; scene_iter;
2100              scene_iter = scene_iter->id.next) {
2101           if (scene_iter->rigidbody_world) {
2102             BKE_rigidbody_remove_object(bmain, scene_iter, ob);
2103           }
2104         }
2105         BKE_rigidbody_free_object(ob, NULL);
2106       }
2107     }
2108   }
2109
2110 #ifdef DEBUG_TIME
2111   printf("Hack: Forcefully rebuild armature object poses: Done.\n");
2112   TIMEIT_VALUE_PRINT(make_local);
2113 #endif
2114
2115   BKE_main_id_clear_newpoins(bmain);
2116   BLI_memarena_free(linklist_mem);
2117
2118 #ifdef DEBUG_TIME
2119   printf("Cleanup and finish: Done.\n");
2120   TIMEIT_END(make_local);
2121 #endif
2122 }
2123
2124 /**
2125  * Use after setting the ID's name
2126  * When name exists: call 'new_id'
2127  */
2128 void BLI_libblock_ensure_unique_name(Main *bmain, const char *name)
2129 {
2130   ListBase *lb;
2131   ID *idtest;
2132
2133   lb = which_libbase(bmain, GS(name));
2134   if (lb == NULL) {
2135     return;
2136   }
2137
2138   /* search for id */
2139   idtest = BLI_findstring(lb, name + 2, offsetof(ID, name) + 2);
2140   if (idtest != NULL) {
2141     /* BKE_id_new_name_validate also takes care of sorting. */
2142     BKE_id_new_name_validate(lb, idtest, NULL);
2143     bmain->is_memfile_undo_written = false;
2144   }
2145 }
2146
2147 /**
2148  * Sets the name of a block to name, suitably adjusted for uniqueness.
2149  */
2150 void BKE_libblock_rename(Main *bmain, ID *id, const char *name)
2151 {
2152   ListBase *lb = which_libbase(bmain, GS(id->name));
2153   if (BKE_id_new_name_validate(lb, id, name)) {
2154     bmain->is_memfile_undo_written = false;
2155   }
2156 }
2157
2158 /**
2159  * Generate full name of the data-block (without ID code, but with library if any).
2160  *
2161  * \note Result is unique to a given ID type in a given Main database.
2162  *
2163  * \param name: An allocated string of minimal length MAX_ID_FULL_NAME, will be filled with generated string.
2164  */
2165 void BKE_id_full_name_get(char name[MAX_ID_FULL_NAME], const ID *id)
2166 {
2167   strcpy(name, id->name + 2);
2168
2169   if (id->lib != NULL) {
2170     const size_t idname_len = strlen(id->name + 2);
2171     const size_t libname_len = strlen(id->lib->id.name + 2);
2172
2173     name[idname_len] = ' ';
2174     name[idname_len + 1] = '[';
2175     strcpy(name + idname_len + 2, id->lib->id.name + 2);
2176     name[idname_len + 2 + libname_len] = ']';
2177     name[idname_len + 2 + libname_len + 1] = '\0';
2178   }
2179 }
2180
2181 /**
2182  * Generate full name of the data-block (without ID code, but with library if any), with a 3-character prefix prepended
2183  * indicating whether it comes from a library, is overriding, has a fake or no user, etc.
2184  *
2185  * \note Result is unique to a given ID type in a given Main database.
2186  *
2187  * \param name: An allocated string of minimal length MAX_ID_FULL_NAME_UI, will be filled with generated string.
2188  */
2189 void BKE_id_full_name_ui_prefix_get(char name[MAX_ID_FULL_NAME_UI], const ID *id)
2190 {
2191   name[0] = id->lib ? (ID_MISSING(id) ? 'M' : 'L') : ID_IS_STATIC_OVERRIDE(id) ? 'O' : ' ';
2192   name[1] = (id->flag & LIB_FAKEUSER) ? 'F' : ((id->us == 0) ? '0' : ' ');
2193   name[2] = ' ';
2194
2195   BKE_id_full_name_get(name + 3, id);
2196 }
2197
2198 /**
2199  * Generate a concatenation of ID name (including two-chars type code) and its lib name, if any.
2200  *
2201  * \return A unique allocated string key for any ID in the whole Main database.
2202  */
2203 char *BKE_id_to_unique_string_key(const struct ID *id)
2204 {
2205   if (id->lib == NULL) {
2206     return BLI_strdup(id->name);
2207   }
2208   else {
2209     /* Prefix with an ascii character in the range of 32..96 (visible)
2210      * this ensures we can't have a library ID pair that collide.
2211      * Where 'LIfooOBbarOBbaz' could be ('LIfoo, OBbarOBbaz') or ('LIfooOBbar', 'OBbaz'). */
2212     const char ascii_len = strlen(id->lib->id.name + 2) + 32;
2213     return BLI_sprintfN("%c%s%s", ascii_len, id->lib->id.name, id->name);
2214   }
2215 }
2216
2217 void BKE_library_filepath_set(Main *bmain, Library *lib, const char *filepath)
2218 {
2219   /* in some cases this is used to update the absolute path from the
2220    * relative */
2221   if (lib->name != filepath) {
2222     BLI_strncpy(lib->name, filepath, sizeof(lib->name));
2223   }
2224
2225   BLI_strncpy(lib->filepath, filepath, sizeof(lib->filepath));
2226
2227   /* not essential but set filepath is an absolute copy of value which
2228    * is more useful if its kept in sync */
2229   if (BLI_path_is_rel(lib->filepath)) {
2230     /* note that the file may be unsaved, in this case, setting the
2231      * filepath on an indirectly linked path is not allowed from the
2232      * outliner, and its not really supported but allow from here for now
2233      * since making local could cause this to be directly linked - campbell
2234      */
2235     /* Never make paths relative to parent lib - reading code (blenloader) always set *all* lib->name relative to
2236      * current main, not to their parent for indirectly linked ones. */
2237     const char *basepath = BKE_main_blendfile_path(bmain);
2238     BLI_path_abs(lib->filepath, basepath);
2239   }
2240 }
2241
2242 void BKE_id_tag_set_atomic(ID *id, int tag)
2243 {
2244   atomic_fetch_and_or_int32(&id->tag, tag);
2245 }
2246
2247 void BKE_id_tag_clear_atomic(ID *id, int tag)
2248 {
2249   atomic_fetch_and_and_int32(&id->tag, ~tag);
2250 }
2251
2252 /** Check that given ID pointer actually is in G_MAIN.
2253  * Main intended use is for debug asserts in places we cannot easily get rid of G_Main... */
2254 bool BKE_id_is_in_global_main(ID *id)
2255 {
2256   /* We do not want to fail when id is NULL here, even though this is a bit strange behavior... */
2257   return (id == NULL || BLI_findindex(which_libbase(G_MAIN, GS(id->name)), id) != -1);
2258 }
2259
2260 /************************* Datablock order in UI **************************/
2261
2262 static int *id_order_get(ID *id)
2263 {
2264   /* Only for workspace tabs currently. */
2265   switch (GS(id->name)) {
2266     case ID_WS:
2267       return &((WorkSpace *)id)->order;
2268     default:
2269       return NULL;
2270   }
2271 }
2272
2273 static int id_order_compare(const void *a, const void *b)
2274 {
2275   ID *id_a = ((LinkData *)a)->data;
2276   ID *id_b = ((LinkData *)b)->data;
2277
2278   int *order_a = id_order_get(id_a);
2279   int *order_b = id_order_get(id_b);
2280
2281   if (order_a && order_b) {
2282     if (*order_a < *order_b) {
2283       return -1;
2284     }
2285     else if (*order_a > *order_b) {
2286       return 1;
2287     }
2288   }
2289
2290   return strcmp(id_a->name, id_b->name);
2291 }
2292
2293 /**
2294  * Returns ordered list of datablocks for display in the UI.
2295  * Result is list of LinkData of IDs that must be freed.
2296  */
2297 void BKE_id_ordered_list(ListBase *ordered_lb, const ListBase *lb)
2298 {
2299   BLI_listbase_clear(ordered_lb);
2300
2301   for (ID *id = lb->first; id; id = id->next) {
2302     BLI_addtail(ordered_lb, BLI_genericNodeN(id));
2303   }
2304
2305   BLI_listbase_sort(ordered_lb, id_order_compare);
2306
2307   int num = 0;
2308   for (LinkData *link = ordered_lb->first; link; link = link->next) {
2309     int *order = id_order_get(link->data);
2310     if (order) {
2311       *order = num++;
2312     }
2313   }
2314 }
2315
2316 /**
2317  * Reorder ID in the list, before or after the "relative" ID.
2318  */
2319 void BKE_id_reorder(const ListBase *lb, ID *id, ID *relative, bool after)
2320 {
2321   int *id_order = id_order_get(id);
2322   int relative_order;
2323
2324   if (relative) {
2325     relative_order = *id_order_get(relative);
2326   }
2327   else {
2328     relative_order = (after) ? BLI_listbase_count(lb) : 0;
2329   }
2330
2331   if (after) {
2332     /* Insert after. */
2333     for (ID *other = lb->first; other; other = other->next) {
2334       int *order = id_order_get(other);
2335       if (*order > relative_order) {
2336         (*order)++;
2337       }
2338     }
2339
2340     *id_order = relative_order + 1;
2341   }
2342   else {
2343     /* Insert before. */
2344     for (ID *other = lb->first; other; other = other->next) {
2345       int *order = id_order_get(other);
2346       if (*order < relative_order) {
2347         (*order)--;
2348       }
2349     }
2350
2351     *id_order = relative_order - 1;
2352   }
2353 }