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