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