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