baf93ffd824ab8717c5ec13c4a9610ad57f34d0e
[blender.git] / source / blender / blenkernel / intern / blender.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/blender.c
29  *  \ingroup bke
30  */
31
32 #ifndef _GNU_SOURCE
33 /* Needed for O_NOFOLLOW on some platforms. */
34 #  define _GNU_SOURCE 1
35 #endif
36
37 #ifndef _WIN32 
38 #  include <unistd.h> // for read close
39 #else
40 #  include <io.h> // for open close read
41 #endif
42
43 #include <stdlib.h>
44 #include <stdio.h>
45 #include <stddef.h>
46 #include <string.h>
47 #include <fcntl.h>  /* for open */
48 #include <errno.h>
49
50 #include "MEM_guardedalloc.h"
51
52 #include "DNA_userdef_types.h"
53 #include "DNA_scene_types.h"
54 #include "DNA_screen_types.h"
55 #include "DNA_view3d_types.h"
56 #include "DNA_windowmanager_types.h"
57
58 #include "BLI_blenlib.h"
59 #include "BLI_utildefines.h"
60 #include "BLI_callbacks.h"
61
62 #include "IMB_imbuf.h"
63 #include "IMB_moviecache.h"
64
65 #include "BKE_appdir.h"
66 #include "BKE_blender.h"
67 #include "BKE_bpath.h"
68 #include "BKE_brush.h"
69 #include "BKE_context.h"
70 #include "BKE_depsgraph.h"
71 #include "BKE_global.h"
72 #include "BKE_idprop.h"
73 #include "BKE_image.h"
74 #include "BKE_ipo.h"
75 #include "BKE_library.h"
76 #include "BKE_main.h"
77 #include "BKE_node.h"
78 #include "BKE_report.h"
79 #include "BKE_scene.h"
80 #include "BKE_screen.h"
81 #include "BKE_sequencer.h"
82 #include "BKE_sound.h"
83
84 #include "RE_pipeline.h"
85 #include "RE_render_ext.h"
86
87 #include "BLF_api.h"
88
89 #include "BLO_undofile.h"
90 #include "BLO_readfile.h" 
91 #include "BLO_writefile.h" 
92
93 #include "RNA_access.h"
94
95 #include "WM_api.h" // XXXXX BAD, very BAD dependency (bad level call) - remove asap, elubie
96
97 #include "IMB_colormanagement.h"
98
99 #ifdef WITH_PYTHON
100 #  include "BPY_extern.h"
101 #endif
102
103 Global G;
104 UserDef U;
105 /* ListBase = {NULL, NULL}; */
106
107 char versionstr[48] = "";
108
109 /* ********** free ********** */
110
111 /* only to be called on exit blender */
112 void free_blender(void)
113 {
114         /* samples are in a global list..., also sets G.main->sound->sample NULL */
115         BKE_main_free(G.main);
116         G.main = NULL;
117
118         BKE_spacetypes_free();      /* after free main, it uses space callbacks */
119         
120         IMB_exit();
121         BKE_images_exit();
122         DAG_exit();
123
124         BKE_brush_system_exit();
125         RE_texture_rng_exit();  
126
127         BLI_callback_global_finalize();
128
129         BKE_sequencer_cache_destruct();
130         IMB_moviecache_destruct();
131         
132         free_nodesystem();
133 }
134
135 void initglobals(void)
136 {
137         memset(&G, 0, sizeof(Global));
138         
139         U.savetime = 1;
140
141         G.main = BKE_main_new();
142
143         strcpy(G.ima, "//");
144
145         if (BLENDER_SUBVERSION)
146                 BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d.%d", BLENDER_VERSION / 100, BLENDER_VERSION % 100, BLENDER_SUBVERSION);
147         else
148                 BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d", BLENDER_VERSION / 100, BLENDER_VERSION % 100);
149
150 #ifndef WITH_PYTHON_SECURITY /* default */
151         G.f |= G_SCRIPT_AUTOEXEC;
152 #else
153         G.f &= ~G_SCRIPT_AUTOEXEC;
154 #endif
155 }
156
157 /***/
158
159 static void clear_global(void) 
160 {
161 //      extern short winqueue_break;    /* screen.c */
162
163         BKE_main_free(G.main);          /* free all lib data */
164         
165 //      free_vertexpaint();
166
167         G.main = NULL;
168 }
169
170 static bool clean_paths_visit_cb(void *UNUSED(userdata), char *path_dst, const char *path_src)
171 {
172         strcpy(path_dst, path_src);
173         BLI_path_native_slash(path_dst);
174         return !STREQ(path_dst, path_src);
175 }
176
177 /* make sure path names are correct for OS */
178 static void clean_paths(Main *main)
179 {
180         Scene *scene;
181
182         BKE_bpath_traverse_main(main, clean_paths_visit_cb, BKE_BPATH_TRAVERSE_SKIP_MULTIFILE, NULL);
183
184         for (scene = main->scene.first; scene; scene = scene->id.next) {
185                 BLI_path_native_slash(scene->r.pic);
186         }
187 }
188
189 static bool wm_scene_is_visible(wmWindowManager *wm, Scene *scene)
190 {
191         wmWindow *win;
192         for (win = wm->windows.first; win; win = win->next) {
193                 if (win->screen->scene == scene) {
194                         return true;
195                 }
196         }
197         return false;
198 }
199
200 /**
201  * Context matching, handle no-ui case
202  *
203  * \note this is called on Undo so any slow conversion functions here
204  * should be avoided or check (mode != LOAD_UNDO).
205  *
206  * \param bfd: Blend file data, freed by this function on exit.
207  * \param filepath: File path or identifier.
208  */
209 static void setup_app_data(
210         bContext *C, BlendFileData *bfd,
211         const char *filepath, ReportList *reports)
212 {
213         Scene *curscene = NULL;
214         const bool recover = (G.fileflags & G_FILE_RECOVER) != 0;
215         enum {
216                 LOAD_UI = 1,
217                 LOAD_UI_OFF,
218                 LOAD_UNDO,
219         } mode;
220
221         if (BLI_listbase_is_empty(&bfd->main->screen)) {
222                 mode = LOAD_UNDO;
223         }
224         else if (G.fileflags & G_FILE_NO_UI) {
225                 mode = LOAD_UI_OFF;
226         }
227         else {
228                 mode = LOAD_UI;
229         }
230
231         if (mode != LOAD_UNDO) {
232                 /* may happen with library files */
233                 if (ELEM(NULL, bfd->curscreen, bfd->curscene)) {
234                         BKE_report(reports, RPT_WARNING, "Library file, loading empty scene");
235                         mode = LOAD_UI_OFF;
236                 }
237         }
238
239         /* Free all render results, without this stale data gets displayed after loading files */
240         if (mode != LOAD_UNDO) {
241                 RE_FreeAllRenderResults();
242         }
243
244         /* Only make filepaths compatible when loading for real (not undo) */
245         if (mode != LOAD_UNDO) {
246                 clean_paths(bfd->main);
247         }
248
249         /* XXX here the complex windowmanager matching */
250         
251         /* no load screens? */
252         if (mode != LOAD_UI) {
253                 /* Logic for 'track_undo_scene' is to keep using the scene which the active screen has,
254                  * as long as the scene associated with the undo operation is visible in one of the open windows.
255                  *
256                  * - 'curscreen->scene' - scene the user is currently looking at.
257                  * - 'bfd->curscene' - scene undo-step was created in.
258                  *
259                  * This means users can have 2+ windows open and undo in both without screens switching.
260                  * But if they close one of the screens,
261                  * undo will ensure that the scene being operated on will be activated
262                  * (otherwise we'd be undoing on an off-screen scene which isn't acceptable).
263                  * see: T43424
264                  */
265                 bScreen *curscreen = NULL;
266                 bool track_undo_scene;
267
268                 /* comes from readfile.c */
269                 SWAP(ListBase, G.main->wm, bfd->main->wm);
270                 SWAP(ListBase, G.main->screen, bfd->main->screen);
271                 
272                 /* we re-use current screen */
273                 curscreen = CTX_wm_screen(C);
274                 /* but use new Scene pointer */
275                 curscene = bfd->curscene;
276
277                 track_undo_scene = (mode == LOAD_UNDO && curscreen && curscene && bfd->main->wm.first);
278
279                 if (curscene == NULL) {
280                         curscene = bfd->main->scene.first;
281                 }
282                 /* empty file, we add a scene to make Blender work */
283                 if (curscene == NULL) {
284                         curscene = BKE_scene_add(bfd->main, "Empty");
285                 }
286
287                 if (track_undo_scene) {
288                         /* keep the old (free'd) scene, let 'blo_lib_link_screen_restore'
289                          * replace it with 'curscene' if its needed */
290                 }
291                 else {
292                         /* and we enforce curscene to be in current screen */
293                         if (curscreen) {
294                                 /* can run in bgmode */
295                                 curscreen->scene = curscene;
296                         }
297                 }
298
299                 /* clear_global will free G.main, here we can still restore pointers */
300                 blo_lib_link_screen_restore(bfd->main, curscreen, curscene);
301                 /* curscreen might not be set when loading without ui (see T44217) so only re-assign if available */
302                 if (curscreen) {
303                         curscene = curscreen->scene;
304                 }
305
306                 if (track_undo_scene) {
307                         wmWindowManager *wm = bfd->main->wm.first;
308                         if (wm_scene_is_visible(wm, bfd->curscene) == false) {
309                                 curscene = bfd->curscene;
310                                 curscreen->scene = curscene;
311                                 BKE_screen_view3d_scene_sync(curscreen);
312                         }
313                 }
314         }
315         
316         /* free G.main Main database */
317 //      CTX_wm_manager_set(C, NULL);
318         clear_global();
319         
320         /* clear old property update cache, in case some old references are left dangling */
321         RNA_property_update_cache_free();
322         
323         G.main = bfd->main;
324
325         CTX_data_main_set(C, G.main);
326
327         if (bfd->user) {
328                 
329                 /* only here free userdef themes... */
330                 BKE_userdef_free();
331                 
332                 U = *bfd->user;
333
334                 /* Security issue: any blend file could include a USER block.
335                  *
336                  * Currently we load prefs from BLENDER_STARTUP_FILE and later on load BLENDER_USERPREF_FILE,
337                  * to load the preferences defined in the users home dir.
338                  *
339                  * This means we will never accidentally (or maliciously)
340                  * enable scripts auto-execution by loading a '.blend' file.
341                  */
342                 U.flag |= USER_SCRIPT_AUTOEXEC_DISABLE;
343
344                 MEM_freeN(bfd->user);
345         }
346         
347         /* case G_FILE_NO_UI or no screens in file */
348         if (mode != LOAD_UI) {
349                 /* leave entire context further unaltered? */
350                 CTX_data_scene_set(C, curscene);
351         }
352         else {
353                 G.fileflags = bfd->fileflags;
354                 CTX_wm_manager_set(C, G.main->wm.first);
355                 CTX_wm_screen_set(C, bfd->curscreen);
356                 CTX_data_scene_set(C, bfd->curscene);
357                 CTX_wm_area_set(C, NULL);
358                 CTX_wm_region_set(C, NULL);
359                 CTX_wm_menu_set(C, NULL);
360                 curscene = bfd->curscene;
361         }
362         
363         /* this can happen when active scene was lib-linked, and doesn't exist anymore */
364         if (CTX_data_scene(C) == NULL) {
365                 /* in case we don't even have a local scene, add one */
366                 if (!G.main->scene.first)
367                         BKE_scene_add(G.main, "Empty");
368
369                 CTX_data_scene_set(C, G.main->scene.first);
370                 CTX_wm_screen(C)->scene = CTX_data_scene(C);
371                 curscene = CTX_data_scene(C);
372         }
373
374         BLI_assert(curscene == CTX_data_scene(C));
375
376
377         /* special cases, override loaded flags: */
378         if (G.f != bfd->globalf) {
379                 const int flags_keep = (G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
380                 bfd->globalf = (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
381         }
382
383
384         G.f = bfd->globalf;
385
386 #ifdef WITH_PYTHON
387         /* let python know about new main */
388         BPY_context_update(C);
389 #endif
390
391         /* FIXME: this version patching should really be part of the file-reading code,
392          * but we still get too many unrelated data-corruption crashes otherwise... */
393         if (G.main->versionfile < 250)
394                 do_versions_ipos_to_animato(G.main);
395         
396         G.main->recovered = 0;
397         
398         /* startup.blend or recovered startup */
399         if (bfd->filename[0] == 0) {
400                 G.main->name[0] = 0;
401         }
402         else if (recover && G.relbase_valid) {
403                 /* in case of autosave or quit.blend, use original filename instead
404                  * use relbase_valid to make sure the file is saved, else we get <memory2> in the filename */
405                 filepath = bfd->filename;
406                 G.main->recovered = 1;
407         
408                 /* these are the same at times, should never copy to the same location */
409                 if (G.main->name != filepath)
410                         BLI_strncpy(G.main->name, filepath, FILE_MAX);
411         }
412         
413         /* baseflags, groups, make depsgraph, etc */
414         /* first handle case if other windows have different scenes visible */
415         if (mode == LOAD_UI) {
416                 wmWindowManager *wm = G.main->wm.first;
417                 
418                 if (wm) {
419                         wmWindow *win;
420                         
421                         for (win = wm->windows.first; win; win = win->next) {
422                                 if (win->screen && win->screen->scene) /* zealous check... */
423                                         if (win->screen->scene != curscene)
424                                                 BKE_scene_set_background(G.main, win->screen->scene);
425                         }
426                 }
427         }
428         BKE_scene_set_background(G.main, curscene);
429
430         if (mode != LOAD_UNDO) {
431                 RE_FreeAllPersistentData();
432                 IMB_colormanagement_check_file_config(G.main);
433         }
434
435         MEM_freeN(bfd);
436
437 }
438
439 static int handle_subversion_warning(Main *main, ReportList *reports)
440 {
441         if (main->minversionfile > BLENDER_VERSION ||
442             (main->minversionfile == BLENDER_VERSION &&
443              main->minsubversionfile > BLENDER_SUBVERSION))
444         {
445                 BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary (%d.%d), expect loss of data!",
446                             main->minversionfile, main->minsubversionfile);
447         }
448
449         return 1;
450 }
451
452 static void keymap_item_free(wmKeyMapItem *kmi)
453 {
454         if (kmi->properties) {
455                 IDP_FreeProperty(kmi->properties);
456                 MEM_freeN(kmi->properties);
457         }
458         if (kmi->ptr)
459                 MEM_freeN(kmi->ptr);
460 }
461
462 void BKE_userdef_free(void)
463 {
464         wmKeyMap *km;
465         wmKeyMapItem *kmi;
466         wmKeyMapDiffItem *kmdi;
467         bAddon *addon, *addon_next;
468         uiFont *font;
469
470         for (km = U.user_keymaps.first; km; km = km->next) {
471                 for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
472                         if (kmdi->add_item) {
473                                 keymap_item_free(kmdi->add_item);
474                                 MEM_freeN(kmdi->add_item);
475                         }
476                         if (kmdi->remove_item) {
477                                 keymap_item_free(kmdi->remove_item);
478                                 MEM_freeN(kmdi->remove_item);
479                         }
480                 }
481
482                 for (kmi = km->items.first; kmi; kmi = kmi->next)
483                         keymap_item_free(kmi);
484
485                 BLI_freelistN(&km->diff_items);
486                 BLI_freelistN(&km->items);
487         }
488         
489         for (addon = U.addons.first; addon; addon = addon_next) {
490                 addon_next = addon->next;
491                 if (addon->prop) {
492                         IDP_FreeProperty(addon->prop);
493                         MEM_freeN(addon->prop);
494                 }
495                 MEM_freeN(addon);
496         }
497
498         for (font = U.uifonts.first; font; font = font->next) {
499                 BLF_unload_id(font->blf_id);
500         }
501
502         BLF_default_set(-1);
503
504         BLI_freelistN(&U.autoexec_paths);
505
506         BLI_freelistN(&U.uistyles);
507         BLI_freelistN(&U.uifonts);
508         BLI_freelistN(&U.themes);
509         BLI_freelistN(&U.user_keymaps);
510 }
511
512 /* handle changes in settings that need recalc */
513 void BKE_userdef_state(void)
514 {
515         /* prevent accidents */
516         if (U.pixelsize == 0) U.pixelsize = 1;
517         
518         BLF_default_dpi(U.pixelsize * U.dpi);
519         U.widget_unit = (U.pixelsize * U.dpi * 20 + 36) / 72;
520
521 }
522
523 int BKE_read_file(bContext *C, const char *filepath, ReportList *reports)
524 {
525         BlendFileData *bfd;
526         int retval = BKE_READ_FILE_OK;
527
528         if (strstr(filepath, BLENDER_STARTUP_FILE) == NULL) /* don't print user-pref loading */
529                 printf("read blend: %s\n", filepath);
530
531         bfd = BLO_read_from_file(filepath, reports);
532         if (bfd) {
533                 if (bfd->user) retval = BKE_READ_FILE_OK_USERPREFS;
534                 
535                 if (0 == handle_subversion_warning(bfd->main, reports)) {
536                         BKE_main_free(bfd->main);
537                         MEM_freeN(bfd);
538                         bfd = NULL;
539                         retval = BKE_READ_FILE_FAIL;
540                 }
541                 else {
542                         setup_app_data(C, bfd, filepath, reports);
543                 }
544         }
545         else
546                 BKE_reports_prependf(reports, "Loading '%s' failed: ", filepath);
547                 
548         return (bfd ? retval : BKE_READ_FILE_FAIL);
549 }
550
551 bool BKE_read_file_from_memory(
552         bContext *C, const void *filebuf, int filelength,
553         ReportList *reports, bool update_defaults)
554 {
555         BlendFileData *bfd;
556
557         bfd = BLO_read_from_memory(filebuf, filelength, reports);
558         if (bfd) {
559                 if (update_defaults)
560                         BLO_update_defaults_startup_blend(bfd->main);
561                 setup_app_data(C, bfd, "<memory2>", reports);
562         }
563         else {
564                 BKE_reports_prepend(reports, "Loading failed: ");
565         }
566
567         return (bfd != NULL);
568 }
569
570 /* memfile is the undo buffer */
571 bool BKE_read_file_from_memfile(
572         bContext *C, MemFile *memfile,
573         ReportList *reports)
574 {
575         BlendFileData *bfd;
576
577         bfd = BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports);
578         if (bfd) {
579                 /* remove the unused screens and wm */
580                 while (bfd->main->wm.first)
581                         BKE_libblock_free_ex(bfd->main, bfd->main->wm.first, true);
582                 while (bfd->main->screen.first)
583                         BKE_libblock_free_ex(bfd->main, bfd->main->screen.first, true);
584                 
585                 setup_app_data(C, bfd, "<memory1>", reports);
586         }
587         else {
588                 BKE_reports_prepend(reports, "Loading failed: ");
589         }
590
591         return (bfd != NULL);
592 }
593
594 /* only read the userdef from a .blend */
595 int BKE_read_file_userdef(const char *filepath, ReportList *reports)
596 {
597         BlendFileData *bfd;
598         int retval = BKE_READ_FILE_FAIL;
599
600         bfd = BLO_read_from_file(filepath, reports);
601         if (bfd) {
602                 if (bfd->user) {
603                         retval = BKE_READ_FILE_OK_USERPREFS;
604
605                         /* only here free userdef themes... */
606                         BKE_userdef_free();
607
608                         U = *bfd->user;
609                         MEM_freeN(bfd->user);
610                 }
611                 BKE_main_free(bfd->main);
612                 MEM_freeN(bfd);
613         }
614         
615         return retval;
616 }
617
618 /* only write the userdef in a .blend */
619 int BKE_write_file_userdef(const char *filepath, ReportList *reports)
620 {
621         Main *mainb = MEM_callocN(sizeof(Main), "empty main");
622         int retval = 0;
623         
624         if (BLO_write_file(mainb, filepath, G_FILE_USERPREFS, reports, NULL)) {
625                 retval = 1;
626         }
627         
628         MEM_freeN(mainb);
629         
630         return retval;
631 }
632
633 /* *****************  testing for break ************* */
634
635 static void (*blender_test_break_cb)(void) = NULL;
636
637 void BKE_blender_callback_test_break_set(void (*func)(void))
638 {
639         blender_test_break_cb = func;
640 }
641
642
643 int blender_test_break(void)
644 {
645         if (!G.background) {
646                 if (blender_test_break_cb)
647                         blender_test_break_cb();
648         }
649         
650         return (G.is_break == true);
651 }
652
653
654 /* -------------------------------------------------------------------- */
655
656 /** \name Global Undo
657  * \{ */
658
659 #define UNDO_DISK   0
660
661 typedef struct UndoElem {
662         struct UndoElem *next, *prev;
663         char str[FILE_MAX];
664         char name[BKE_UNDO_STR_MAX];
665         MemFile memfile;
666         uintptr_t undosize;
667 } UndoElem;
668
669 static ListBase undobase = {NULL, NULL};
670 static UndoElem *curundo = NULL;
671
672
673 static int read_undosave(bContext *C, UndoElem *uel)
674 {
675         char mainstr[sizeof(G.main->name)];
676         int success = 0, fileflags;
677         
678         /* This is needed so undoing/redoing doesn't crash with threaded previews going */
679         WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));
680
681         BLI_strncpy(mainstr, G.main->name, sizeof(mainstr));    /* temporal store */
682
683         fileflags = G.fileflags;
684         G.fileflags |= G_FILE_NO_UI;
685
686         if (UNDO_DISK) 
687                 success = (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL);
688         else
689                 success = BKE_read_file_from_memfile(C, &uel->memfile, NULL);
690
691         /* restore */
692         BLI_strncpy(G.main->name, mainstr, sizeof(G.main->name)); /* restore */
693         G.fileflags = fileflags;
694
695         if (success) {
696                 /* important not to update time here, else non keyed tranforms are lost */
697                 DAG_on_visible_update(G.main, false);
698         }
699
700         return success;
701 }
702
703 /* name can be a dynamic string */
704 void BKE_undo_write(bContext *C, const char *name)
705 {
706         uintptr_t maxmem, totmem, memused;
707         int nr /*, success */ /* UNUSED */;
708         UndoElem *uel;
709         
710         if ((U.uiflag & USER_GLOBALUNDO) == 0) {
711                 return;
712         }
713
714         if (U.undosteps == 0) {
715                 return;
716         }
717         
718         /* remove all undos after (also when curundo == NULL) */
719         while (undobase.last != curundo) {
720                 uel = undobase.last;
721                 BLI_remlink(&undobase, uel);
722                 BLO_memfile_free(&uel->memfile);
723                 MEM_freeN(uel);
724         }
725         
726         /* make new */
727         curundo = uel = MEM_callocN(sizeof(UndoElem), "undo file");
728         BLI_strncpy(uel->name, name, sizeof(uel->name));
729         BLI_addtail(&undobase, uel);
730         
731         /* and limit amount to the maximum */
732         nr = 0;
733         uel = undobase.last;
734         while (uel) {
735                 nr++;
736                 if (nr == U.undosteps) break;
737                 uel = uel->prev;
738         }
739         if (uel) {
740                 while (undobase.first != uel) {
741                         UndoElem *first = undobase.first;
742                         BLI_remlink(&undobase, first);
743                         /* the merge is because of compression */
744                         BLO_memfile_merge(&first->memfile, &first->next->memfile);
745                         MEM_freeN(first);
746                 }
747         }
748
749
750         /* disk save version */
751         if (UNDO_DISK) {
752                 static int counter = 0;
753                 char filepath[FILE_MAX];
754                 char numstr[32];
755                 int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */
756
757                 /* calculate current filepath */
758                 counter++;
759                 counter = counter % U.undosteps;
760         
761                 BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter);
762                 BLI_make_file_string("/", filepath, BKE_tempdir_session(), numstr);
763         
764                 /* success = */ /* UNUSED */ BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);
765                 
766                 BLI_strncpy(curundo->str, filepath, sizeof(curundo->str));
767         }
768         else {
769                 MemFile *prevfile = NULL;
770                 
771                 if (curundo->prev) prevfile = &(curundo->prev->memfile);
772                 
773                 memused = MEM_get_memory_in_use();
774                 /* success = */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags);
775                 curundo->undosize = MEM_get_memory_in_use() - memused;
776         }
777
778         if (U.undomemory != 0) {
779                 /* limit to maximum memory (afterwards, we can't know in advance) */
780                 totmem = 0;
781                 maxmem = ((uintptr_t)U.undomemory) * 1024 * 1024;
782
783                 /* keep at least two (original + other) */
784                 uel = undobase.last;
785                 while (uel && uel->prev) {
786                         totmem += uel->undosize;
787                         if (totmem > maxmem) break;
788                         uel = uel->prev;
789                 }
790
791                 if (uel) {
792                         if (uel->prev && uel->prev->prev)
793                                 uel = uel->prev;
794
795                         while (undobase.first != uel) {
796                                 UndoElem *first = undobase.first;
797                                 BLI_remlink(&undobase, first);
798                                 /* the merge is because of compression */
799                                 BLO_memfile_merge(&first->memfile, &first->next->memfile);
800                                 MEM_freeN(first);
801                         }
802                 }
803         }
804 }
805
806 /* 1 = an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
807 void BKE_undo_step(bContext *C, int step)
808 {
809         
810         if (step == 0) {
811                 read_undosave(C, curundo);
812         }
813         else if (step == 1) {
814                 /* curundo should never be NULL, after restart or load file it should call undo_save */
815                 if (curundo == NULL || curundo->prev == NULL) {
816                         // XXX error("No undo available");
817                 }
818                 else {
819                         if (G.debug & G_DEBUG) printf("undo %s\n", curundo->name);
820                         curundo = curundo->prev;
821                         read_undosave(C, curundo);
822                 }
823         }
824         else {
825                 /* curundo has to remain current situation! */
826                 
827                 if (curundo == NULL || curundo->next == NULL) {
828                         // XXX error("No redo available");
829                 }
830                 else {
831                         read_undosave(C, curundo->next);
832                         curundo = curundo->next;
833                         if (G.debug & G_DEBUG) printf("redo %s\n", curundo->name);
834                 }
835         }
836 }
837
838 void BKE_undo_reset(void)
839 {
840         UndoElem *uel;
841         
842         uel = undobase.first;
843         while (uel) {
844                 BLO_memfile_free(&uel->memfile);
845                 uel = uel->next;
846         }
847         
848         BLI_freelistN(&undobase);
849         curundo = NULL;
850 }
851
852 /* based on index nr it does a restore */
853 void BKE_undo_number(bContext *C, int nr)
854 {
855         curundo = BLI_findlink(&undobase, nr);
856         BKE_undo_step(C, 0);
857 }
858
859 /* go back to the last occurance of name in stack */
860 void BKE_undo_name(bContext *C, const char *name)
861 {
862         UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
863
864         if (uel && uel->prev) {
865                 curundo = uel->prev;
866                 BKE_undo_step(C, 0);
867         }
868 }
869
870 /* name optional */
871 bool BKE_undo_is_valid(const char *name)
872 {
873         if (name) {
874                 UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
875                 return uel && uel->prev;
876         }
877         
878         return undobase.last != undobase.first;
879 }
880
881 /* get name of undo item, return null if no item with this index */
882 /* if active pointer, set it to 1 if true */
883 const char *BKE_undo_get_name(int nr, bool *r_active)
884 {
885         UndoElem *uel = BLI_findlink(&undobase, nr);
886         
887         if (r_active) *r_active = false;
888         
889         if (uel) {
890                 if (r_active && (uel == curundo)) {
891                         *r_active = true;
892                 }
893                 return uel->name;
894         }
895         return NULL;
896 }
897
898 /**
899  * Saves .blend using undo buffer.
900  *
901  * \return success.
902  */
903 bool BKE_undo_save_file(const char *filename)
904 {
905         UndoElem *uel;
906         MemFileChunk *chunk;
907         int file, oflags;
908
909         if ((U.uiflag & USER_GLOBALUNDO) == 0) {
910                 return false;
911         }
912
913         uel = curundo;
914         if (uel == NULL) {
915                 fprintf(stderr, "No undo buffer to save recovery file\n");
916                 return false;
917         }
918
919         /* note: This is currently used for autosave and 'quit.blend', where _not_ following symlinks is OK,
920          * however if this is ever executed explicitly by the user, we may want to allow writing to symlinks.
921          */
922
923         oflags = O_BINARY | O_WRONLY | O_CREAT | O_TRUNC;
924 #ifdef O_NOFOLLOW
925         /* use O_NOFOLLOW to avoid writing to a symlink - use 'O_EXCL' (CVE-2008-1103) */
926         oflags |= O_NOFOLLOW;
927 #else
928         /* TODO(sergey): How to deal with symlinks on windows? */
929 #  ifndef _MSC_VER
930 #    warning "Symbolic links will be followed on undo save, possibly causing CVE-2008-1103"
931 #  endif
932 #endif
933         file = BLI_open(filename,  oflags, 0666);
934
935         if (file == -1) {
936                 fprintf(stderr, "Unable to save '%s': %s\n",
937                         filename, errno ? strerror(errno) : "Unknown error opening file");
938                 return false;
939         }
940
941         for (chunk = uel->memfile.chunks.first; chunk; chunk = chunk->next) {
942                 if (write(file, chunk->buf, chunk->size) != chunk->size) {
943                         break;
944                 }
945         }
946         
947         close(file);
948         
949         if (chunk) {
950                 fprintf(stderr, "Unable to save '%s': %s\n",
951                         filename, errno ? strerror(errno) : "Unknown error writing file");
952                 return false;
953         }
954         return true;
955 }
956
957 /* sets curscene */
958 Main *BKE_undo_get_main(Scene **r_scene)
959 {
960         Main *mainp = NULL;
961         BlendFileData *bfd = BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL);
962         
963         if (bfd) {
964                 mainp = bfd->main;
965                 if (r_scene) {
966                         *r_scene = bfd->curscene;
967                 }
968                 
969                 MEM_freeN(bfd);
970         }
971         
972         return mainp;
973 }
974
975 /** \} */
976
977
978 /* -------------------------------------------------------------------- */
979
980 /** \name Partial `.blend` file save.
981  * \{ */
982
983 void BKE_blendfile_write_partial_begin(Main *bmain_src)
984 {
985         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
986 }
987
988 void BKE_blendfile_write_partial_tag_ID(ID *id, bool set)
989 {
990         if (set) {
991                 id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
992         }
993         else {
994                 id->tag &= ~(LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT);
995         }
996 }
997
998 static void blendfile_write_partial_cb(void *UNUSED(handle), Main *UNUSED(bmain), void *vid)
999 {
1000         if (vid) {
1001                 ID *id = vid;
1002                 /* only tag for need-expand if not done, prevents eternal loops */
1003                 if ((id->tag & LIB_TAG_DOIT) == 0)
1004                         id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
1005         }
1006 }
1007
1008 /**
1009  * \return Success.
1010  */
1011 bool BKE_blendfile_write_partial(
1012         Main *bmain_src, const char *filepath, const int write_flags, ReportList *reports)
1013 {
1014         Main *bmain_dst = MEM_callocN(sizeof(Main), "copybuffer");
1015         ListBase *lbarray_dst[MAX_LIBARRAY], *lbarray_src[MAX_LIBARRAY];
1016         int a, retval;
1017
1018         void     *path_list_backup = NULL;
1019         const int path_list_flag = (BKE_BPATH_TRAVERSE_SKIP_LIBRARY | BKE_BPATH_TRAVERSE_SKIP_MULTIFILE);
1020
1021         if (write_flags & G_FILE_RELATIVE_REMAP) {
1022                 path_list_backup = BKE_bpath_list_backup(bmain_src, path_list_flag);
1023         }
1024
1025         BLO_main_expander(blendfile_write_partial_cb);
1026         BLO_expand_main(NULL, bmain_src);
1027
1028         /* move over all tagged blocks */
1029         set_listbasepointers(bmain_src, lbarray_src);
1030         a = set_listbasepointers(bmain_dst, lbarray_dst);
1031         while (a--) {
1032                 ID *id, *nextid;
1033                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
1034                 
1035                 for (id = lb_src->first; id; id = nextid) {
1036                         nextid = id->next;
1037                         if (id->tag & LIB_TAG_DOIT) {
1038                                 BLI_remlink(lb_src, id);
1039                                 BLI_addtail(lb_dst, id);
1040                         }
1041                 }
1042         }
1043         
1044         
1045         /* save the buffer */
1046         retval = BLO_write_file(bmain_dst, filepath, write_flags, reports, NULL);
1047         
1048         /* move back the main, now sorted again */
1049         set_listbasepointers(bmain_src, lbarray_dst);
1050         a = set_listbasepointers(bmain_dst, lbarray_src);
1051         while (a--) {
1052                 ID *id;
1053                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
1054                 
1055                 while ((id = BLI_pophead(lb_src))) {
1056                         BLI_addtail(lb_dst, id);
1057                         id_sort_by_name(lb_dst, id);
1058                 }
1059         }
1060         
1061         MEM_freeN(bmain_dst);
1062         
1063         if (path_list_backup) {
1064                 BKE_bpath_list_restore(bmain_src, path_list_flag, path_list_backup);
1065                 BKE_bpath_list_free(path_list_backup);
1066         }
1067
1068         return retval;
1069 }
1070
1071 void BKE_blendfile_write_partial_end(Main *bmain_src)
1072 {
1073         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
1074 }
1075
1076 /** \} */
1077
1078
1079 /* -------------------------------------------------------------------- */
1080
1081 /** \name Copy/Paste `.blend`, partial saves.
1082  * \{ */
1083
1084 void BKE_copybuffer_begin(Main *bmain_src)
1085 {
1086         BKE_blendfile_write_partial_begin(bmain_src);
1087 }
1088
1089 void BKE_copybuffer_tag_ID(ID *id)
1090 {
1091         BKE_blendfile_write_partial_tag_ID(id, true);
1092 }
1093
1094 /**
1095  * \return Success.
1096  */
1097 bool BKE_copybuffer_save(Main *bmain_src, const char *filename, ReportList *reports)
1098 {
1099         const int write_flags = G_FILE_RELATIVE_REMAP;
1100
1101         bool retval = BKE_blendfile_write_partial(bmain_src, filename, write_flags, reports);
1102
1103         BKE_blendfile_write_partial_end(bmain_src);
1104
1105         return retval;
1106 }
1107
1108 /**
1109  * \return Success.
1110  */
1111 bool BKE_copybuffer_paste(bContext *C, const char *libname, const short flag, ReportList *reports)
1112 {
1113         Main *bmain = CTX_data_main(C);
1114         Scene *scene = CTX_data_scene(C);
1115         View3D *v3d = CTX_wm_view3d(C);
1116         Main *mainl = NULL;
1117         Library *lib;
1118         BlendHandle *bh;
1119                 
1120         bh = BLO_blendhandle_from_file(libname, reports);
1121         
1122         if (bh == NULL) {
1123                 /* error reports will have been made by BLO_blendhandle_from_file() */
1124                 return false;
1125         }
1126
1127         BKE_scene_base_deselect_all(scene);
1128         
1129         /* tag everything, all untagged data can be made local
1130          * its also generally useful to know what is new
1131          *
1132          * take extra care BKE_main_id_flag_all(bmain, LIB_TAG_PRE_EXISTING, false) is called after! */
1133         BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, true);
1134         
1135         /* here appending/linking starts */
1136         mainl = BLO_library_link_begin(bmain, &bh, libname);
1137         
1138         BLO_library_link_copypaste(mainl, bh);
1139
1140         BLO_library_link_end(mainl, &bh, flag, scene, v3d);
1141         
1142         /* mark all library linked objects to be updated */
1143         BKE_main_lib_objects_recalc_all(bmain);
1144         IMB_colormanagement_check_file_config(bmain);
1145         
1146         /* append, rather than linking */
1147         lib = BLI_findstring(&bmain->library, libname, offsetof(Library, filepath));
1148         BKE_library_make_local(bmain, lib, true, false);
1149         
1150         /* important we unset, otherwise these object wont
1151          * link into other scenes from this blend file */
1152         BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, false);
1153         
1154         /* recreate dependency graph to include new objects */
1155         DAG_relations_tag_update(bmain);
1156         
1157         BLO_blendhandle_close(bh);
1158         /* remove library... */
1159         
1160         return true;
1161 }
1162
1163 /** \} */