Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / blendfile.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/blenkernel/intern/blendfile.c
22  *  \ingroup bke
23  *
24  * High level `.blend` file read/write,
25  * and functions for writing *partial* files (only selected data-blocks).
26  */
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_scene_types.h"
34 #include "DNA_screen_types.h"
35 #include "DNA_workspace_types.h"
36
37 #include "BLI_listbase.h"
38 #include "BLI_string.h"
39 #include "BLI_path_util.h"
40 #include "BLI_utildefines.h"
41
42 #include "IMB_colormanagement.h"
43
44 #include "BKE_appdir.h"
45 #include "BKE_blender.h"
46 #include "BKE_blender_version.h"
47 #include "BKE_blendfile.h"
48 #include "BKE_bpath.h"
49 #include "BKE_context.h"
50 #include "BKE_global.h"
51 #include "BKE_ipo.h"
52 #include "BKE_layer.h"
53 #include "BKE_library.h"
54 #include "BKE_main.h"
55 #include "BKE_report.h"
56 #include "BKE_scene.h"
57 #include "BKE_screen.h"
58 #include "BKE_workspace.h"
59
60 #include "BLO_readfile.h"
61 #include "BLO_writefile.h"
62
63 #include "RNA_access.h"
64
65 #include "RE_pipeline.h"
66
67 #ifdef WITH_PYTHON
68 #  include "BPY_extern.h"
69 #endif
70
71 /* -------------------------------------------------------------------- */
72
73 /** \name High Level `.blend` file read/write.
74  * \{ */
75
76 static bool clean_paths_visit_cb(void *UNUSED(userdata), char *path_dst, const char *path_src)
77 {
78         strcpy(path_dst, path_src);
79         BLI_path_native_slash(path_dst);
80         return !STREQ(path_dst, path_src);
81 }
82
83 /* make sure path names are correct for OS */
84 static void clean_paths(Main *main)
85 {
86         Scene *scene;
87
88         BKE_bpath_traverse_main(main, clean_paths_visit_cb, BKE_BPATH_TRAVERSE_SKIP_MULTIFILE, NULL);
89
90         for (scene = main->scene.first; scene; scene = scene->id.next) {
91                 BLI_path_native_slash(scene->r.pic);
92         }
93 }
94
95 static bool wm_scene_is_visible(wmWindowManager *wm, Scene *scene)
96 {
97         wmWindow *win;
98         for (win = wm->windows.first; win; win = win->next) {
99                 if (win->scene == scene) {
100                         return true;
101                 }
102         }
103         return false;
104 }
105
106 /**
107  * Context matching, handle no-ui case
108  *
109  * \note this is called on Undo so any slow conversion functions here
110  * should be avoided or check (mode != LOAD_UNDO).
111  *
112  * \param bfd: Blend file data, freed by this function on exit.
113  * \param filepath: File path or identifier.
114  */
115 static void setup_app_data(
116         bContext *C, BlendFileData *bfd,
117         const char *filepath,
118         const bool is_startup,
119         ReportList *reports)
120 {
121         Main *bmain = G_MAIN;
122         Scene *curscene = NULL;
123         const bool recover = (G.fileflags & G_FILE_RECOVER) != 0;
124         enum {
125                 LOAD_UI = 1,
126                 LOAD_UI_OFF,
127                 LOAD_UNDO,
128         } mode;
129
130         /* may happen with library files - UNDO file should never have NULL cursccene... */
131         if (ELEM(NULL, bfd->curscreen, bfd->curscene)) {
132                 BKE_report(reports, RPT_WARNING, "Library file, loading empty scene");
133                 mode = LOAD_UI_OFF;
134         }
135         else if (BLI_listbase_is_empty(&bfd->main->screen)) {
136                 mode = LOAD_UNDO;
137         }
138         else if ((G.fileflags & G_FILE_NO_UI) && (is_startup == false)) {
139                 mode = LOAD_UI_OFF;
140         }
141         else {
142                 mode = LOAD_UI;
143         }
144
145         /* Free all render results, without this stale data gets displayed after loading files */
146         if (mode != LOAD_UNDO) {
147                 RE_FreeAllRenderResults();
148         }
149
150         /* Only make filepaths compatible when loading for real (not undo) */
151         if (mode != LOAD_UNDO) {
152                 clean_paths(bfd->main);
153         }
154
155         /* XXX here the complex windowmanager matching */
156
157         /* no load screens? */
158         if (mode != LOAD_UI) {
159                 /* Logic for 'track_undo_scene' is to keep using the scene which the active screen has,
160                  * as long as the scene associated with the undo operation is visible in one of the open windows.
161                  *
162                  * - 'curscreen->scene' - scene the user is currently looking at.
163                  * - 'bfd->curscene' - scene undo-step was created in.
164                  *
165                  * This means users can have 2+ windows open and undo in both without screens switching.
166                  * But if they close one of the screens,
167                  * undo will ensure that the scene being operated on will be activated
168                  * (otherwise we'd be undoing on an off-screen scene which isn't acceptable).
169                  * see: T43424
170                  */
171                 wmWindow *win;
172                 bScreen *curscreen = NULL;
173                 ViewLayer *cur_view_layer;
174                 bool track_undo_scene;
175
176                 /* comes from readfile.c */
177                 SWAP(ListBase, bmain->wm, bfd->main->wm);
178                 SWAP(ListBase, bmain->workspaces, bfd->main->workspaces);
179                 SWAP(ListBase, bmain->screen, bfd->main->screen);
180
181                 /* we re-use current window and screen */
182                 win = CTX_wm_window(C);
183                 curscreen = CTX_wm_screen(C);
184                 /* but use Scene pointer from new file */
185                 curscene = bfd->curscene;
186                 cur_view_layer = bfd->cur_view_layer;
187
188                 track_undo_scene = (mode == LOAD_UNDO && curscreen && curscene && bfd->main->wm.first);
189
190                 if (curscene == NULL) {
191                         curscene = bfd->main->scene.first;
192                 }
193                 /* empty file, we add a scene to make Blender work */
194                 if (curscene == NULL) {
195                         curscene = BKE_scene_add(bfd->main, "Empty");
196                 }
197                 if (cur_view_layer == NULL) {
198                         /* fallback to scene layer */
199                         cur_view_layer = BKE_view_layer_default_view(curscene);
200                 }
201
202                 if (track_undo_scene) {
203                         /* keep the old (free'd) scene, let 'blo_lib_link_screen_restore'
204                          * replace it with 'curscene' if its needed */
205                 }
206                 /* and we enforce curscene to be in current screen */
207                 else if (win) { /* can run in bgmode */
208                         win->scene = curscene;
209                 }
210
211                 /* BKE_blender_globals_clear will free G_MAIN, here we can still restore pointers */
212                 blo_lib_link_restore(bfd->main, CTX_wm_manager(C), curscene, cur_view_layer);
213                 if (win) {
214                         curscene = win->scene;
215                 }
216
217                 if (track_undo_scene) {
218                         wmWindowManager *wm = bfd->main->wm.first;
219                         if (wm_scene_is_visible(wm, bfd->curscene) == false) {
220                                 curscene = bfd->curscene;
221                                 win->scene = curscene;
222                                 BKE_screen_view3d_scene_sync(curscreen, curscene);
223                         }
224                 }
225
226                 /* We need to tag this here because events may be handled immediately after.
227                  * only the current screen is important because we wont have to handle
228                  * events from multiple screens at once.*/
229                 if (curscreen) {
230                         BKE_screen_gizmo_tag_refresh(curscreen);
231                 }
232         }
233
234         /* free G_MAIN Main database */
235 //      CTX_wm_manager_set(C, NULL);
236         BKE_blender_globals_clear();
237
238         /* clear old property update cache, in case some old references are left dangling */
239         RNA_property_update_cache_free();
240
241         bmain = G_MAIN = bfd->main;
242
243         CTX_data_main_set(C, bmain);
244
245         if (bfd->user) {
246
247                 /* only here free userdef themes... */
248                 BKE_blender_userdef_data_set_and_free(bfd->user);
249                 bfd->user = NULL;
250
251                 /* Security issue: any blend file could include a USER block.
252                  *
253                  * Currently we load prefs from BLENDER_STARTUP_FILE and later on load BLENDER_USERPREF_FILE,
254                  * to load the preferences defined in the users home dir.
255                  *
256                  * This means we will never accidentally (or maliciously)
257                  * enable scripts auto-execution by loading a '.blend' file.
258                  */
259                 U.flag |= USER_SCRIPT_AUTOEXEC_DISABLE;
260         }
261
262         /* case G_FILE_NO_UI or no screens in file */
263         if (mode != LOAD_UI) {
264                 /* leave entire context further unaltered? */
265                 CTX_data_scene_set(C, curscene);
266         }
267         else {
268                 /* Keep state from preferences. */
269                 const int fileflags_skip = G_FILE_FLAGS_RUNTIME;
270                 G.fileflags = (G.fileflags & fileflags_skip) | (bfd->fileflags & ~fileflags_skip);
271                 CTX_wm_manager_set(C, bmain->wm.first);
272                 CTX_wm_screen_set(C, bfd->curscreen);
273                 CTX_data_scene_set(C, bfd->curscene);
274                 CTX_wm_area_set(C, NULL);
275                 CTX_wm_region_set(C, NULL);
276                 CTX_wm_menu_set(C, NULL);
277                 curscene = bfd->curscene;
278         }
279
280         /* this can happen when active scene was lib-linked, and doesn't exist anymore */
281         if (CTX_data_scene(C) == NULL) {
282                 wmWindow *win = CTX_wm_window(C);
283
284                 /* in case we don't even have a local scene, add one */
285                 if (!bmain->scene.first)
286                         BKE_scene_add(bmain, "Empty");
287
288                 CTX_data_scene_set(C, bmain->scene.first);
289                 win->scene = CTX_data_scene(C);
290                 curscene = CTX_data_scene(C);
291         }
292
293         BLI_assert(curscene == CTX_data_scene(C));
294
295
296         /* special cases, override loaded flags: */
297         if (G.f != bfd->globalf) {
298                 const int flags_keep = (G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
299                 bfd->globalf = (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
300         }
301
302
303         G.f = bfd->globalf;
304
305 #ifdef WITH_PYTHON
306         /* let python know about new main */
307         BPY_context_update(C);
308 #endif
309
310         /* FIXME: this version patching should really be part of the file-reading code,
311          * but we still get too many unrelated data-corruption crashes otherwise... */
312         if (bmain->versionfile < 250)
313                 do_versions_ipos_to_animato(bmain);
314
315         bmain->recovered = 0;
316
317         /* startup.blend or recovered startup */
318         if (is_startup) {
319                 bmain->name[0] = '\0';
320         }
321         else if (recover && G.relbase_valid) {
322                 /* in case of autosave or quit.blend, use original filename instead
323                  * use relbase_valid to make sure the file is saved, else we get <memory2> in the filename */
324                 filepath = bfd->filename;
325                 bmain->recovered = 1;
326
327                 /* these are the same at times, should never copy to the same location */
328                 if (bmain->name != filepath)
329                         BLI_strncpy(bmain->name, filepath, FILE_MAX);
330         }
331
332         /* baseflags, groups, make depsgraph, etc */
333         /* first handle case if other windows have different scenes visible */
334         if (mode == LOAD_UI) {
335                 wmWindowManager *wm = bmain->wm.first;
336
337                 if (wm) {
338                         for (wmWindow *win = wm->windows.first; win; win = win->next) {
339                                 if (win->scene && win->scene != curscene) {
340                                         BKE_scene_set_background(bmain, win->scene);
341                                 }
342                         }
343                 }
344         }
345
346         /* Setting scene might require having a dependency graph, with copy on write
347          * we need to make sure we ensure scene has correct color management before
348          * constructing dependency graph.
349          */
350         if (mode != LOAD_UNDO) {
351                 IMB_colormanagement_check_file_config(bmain);
352         }
353
354         BKE_scene_set_background(bmain, curscene);
355
356         if (mode != LOAD_UNDO) {
357                 /* TODO(sergey): Can this be also move above? */
358                 RE_FreeAllPersistentData();
359         }
360
361         MEM_freeN(bfd);
362
363 }
364
365 static int handle_subversion_warning(Main *main, ReportList *reports)
366 {
367         if (main->minversionfile > BLENDER_VERSION ||
368             (main->minversionfile == BLENDER_VERSION &&
369              main->minsubversionfile > BLENDER_SUBVERSION))
370         {
371                 BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary (%d.%d), expect loss of data!",
372                             main->minversionfile, main->minsubversionfile);
373         }
374
375         return 1;
376 }
377
378 int BKE_blendfile_read(
379         bContext *C, const char *filepath,
380         const struct BlendFileReadParams *params,
381         ReportList *reports)
382 {
383         BlendFileData *bfd;
384         int retval = BKE_BLENDFILE_READ_OK;
385
386         /* don't print user-pref loading */
387         if (strstr(filepath, BLENDER_STARTUP_FILE) == NULL) {
388                 printf("Read blend: %s\n", filepath);
389         }
390
391         bfd = BLO_read_from_file(filepath, params->skip_flags, reports);
392         if (bfd) {
393                 if (bfd->user) {
394                         retval = BKE_BLENDFILE_READ_OK_USERPREFS;
395                 }
396
397                 if (0 == handle_subversion_warning(bfd->main, reports)) {
398                         BKE_main_free(bfd->main);
399                         MEM_freeN(bfd);
400                         bfd = NULL;
401                         retval = BKE_BLENDFILE_READ_FAIL;
402                 }
403                 else {
404                         setup_app_data(C, bfd, filepath, params->is_startup, reports);
405                 }
406         }
407         else
408                 BKE_reports_prependf(reports, "Loading '%s' failed: ", filepath);
409
410         return (bfd ? retval : BKE_BLENDFILE_READ_FAIL);
411 }
412
413 bool BKE_blendfile_read_from_memory(
414         bContext *C, const void *filebuf, int filelength, bool update_defaults,
415         const struct BlendFileReadParams *params,
416         ReportList *reports)
417 {
418         BlendFileData *bfd;
419
420         bfd = BLO_read_from_memory(filebuf, filelength, params->skip_flags, reports);
421         if (bfd) {
422                 if (update_defaults)
423                         BLO_update_defaults_startup_blend(bfd->main, NULL);
424                 setup_app_data(C, bfd, "<memory2>", params->is_startup, reports);
425         }
426         else {
427                 BKE_reports_prepend(reports, "Loading failed: ");
428         }
429
430         return (bfd != NULL);
431 }
432
433 /* memfile is the undo buffer */
434 bool BKE_blendfile_read_from_memfile(
435         bContext *C, struct MemFile *memfile,
436         const struct BlendFileReadParams *params,
437         ReportList *reports)
438 {
439         Main *bmain = CTX_data_main(C);
440         BlendFileData *bfd;
441
442         bfd = BLO_read_from_memfile(bmain, BKE_main_blendfile_path(bmain), memfile, params->skip_flags, reports);
443         if (bfd) {
444                 /* remove the unused screens and wm */
445                 while (bfd->main->wm.first)
446                         BKE_libblock_free(bfd->main, bfd->main->wm.first);
447                 while (bfd->main->screen.first)
448                         BKE_libblock_free(bfd->main, bfd->main->screen.first);
449
450                 setup_app_data(C, bfd, "<memory1>", params->is_startup, reports);
451         }
452         else {
453                 BKE_reports_prepend(reports, "Loading failed: ");
454         }
455
456         return (bfd != NULL);
457 }
458
459 /**
460  * Utility to make a file 'empty' used for startup to optionally give an empty file.
461  * Handy for tests.
462  */
463 void BKE_blendfile_read_make_empty(bContext *C)
464 {
465         Main *bmain = CTX_data_main(C);
466
467         ListBase *lbarray[MAX_LIBARRAY];
468         ID *id;
469         int a;
470
471         a = set_listbasepointers(bmain, lbarray);
472         while (a--) {
473                 id = lbarray[a]->first;
474                 if (id != NULL) {
475                         if (ELEM(GS(id->name), ID_SCE, ID_SCR, ID_WM, ID_WS)) {
476                                 continue;
477                         }
478                         while ((id = lbarray[a]->first)) {
479                                 BKE_libblock_delete(bmain, id);
480                         }
481                 }
482         }
483 }
484
485 /* only read the userdef from a .blend */
486 UserDef *BKE_blendfile_userdef_read(const char *filepath, ReportList *reports)
487 {
488         BlendFileData *bfd;
489         UserDef *userdef = NULL;
490
491         bfd = BLO_read_from_file(filepath, BLO_READ_SKIP_ALL & ~BLO_READ_SKIP_USERDEF, reports);
492         if (bfd) {
493                 if (bfd->user) {
494                         userdef = bfd->user;
495                 }
496                 BKE_main_free(bfd->main);
497                 MEM_freeN(bfd);
498         }
499
500         return userdef;
501 }
502
503
504 UserDef *BKE_blendfile_userdef_read_from_memory(
505         const void *filebuf, int filelength,
506         ReportList *reports)
507 {
508         BlendFileData *bfd;
509         UserDef *userdef = NULL;
510
511         bfd = BLO_read_from_memory(
512                 filebuf, filelength,
513                 BLO_READ_SKIP_ALL & ~BLO_READ_SKIP_USERDEF,
514                 reports);
515         if (bfd) {
516                 if (bfd->user) {
517                         userdef = bfd->user;
518                 }
519                 BKE_main_free(bfd->main);
520                 MEM_freeN(bfd);
521         }
522         else {
523                 BKE_reports_prepend(reports, "Loading failed: ");
524         }
525
526         return userdef;
527 }
528
529
530 /**
531  * Only write the userdef in a .blend
532  * \return success
533  */
534 bool BKE_blendfile_userdef_write(const char *filepath, ReportList *reports)
535 {
536         Main *mainb = MEM_callocN(sizeof(Main), "empty main");
537         bool ok = false;
538
539         if (BLO_write_file(mainb, filepath, G_FILE_USERPREFS, reports, NULL)) {
540                 ok = true;
541         }
542
543         MEM_freeN(mainb);
544
545         return ok;
546 }
547
548 /**
549  * Only write the userdef in a .blend, merging with the existing blend file.
550  * \return success
551  *
552  * \note In the future we should re-evaluate user preferences,
553  * possibly splitting out system/hardware specific prefs.
554  */
555 bool BKE_blendfile_userdef_write_app_template(const char *filepath, ReportList *reports)
556 {
557         /* if it fails, overwrite is OK. */
558         UserDef *userdef_default = BKE_blendfile_userdef_read(filepath, NULL);
559         if (userdef_default == NULL) {
560                 return BKE_blendfile_userdef_write(filepath, reports);
561         }
562
563         BKE_blender_userdef_app_template_data_swap(&U, userdef_default);
564         bool ok = BKE_blendfile_userdef_write(filepath, reports);
565         BKE_blender_userdef_app_template_data_swap(&U, userdef_default);
566         BKE_blender_userdef_data_free(userdef_default, false);
567         MEM_freeN(userdef_default);
568         return ok;
569 }
570
571 WorkspaceConfigFileData *BKE_blendfile_workspace_config_read(const char *filepath, const void *filebuf, int filelength, ReportList *reports)
572 {
573         BlendFileData *bfd;
574         WorkspaceConfigFileData *workspace_config = NULL;
575
576         if (filepath) {
577                 bfd = BLO_read_from_file(filepath, BLO_READ_SKIP_USERDEF, reports);
578         }
579         else {
580                 bfd = BLO_read_from_memory(filebuf, filelength, BLO_READ_SKIP_USERDEF, reports);
581         }
582
583         if (bfd) {
584                 workspace_config = MEM_mallocN(sizeof(*workspace_config), __func__);
585                 workspace_config->main = bfd->main;
586                 workspace_config->workspaces = bfd->main->workspaces;
587
588                 MEM_freeN(bfd);
589         }
590
591         return workspace_config;
592 }
593
594 bool BKE_blendfile_workspace_config_write(Main *bmain, const char *filepath, ReportList *reports)
595 {
596         int fileflags = G.fileflags & ~(G_FILE_NO_UI | G_FILE_HISTORY);
597         bool retval = false;
598
599         BKE_blendfile_write_partial_begin(bmain);
600
601         for (WorkSpace *workspace = bmain->workspaces.first; workspace; workspace = workspace->id.next) {
602                 BKE_blendfile_write_partial_tag_ID(&workspace->id, true);
603         }
604
605         if (BKE_blendfile_write_partial(bmain, filepath, fileflags, reports)) {
606                 retval = true;
607         }
608
609         BKE_blendfile_write_partial_end(bmain);
610
611         return retval;
612 }
613
614 void BKE_blendfile_workspace_config_data_free(WorkspaceConfigFileData *workspace_config)
615 {
616         BKE_main_free(workspace_config->main);
617         MEM_freeN(workspace_config);
618 }
619
620 /** \} */
621
622
623 /* -------------------------------------------------------------------- */
624
625 /** \name Partial `.blend` file save.
626  * \{ */
627
628 void BKE_blendfile_write_partial_begin(Main *bmain_src)
629 {
630         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
631 }
632
633 void BKE_blendfile_write_partial_tag_ID(ID *id, bool set)
634 {
635         if (set) {
636                 id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
637         }
638         else {
639                 id->tag &= ~(LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT);
640         }
641 }
642
643 static void blendfile_write_partial_cb(void *UNUSED(handle), Main *UNUSED(bmain), void *vid)
644 {
645         if (vid) {
646                 ID *id = vid;
647                 /* only tag for need-expand if not done, prevents eternal loops */
648                 if ((id->tag & LIB_TAG_DOIT) == 0)
649                         id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
650
651                 if (id->lib && (id->lib->id.tag & LIB_TAG_DOIT) == 0)
652                         id->lib->id.tag |= LIB_TAG_DOIT;
653         }
654 }
655
656 /**
657  * \return Success.
658  */
659 bool BKE_blendfile_write_partial(
660         Main *bmain_src, const char *filepath, const int write_flags, ReportList *reports)
661 {
662         Main *bmain_dst = MEM_callocN(sizeof(Main), "copybuffer");
663         ListBase *lbarray_dst[MAX_LIBARRAY], *lbarray_src[MAX_LIBARRAY];
664         int a, retval;
665
666         void     *path_list_backup = NULL;
667         const int path_list_flag = (BKE_BPATH_TRAVERSE_SKIP_LIBRARY | BKE_BPATH_TRAVERSE_SKIP_MULTIFILE);
668
669         /* This is needed to be able to load that file as a real one later
670          * (otherwise main->name will not be set at read time). */
671         BLI_strncpy(bmain_dst->name, bmain_src->name, sizeof(bmain_dst->name));
672
673         BLO_main_expander(blendfile_write_partial_cb);
674         BLO_expand_main(NULL, bmain_src);
675
676         /* move over all tagged blocks */
677         set_listbasepointers(bmain_src, lbarray_src);
678         a = set_listbasepointers(bmain_dst, lbarray_dst);
679         while (a--) {
680                 ID *id, *nextid;
681                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
682
683                 for (id = lb_src->first; id; id = nextid) {
684                         nextid = id->next;
685                         if (id->tag & LIB_TAG_DOIT) {
686                                 BLI_remlink(lb_src, id);
687                                 BLI_addtail(lb_dst, id);
688                         }
689                 }
690         }
691
692         /* Backup paths because remap relative will overwrite them.
693          *
694          * NOTE: we do this only on the list of datablocks that we are writing
695          * because the restored full list is not guaranteed to be in the same
696          * order as before, as expected by BKE_bpath_list_restore.
697          *
698          * This happens because id_sort_by_name does not take into account
699          * string case or the library name, so the order is not strictly
700          * defined for two linked datablocks with the same name! */
701         if (write_flags & G_FILE_RELATIVE_REMAP) {
702                 path_list_backup = BKE_bpath_list_backup(bmain_dst, path_list_flag);
703         }
704
705         /* save the buffer */
706         retval = BLO_write_file(bmain_dst, filepath, write_flags, reports, NULL);
707
708         if (path_list_backup) {
709                 BKE_bpath_list_restore(bmain_dst, path_list_flag, path_list_backup);
710                 BKE_bpath_list_free(path_list_backup);
711         }
712
713         /* move back the main, now sorted again */
714         set_listbasepointers(bmain_src, lbarray_dst);
715         a = set_listbasepointers(bmain_dst, lbarray_src);
716         while (a--) {
717                 ID *id;
718                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
719
720                 while ((id = BLI_pophead(lb_src))) {
721                         BLI_addtail(lb_dst, id);
722                         id_sort_by_name(lb_dst, id);
723                 }
724         }
725
726         MEM_freeN(bmain_dst);
727
728         return retval;
729 }
730
731 void BKE_blendfile_write_partial_end(Main *bmain_src)
732 {
733         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
734 }
735
736 /** \} */