Merge branch 'master' into blender2.8
[blender.git] / source / blender / windowmanager / intern / wm_files.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  * Contributor(s): Blender Foundation 2007
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/windowmanager/intern/wm_files.c
27  *  \ingroup wm
28  *
29  * User level access for blend file read/write, file-history and userprefs (including relevant operators).
30  */
31
32
33 /* placed up here because of crappy
34  * winsock stuff.
35  */
36 #include <stddef.h>
37 #include <string.h>
38 #include <errno.h>
39
40 #include "zlib.h" /* wm_read_exotic() */
41
42 #ifdef WIN32
43 #  include <windows.h> /* need to include windows.h so _WIN32_IE is defined  */
44 #  ifndef _WIN32_IE
45 #    define _WIN32_IE 0x0400 /* minimal requirements for SHGetSpecialFolderPath on MINGW MSVC has this defined already */
46 #  endif
47 #  include <shlobj.h>  /* for SHGetSpecialFolderPath, has to be done before BLI_winstuff
48                         * because 'near' is disabled through BLI_windstuff */
49 #  include "BLI_winstuff.h"
50 #endif
51
52 #include "MEM_guardedalloc.h"
53 #include "MEM_CacheLimiterC-Api.h"
54
55 #include "BLI_blenlib.h"
56 #include "BLI_linklist.h"
57 #include "BLI_utildefines.h"
58 #include "BLI_threads.h"
59 #include "BLI_callbacks.h"
60 #include "BLI_system.h"
61 #include BLI_SYSTEM_PID_H
62
63 #include "BLT_translation.h"
64
65 #include "BLF_api.h"
66
67 #include "DNA_object_types.h"
68 #include "DNA_space_types.h"
69 #include "DNA_userdef_types.h"
70 #include "DNA_scene_types.h"
71 #include "DNA_screen_types.h"
72 #include "DNA_windowmanager_types.h"
73 #include "DNA_workspace_types.h"
74
75 #include "BKE_appdir.h"
76 #include "BKE_autoexec.h"
77 #include "BKE_blender.h"
78 #include "BKE_blendfile.h"
79 #include "BKE_blender_undo.h"
80 #include "BKE_context.h"
81 #include "BKE_global.h"
82 #include "BKE_library.h"
83 #include "BKE_main.h"
84 #include "BKE_packedFile.h"
85 #include "BKE_report.h"
86 #include "BKE_sound.h"
87 #include "BKE_scene.h"
88 #include "BKE_screen.h"
89 #include "BKE_undo_system.h"
90 #include "BKE_workspace.h"
91
92 #include "BLO_readfile.h"
93 #include "BLO_writefile.h"
94 #include "BLO_undofile.h"  /* to save from an undo memfile */
95
96 #include "RNA_access.h"
97 #include "RNA_define.h"
98
99 #include "IMB_imbuf.h"
100 #include "IMB_imbuf_types.h"
101 #include "IMB_thumbs.h"
102
103 #include "ED_datafiles.h"
104 #include "ED_fileselect.h"
105 #include "ED_screen.h"
106 #include "ED_view3d.h"
107 #include "ED_util.h"
108 #include "ED_undo.h"
109
110 #include "GHOST_C-api.h"
111 #include "GHOST_Path-api.h"
112
113 #include "UI_interface.h"
114 #include "UI_resources.h"
115 #include "UI_view2d.h"
116
117 #include "GPU_draw.h"
118
119 /* only to report a missing engine */
120 #include "RE_engine.h"
121
122 #ifdef WITH_PYTHON
123 #include "BPY_extern.h"
124 #endif
125
126 #include "DEG_depsgraph.h"
127
128 #include "WM_api.h"
129 #include "WM_types.h"
130 #include "WM_message.h"
131 #include "WM_toolsystem.h"
132
133 #include "wm.h"
134 #include "wm_files.h"
135 #include "wm_window.h"
136 #include "wm_event_system.h"
137
138 static RecentFile *wm_file_history_find(const char *filepath);
139 static void wm_history_file_free(RecentFile *recent);
140 static void wm_history_file_update(void);
141 static void wm_history_file_write(void);
142
143
144 /* To be able to read files without windows closing, opening, moving
145  * we try to prepare for worst case:
146  * - active window gets active screen from file
147  * - restoring the screens from non-active windows
148  * Best case is all screens match, in that case they get assigned to proper window
149  */
150 static void wm_window_match_init(bContext *C, ListBase *wmlist)
151 {
152         wmWindowManager *wm;
153         wmWindow *win, *active_win;
154
155         *wmlist = G_MAIN->wm;
156         BLI_listbase_clear(&G_MAIN->wm);
157
158         active_win = CTX_wm_window(C);
159
160         /* first wrap up running stuff */
161         /* code copied from wm_init_exit.c */
162         for (wm = wmlist->first; wm; wm = wm->id.next) {
163
164                 WM_jobs_kill_all(wm);
165
166                 for (win = wm->windows.first; win; win = win->next) {
167
168                         CTX_wm_window_set(C, win);  /* needed by operator close callbacks */
169                         WM_event_remove_handlers(C, &win->handlers);
170                         WM_event_remove_handlers(C, &win->modalhandlers);
171                         ED_screen_exit(C, win, WM_window_get_active_screen(win));
172                 }
173         }
174
175         /* reset active window */
176         CTX_wm_window_set(C, active_win);
177
178         /* XXX Hack! We have to clear context menu here, because removing all modalhandlers above frees the active menu
179          *     (at least, in the 'startup splash' case), causing use-after-free error in later handling of the button
180          *     callbacks in UI code (see ui_apply_but_funcs_after()).
181          *     Tried solving this by always NULL-ing context's menu when setting wm/win/etc., but it broke popups refreshing
182          *     (see T47632), so for now just handling this specific case here. */
183         CTX_wm_menu_set(C, NULL);
184
185         ED_editors_exit(C);
186 }
187
188 static void wm_window_substitute_old(wmWindowManager *oldwm, wmWindowManager *wm, wmWindow *oldwin, wmWindow *win)
189 {
190         win->ghostwin = oldwin->ghostwin;
191         win->gpuctx = oldwin->gpuctx;
192         win->active = oldwin->active;
193         if (win->active) {
194                 wm->winactive = win;
195         }
196         if (oldwm->windrawable == oldwin) {
197                 oldwm->windrawable = NULL;
198                 wm->windrawable = win;
199         }
200
201         if (!G.background) /* file loading in background mode still calls this */
202                 GHOST_SetWindowUserData(win->ghostwin, win);    /* pointer back */
203
204         oldwin->ghostwin = NULL;
205         oldwin->gpuctx = NULL;
206
207         win->eventstate = oldwin->eventstate;
208         oldwin->eventstate = NULL;
209
210         /* ensure proper screen rescaling */
211         win->sizex = oldwin->sizex;
212         win->sizey = oldwin->sizey;
213         win->posx = oldwin->posx;
214         win->posy = oldwin->posy;
215 }
216
217 static void wm_window_match_keep_current_wm(
218         const bContext *C, ListBase *current_wm_list,
219         const bool load_ui,
220         ListBase *r_new_wm_list)
221 {
222         Main *bmain = CTX_data_main(C);
223         wmWindowManager *wm = current_wm_list->first;
224         bScreen *screen = NULL;
225
226         /* match oldwm to new dbase, only old files */
227         wm->initialized &= ~WM_WINDOW_IS_INITIALIZED;
228
229         /* when loading without UI, no matching needed */
230         if (load_ui && (screen = CTX_wm_screen(C))) {
231                 for (wmWindow *win = wm->windows.first; win; win = win->next) {
232                         WorkSpace *workspace;
233
234                         BKE_workspace_layout_find_global(bmain, screen, &workspace);
235                         BKE_workspace_active_set(win->workspace_hook, workspace);
236                         win->scene = CTX_data_scene(C);
237
238                         /* all windows get active screen from file */
239                         if (screen->winid == 0) {
240                                 WM_window_set_active_screen(win, workspace, screen);
241                         }
242                         else {
243                                 WorkSpaceLayout *layout_old = WM_window_get_active_layout(win);
244                                 WorkSpaceLayout *layout_new = ED_workspace_layout_duplicate(bmain, workspace, layout_old, win);
245
246                                 WM_window_set_active_layout(win, workspace, layout_new);
247                         }
248
249                         bScreen *win_screen = WM_window_get_active_screen(win);
250                         win_screen->winid = win->winid;
251                 }
252         }
253
254         *r_new_wm_list = *current_wm_list;
255 }
256
257 static void wm_window_match_replace_by_file_wm(
258         bContext *C, ListBase *current_wm_list, ListBase *readfile_wm_list,
259         ListBase *r_new_wm_list)
260 {
261         wmWindowManager *oldwm = current_wm_list->first;
262         wmWindowManager *wm = readfile_wm_list->first; /* will become our new WM */
263         bool has_match = false;
264
265         /* this code could move to setup_appdata */
266
267         /* preserve key configurations in new wm, to preserve their keymaps */
268         wm->keyconfigs = oldwm->keyconfigs;
269         wm->addonconf = oldwm->addonconf;
270         wm->defaultconf = oldwm->defaultconf;
271         wm->userconf = oldwm->userconf;
272
273         BLI_listbase_clear(&oldwm->keyconfigs);
274         oldwm->addonconf = NULL;
275         oldwm->defaultconf = NULL;
276         oldwm->userconf = NULL;
277
278         /* ensure making new keymaps and set space types */
279         wm->initialized = 0;
280         wm->winactive = NULL;
281
282         /* Clearing drawable of before deleting any context
283          * to avoid clearing the wrong wm. */
284         wm_window_clear_drawable(oldwm);
285
286         /* only first wm in list has ghostwins */
287         for (wmWindow *win = wm->windows.first; win; win = win->next) {
288                 for (wmWindow *oldwin = oldwm->windows.first; oldwin; oldwin = oldwin->next) {
289                         if (oldwin->winid == win->winid) {
290                                 has_match = true;
291
292                                 wm_window_substitute_old(oldwm, wm, oldwin, win);
293                         }
294                 }
295         }
296         /* make sure at least one window is kept open so we don't lose the context, check T42303 */
297         if (!has_match) {
298                 wm_window_substitute_old(oldwm, wm, oldwm->windows.first, wm->windows.first);
299         }
300
301         wm_close_and_free_all(C, current_wm_list);
302
303         *r_new_wm_list = *readfile_wm_list;
304 }
305
306 /**
307  * Match old WM with new, 4 cases:
308  * 1) No current WM, no WM in file: Make new default.
309  * 2) No current WM, but WM in file: Keep current WM, do nothing else.
310  * 3) Current WM, but not in file: Keep current WM, update windows with screens from file.
311  * 4) Current WM, and WM in file: Try to keep current GHOST windows, use WM from file.
312  *
313  * \param r_new_wm_list: Return argument for the wm list to be used from now on.
314  */
315 static void wm_window_match_do(
316         bContext *C,
317         ListBase *current_wm_list, ListBase *readfile_wm_list,
318         ListBase *r_new_wm_list)
319 {
320         if (BLI_listbase_is_empty(current_wm_list)) {
321                 /* case 1 */
322                 if (BLI_listbase_is_empty(readfile_wm_list)) {
323                         Main *bmain = CTX_data_main(C);
324                         /* Neither current, no newly read file have a WM -> add the default one. */
325                         wm_add_default(bmain, C);
326                         *r_new_wm_list = bmain->wm;
327                 }
328                 /* case 2 */
329                 else {
330                         *r_new_wm_list = *readfile_wm_list;
331                 }
332         }
333         else {
334                 /* case 3 */
335                 if (BLI_listbase_is_empty(readfile_wm_list)) {
336                         /* We've read file without wm, keep current one entirely alive.
337                          * Happens when reading pre 2.5 files (no WM back then) */
338                         wm_window_match_keep_current_wm(C, current_wm_list, (G.fileflags & G_FILE_NO_UI) == 0, r_new_wm_list);
339                 }
340                 /* case 4 */
341                 else {
342                         wm_window_match_replace_by_file_wm(C, current_wm_list, readfile_wm_list, r_new_wm_list);
343                 }
344         }
345 }
346
347 /* in case UserDef was read, we re-initialize all, and do versioning */
348 static void wm_init_userdef(Main *bmain, const bool read_userdef_from_memory)
349 {
350         /* versioning is here */
351         UI_init_userdef(bmain);
352
353         MEM_CacheLimiter_set_maximum(((size_t)U.memcachelimit) * 1024 * 1024);
354         BKE_sound_init(bmain);
355
356         /* needed so loading a file from the command line respects user-pref [#26156] */
357         SET_FLAG_FROM_TEST(G.fileflags, U.flag & USER_FILENOUI, G_FILE_NO_UI);
358
359         /* set the python auto-execute setting from user prefs */
360         /* enabled by default, unless explicitly enabled in the command line which overrides */
361         if ((G.f & G_SCRIPT_OVERRIDE_PREF) == 0) {
362                 SET_FLAG_FROM_TEST(G.f, (U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0, G_SCRIPT_AUTOEXEC);
363         }
364
365         /* avoid re-saving for every small change to our prefs, allow overrides */
366         if (read_userdef_from_memory) {
367                 BLO_update_defaults_userpref_blend();
368         }
369
370         /* update tempdir from user preferences */
371         BKE_tempdir_init(U.tempdir);
372 }
373
374
375
376 /* return codes */
377 #define BKE_READ_EXOTIC_FAIL_PATH       -3 /* file format is not supported */
378 #define BKE_READ_EXOTIC_FAIL_FORMAT     -2 /* file format is not supported */
379 #define BKE_READ_EXOTIC_FAIL_OPEN       -1 /* Can't open the file */
380 #define BKE_READ_EXOTIC_OK_BLEND         0 /* .blend file */
381 #if 0
382 #define BKE_READ_EXOTIC_OK_OTHER         1 /* other supported formats */
383 #endif
384
385
386 /* intended to check for non-blender formats but for now it only reads blends */
387 static int wm_read_exotic(const char *name)
388 {
389         int len;
390         gzFile gzfile;
391         char header[7];
392         int retval;
393
394         /* make sure we're not trying to read a directory.... */
395
396         len = strlen(name);
397         if (len > 0 && ELEM(name[len - 1], '/', '\\')) {
398                 retval = BKE_READ_EXOTIC_FAIL_PATH;
399         }
400         else {
401                 gzfile = BLI_gzopen(name, "rb");
402                 if (gzfile == NULL) {
403                         retval = BKE_READ_EXOTIC_FAIL_OPEN;
404                 }
405                 else {
406                         len = gzread(gzfile, header, sizeof(header));
407                         gzclose(gzfile);
408                         if (len == sizeof(header) && STREQLEN(header, "BLENDER", 7)) {
409                                 retval = BKE_READ_EXOTIC_OK_BLEND;
410                         }
411                         else {
412 #if 0           /* historic stuff - no longer used */
413                                 WM_cursor_wait(true);
414
415                                 if (is_foo_format(name)) {
416                                         read_foo(name);
417                                         retval = BKE_READ_EXOTIC_OK_OTHER;
418                                 }
419                                 else
420 #endif
421                                 {
422                                         retval = BKE_READ_EXOTIC_FAIL_FORMAT;
423                                 }
424 #if 0
425                                 WM_cursor_wait(false);
426 #endif
427                         }
428                 }
429         }
430
431         return retval;
432 }
433
434 void WM_file_autoexec_init(const char *filepath)
435 {
436         if (G.f & G_SCRIPT_OVERRIDE_PREF) {
437                 return;
438         }
439
440         if (G.f & G_SCRIPT_AUTOEXEC) {
441                 char path[FILE_MAX];
442                 BLI_split_dir_part(filepath, path, sizeof(path));
443                 if (BKE_autoexec_match(path)) {
444                         G.f &= ~G_SCRIPT_AUTOEXEC;
445                 }
446         }
447 }
448
449 void wm_file_read_report(bContext *C, Main *bmain)
450 {
451         ReportList *reports = NULL;
452         Scene *sce;
453
454         for (sce = bmain->scene.first; sce; sce = sce->id.next) {
455                 if (sce->r.engine[0] &&
456                     BLI_findstring(&R_engines, sce->r.engine, offsetof(RenderEngineType, idname)) == NULL)
457                 {
458                         if (reports == NULL) {
459                                 reports = CTX_wm_reports(C);
460                         }
461
462                         BKE_reportf(reports, RPT_ERROR,
463                                     "Engine '%s' not available for scene '%s' (an add-on may need to be installed or enabled)",
464                                     sce->r.engine, sce->id.name + 2);
465                 }
466         }
467
468         if (reports) {
469                 if (!G.background) {
470                         WM_report_banner_show();
471                 }
472         }
473 }
474
475 /**
476  * Logic shared between #WM_file_read & #wm_homefile_read,
477  * updates to make after reading a file.
478  */
479 static void wm_file_read_post(bContext *C, const bool is_startup_file, const bool use_userdef)
480 {
481         bool addons_loaded = false;
482         wmWindowManager *wm = CTX_wm_manager(C);
483
484         if (!G.background) {
485                 /* remove windows which failed to be added via WM_check */
486                 wm_window_ghostwindows_remove_invalid(C, wm);
487         }
488
489         CTX_wm_window_set(C, wm->windows.first);
490
491         Main *bmain = CTX_data_main(C);
492         DEG_on_visible_update(bmain, true);
493         wm_event_do_depsgraph(C);
494
495         ED_editors_init(C);
496
497 #ifdef WITH_PYTHON
498         if (is_startup_file) {
499                 /* possible python hasn't been initialized */
500                 if (CTX_py_init_get(C)) {
501                         if (use_userdef) {
502                                 /* Only run when we have a template path found. */
503                                 if (BKE_appdir_app_template_any()) {
504                                         BPY_execute_string(C, "__import__('bl_app_template_utils').reset()");
505                                 }
506                                 /* sync addons, these may have changed from the defaults */
507                                 BPY_execute_string(C, "__import__('addon_utils').reset_all()");
508                         }
509                         BPY_python_reset(C);
510                         addons_loaded = true;
511                 }
512         }
513         else {
514                 /* run any texts that were loaded in and flagged as modules */
515                 BPY_python_reset(C);
516                 addons_loaded = true;
517         }
518 #else
519         UNUSED_VARS(is_startup_file, use_userdef);
520 #endif  /* WITH_PYTHON */
521
522         WM_operatortype_last_properties_clear_all();
523
524         /* important to do before NULL'ing the context */
525         BLI_callback_exec(bmain, NULL, BLI_CB_EVT_VERSION_UPDATE);
526         BLI_callback_exec(bmain, NULL, BLI_CB_EVT_LOAD_POST);
527
528 #if 1
529         WM_event_add_notifier(C, NC_WM | ND_FILEREAD, NULL);
530 #else
531         WM_msg_publish_static(CTX_wm_message_bus(C), WM_MSG_STATICTYPE_FILE_READ);
532 #endif
533
534         /* report any errors.
535          * currently disabled if addons aren't yet loaded */
536         if (addons_loaded) {
537                 wm_file_read_report(C, bmain);
538         }
539
540         if (!G.background) {
541                 if (wm->undo_stack == NULL) {
542                         wm->undo_stack = BKE_undosys_stack_create();
543                 }
544                 else {
545                         BKE_undosys_stack_clear(wm->undo_stack);
546                 }
547                 BKE_undosys_stack_init_from_main(wm->undo_stack, bmain);
548                 BKE_undosys_stack_init_from_context(wm->undo_stack, C);
549         }
550
551         if (!G.background) {
552                 /* in background mode this makes it hard to load
553                  * a blend file and do anything since the screen
554                  * won't be set to a valid value again */
555                 CTX_wm_window_set(C, NULL); /* exits queues */
556
557                 /* Ensure tools are registered. */
558                 WM_toolsystem_init(C);
559         }
560 }
561
562 bool WM_file_read(bContext *C, const char *filepath, ReportList *reports)
563 {
564         /* assume automated tasks with background, don't write recent file list */
565         const bool do_history = (G.background == false) && (CTX_wm_manager(C)->op_undo_depth == 0);
566         bool success = false;
567         int retval;
568
569         /* so we can get the error message */
570         errno = 0;
571
572         WM_cursor_wait(1);
573
574         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_PRE);
575
576         UI_view2d_zoom_cache_reset();
577
578         /* first try to append data from exotic file formats... */
579         /* it throws error box when file doesn't exist and returns -1 */
580         /* note; it should set some error message somewhere... (ton) */
581         retval = wm_read_exotic(filepath);
582
583         /* we didn't succeed, now try to read Blender file */
584         if (retval == BKE_READ_EXOTIC_OK_BLEND) {
585                 int G_f = G.f;
586                 ListBase wmbase;
587
588                 /* put aside screens to match with persistent windows later */
589                 /* also exit screens and editors */
590                 wm_window_match_init(C, &wmbase);
591
592                 /* confusing this global... */
593                 G.relbase_valid = 1;
594                 retval = BKE_blendfile_read(C, filepath, reports, 0);
595
596                 /* BKE_file_read sets new Main into context. */
597                 Main *bmain = CTX_data_main(C);
598
599                 /* when loading startup.blend's, we can be left with a blank path */
600                 if (BKE_main_blendfile_path(bmain)) {
601                         G.save_over = 1;
602                 }
603                 else {
604                         G.save_over = 0;
605                         G.relbase_valid = 0;
606                 }
607
608                 /* this flag is initialized by the operator but overwritten on read.
609                  * need to re-enable it here else drivers + registered scripts wont work. */
610                 if (G.f != G_f) {
611                         const int flags_keep = (G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
612                         G.f = (G.f & ~flags_keep) | (G_f & flags_keep);
613                 }
614
615                 /* match the read WM with current WM */
616                 wm_window_match_do(C, &wmbase, &bmain->wm, &bmain->wm);
617                 WM_check(C); /* opens window(s), checks keymaps */
618
619                 if (retval == BKE_BLENDFILE_READ_OK_USERPREFS) {
620                         /* in case a userdef is read from regular .blend */
621                         wm_init_userdef(bmain, false);
622                 }
623
624                 if (retval != BKE_BLENDFILE_READ_FAIL) {
625                         if (do_history) {
626                                 wm_history_file_update();
627                         }
628                 }
629
630                 wm_file_read_post(C, false, false);
631
632                 success = true;
633         }
634 #if 0
635         else if (retval == BKE_READ_EXOTIC_OK_OTHER)
636                 BKE_undo_write(C, "Import file");
637 #endif
638         else if (retval == BKE_READ_EXOTIC_FAIL_OPEN) {
639                 BKE_reportf(reports, RPT_ERROR, "Cannot read file '%s': %s", filepath,
640                             errno ? strerror(errno) : TIP_("unable to open the file"));
641         }
642         else if (retval == BKE_READ_EXOTIC_FAIL_FORMAT) {
643                 BKE_reportf(reports, RPT_ERROR, "File format is not supported in file '%s'", filepath);
644         }
645         else if (retval == BKE_READ_EXOTIC_FAIL_PATH) {
646                 BKE_reportf(reports, RPT_ERROR, "File path '%s' invalid", filepath);
647         }
648         else {
649                 BKE_reportf(reports, RPT_ERROR, "Unknown error loading '%s'", filepath);
650                 BLI_assert(!"invalid 'retval'");
651         }
652
653
654         if (success == false) {
655                 /* remove from recent files list */
656                 if (do_history) {
657                         RecentFile *recent = wm_file_history_find(filepath);
658                         if (recent) {
659                                 wm_history_file_free(recent);
660                                 wm_history_file_write();
661                         }
662                 }
663         }
664
665         WM_cursor_wait(0);
666
667         return success;
668
669 }
670
671 struct {
672         char app_template[64];
673         bool override;
674 } wm_init_state_app_template = {{0}};
675
676 /**
677  * Used for setting app-template from the command line:
678  * - non-empty string: overrides.
679  * - empty string: override, using no app template.
680  * - NULL: clears override.
681  */
682 void WM_init_state_app_template_set(const char *app_template)
683 {
684         if (app_template) {
685                 STRNCPY(wm_init_state_app_template.app_template, app_template);
686                 wm_init_state_app_template.override = true;
687         }
688         else {
689                 wm_init_state_app_template.app_template[0] = '\0';
690                 wm_init_state_app_template.override = false;
691         }
692 }
693
694 const char *WM_init_state_app_template_get(void)
695 {
696         return wm_init_state_app_template.override ? wm_init_state_app_template.app_template : NULL;
697 }
698
699
700 static bool wm_app_template_has_userpref(const char *app_template)
701 {
702         /* Test if app template provides a userpref.blend. If not, we will
703          * share user preferences with the rest of Blender. */
704         if (!app_template && app_template[0]) {
705                 return false;
706         }
707
708         char app_template_path[FILE_MAX];
709         if (!BKE_appdir_app_template_id_search(app_template, app_template_path, sizeof(app_template_path))) {
710                 return false;
711         }
712
713         char userpref_path[FILE_MAX];
714         BLI_path_join(userpref_path, sizeof(userpref_path), app_template_path, BLENDER_USERPREF_FILE, NULL);
715         return BLI_exists(userpref_path);
716 }
717
718 /**
719  * Called on startup, (context entirely filled with NULLs)
720  * or called for 'New File' both startup.blend and userpref.blend are checked.
721  *
722  * \param use_factory_settings: Ignore on-disk startup file, use bundled ``datatoc_startup_blend`` instead.
723  * Used for "Restore Factory Settings".
724  * \param use_userdef: Load factory settings as well as startup file.
725  * Disabled for "File New" we don't want to reload preferences.
726  * \param filepath_startup_override: Optional path pointing to an alternative blend file (may be NULL).
727  * \param app_template_override: Template to use instead of the template defined in user-preferences.
728  * When not-null, this is written into the user preferences.
729  */
730 int wm_homefile_read(
731         bContext *C, ReportList *reports,
732         bool use_factory_settings, bool use_empty_data, bool use_userdef,
733         const char *filepath_startup_override, const char *app_template_override)
734 {
735         Main *bmain = G_MAIN;  /* Context does not always have valid main pointer here... */
736         ListBase wmbase;
737         bool success = false;
738
739         char filepath_startup[FILE_MAX];
740         char filepath_userdef[FILE_MAX];
741
742         /* When 'app_template' is set: '{BLENDER_USER_CONFIG}/{app_template}' */
743         char app_template_system[FILE_MAX];
744         /* When 'app_template' is set: '{BLENDER_SYSTEM_SCRIPTS}/startup/bl_app_templates_system/{app_template}' */
745         char app_template_config[FILE_MAX];
746
747         /* Indicates whether user preferences were really load from memory.
748          *
749          * This is used for versioning code, and for this we can not rely on use_factory_settings
750          * passed via argument. This is because there might be configuration folder
751          * exists but it might not have userpref.blend and in this case we fallback to
752          * reading home file from memory.
753          *
754          * And in this case versioning code is to be run.
755          */
756         bool read_userdef_from_memory = false;
757         eBLOReadSkip skip_flags = use_userdef ? 0 : BLO_READ_SKIP_USERDEF;
758
759         /* options exclude eachother */
760         BLI_assert((use_factory_settings && filepath_startup_override) == 0);
761
762         if ((G.f & G_SCRIPT_OVERRIDE_PREF) == 0) {
763                 SET_FLAG_FROM_TEST(G.f, (U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0, G_SCRIPT_AUTOEXEC);
764         }
765
766         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_PRE);
767
768         UI_view2d_zoom_cache_reset();
769
770         G.relbase_valid = 0;
771
772         /* put aside screens to match with persistent windows later */
773         wm_window_match_init(C, &wmbase);
774
775         filepath_startup[0] = '\0';
776         filepath_userdef[0] = '\0';
777         app_template_system[0] = '\0';
778         app_template_config[0] = '\0';
779
780         const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);
781         if (!use_factory_settings) {
782                 if (cfgdir) {
783                         BLI_path_join(filepath_startup, sizeof(filepath_startup), cfgdir, BLENDER_STARTUP_FILE, NULL);
784                         if (use_userdef) {
785                                 BLI_path_join(filepath_userdef, sizeof(filepath_startup), cfgdir, BLENDER_USERPREF_FILE, NULL);
786                         }
787                 }
788                 else {
789                         use_factory_settings = true;
790                 }
791
792                 if (filepath_startup_override) {
793                         BLI_strncpy(filepath_startup, filepath_startup_override, FILE_MAX);
794                 }
795         }
796
797         /* load preferences before startup.blend */
798         if (use_userdef) {
799                 if (!use_factory_settings && BLI_exists(filepath_userdef)) {
800                         UserDef *userdef = BKE_blendfile_userdef_read(filepath_userdef, NULL);
801                         if (userdef != NULL) {
802                                 BKE_blender_userdef_data_set_and_free(userdef);
803                                 userdef = NULL;
804
805                                 skip_flags |= BLO_READ_SKIP_USERDEF;
806                                 printf("Read prefs: %s\n", filepath_userdef);
807                         }
808                 }
809         }
810
811         const char *app_template = NULL;
812         bool update_defaults = false;
813
814         if (filepath_startup_override != NULL) {
815                 /* pass */
816         }
817         else if (app_template_override) {
818                 /* This may be clearing the current template by setting to an empty string. */
819                 app_template = app_template_override;
820         }
821         else if (!use_factory_settings && U.app_template[0]) {
822                 app_template = U.app_template;
823         }
824
825         if ((app_template != NULL) && (app_template[0] != '\0')) {
826                 if (!BKE_appdir_app_template_id_search(app_template, app_template_system, sizeof(app_template_system))) {
827                         /* Can safely continue with code below, just warn it's not found. */
828                         BKE_reportf(reports, RPT_WARNING, "Application Template '%s' not found.", app_template);
829                 }
830
831                 /* Insert template name into startup file. */
832
833                 /* note that the path is being set even when 'use_factory_settings == true'
834                  * this is done so we can load a templates factory-settings */
835                 if (!use_factory_settings) {
836                         BLI_path_join(app_template_config, sizeof(app_template_config), cfgdir, app_template, NULL);
837                         BLI_path_join(filepath_startup, sizeof(filepath_startup), app_template_config, BLENDER_STARTUP_FILE, NULL);
838                         if (BLI_access(filepath_startup, R_OK) != 0) {
839                                 filepath_startup[0] = '\0';
840                         }
841                 }
842                 else {
843                         filepath_startup[0] = '\0';
844                 }
845
846                 if (filepath_startup[0] == '\0') {
847                         BLI_path_join(filepath_startup, sizeof(filepath_startup), app_template_system, BLENDER_STARTUP_FILE, NULL);
848
849                         /* Update defaults only for system templates. */
850                         update_defaults = true;
851                 }
852         }
853
854         if (!use_factory_settings || (filepath_startup[0] != '\0')) {
855                 if (BLI_access(filepath_startup, R_OK) == 0) {
856                         success = (BKE_blendfile_read(C, filepath_startup, NULL, skip_flags) != BKE_BLENDFILE_READ_FAIL);
857                 }
858                 if (BLI_listbase_is_empty(&U.themes)) {
859                         if (G.debug & G_DEBUG)
860                                 printf("\nNote: No (valid) '%s' found, fall back to built-in default.\n\n", filepath_startup);
861                         success = false;
862                 }
863                 if (success && update_defaults) {
864                         BLO_update_defaults_startup_blend(CTX_data_main(C), app_template);
865                 }
866         }
867
868         if (success == false && filepath_startup_override && reports) {
869                 /* We can not return from here because wm is already reset */
870                 BKE_reportf(reports, RPT_ERROR, "Could not read '%s'", filepath_startup_override);
871         }
872
873         if (success == false) {
874                 success = BKE_blendfile_read_from_memory(
875                         C, datatoc_startup_blend, datatoc_startup_blend_size,
876                         NULL, skip_flags, true);
877                 if (success) {
878                         if (use_userdef) {
879                                 if ((skip_flags & BLO_READ_SKIP_USERDEF) == 0) {
880                                         read_userdef_from_memory = true;
881                                 }
882                         }
883                 }
884                 if (BLI_listbase_is_empty(&wmbase)) {
885                         wm_clear_default_size(C);
886                 }
887         }
888
889         if (use_empty_data) {
890                 BKE_blendfile_read_make_empty(C);
891         }
892
893         /* Load template preferences,
894          * unlike regular preferences we only use some of the settings,
895          * see: BKE_blender_userdef_set_app_template */
896         if (app_template_system[0] != '\0') {
897                 char temp_path[FILE_MAX];
898                 temp_path[0] = '\0';
899                 if (!use_factory_settings) {
900                         BLI_path_join(temp_path, sizeof(temp_path), app_template_config, BLENDER_USERPREF_FILE, NULL);
901                         if (BLI_access(temp_path, R_OK) != 0) {
902                                 temp_path[0] = '\0';
903                         }
904                 }
905
906                 if (temp_path[0] == '\0') {
907                         BLI_path_join(temp_path, sizeof(temp_path), app_template_system, BLENDER_USERPREF_FILE, NULL);
908                 }
909
910                 if (use_userdef) {
911                         UserDef *userdef_template = NULL;
912                         /* just avoids missing file warning */
913                         if (BLI_exists(temp_path)) {
914                                 userdef_template = BKE_blendfile_userdef_read(temp_path, NULL);
915                         }
916                         if (userdef_template == NULL) {
917                                 /* we need to have preferences load to overwrite preferences from previous template */
918                                 userdef_template = BKE_blendfile_userdef_read_from_memory(
919                                         datatoc_startup_blend, datatoc_startup_blend_size, NULL);
920                                 read_userdef_from_memory = true;
921                         }
922                         if (userdef_template) {
923                                 BKE_blender_userdef_app_template_data_set_and_free(userdef_template);
924                                 userdef_template = NULL;
925                         }
926                 }
927         }
928
929         if (app_template_override) {
930                 BLI_strncpy(U.app_template, app_template_override, sizeof(U.app_template));
931         }
932
933         /* prevent buggy files that had G_FILE_RELATIVE_REMAP written out by mistake. Screws up autosaves otherwise
934          * can remove this eventually, only in a 2.53 and older, now its not written */
935         G.fileflags &= ~G_FILE_RELATIVE_REMAP;
936
937         bmain = CTX_data_main(C);
938
939         if (use_userdef) {
940                 /* check userdef before open window, keymaps etc */
941                 wm_init_userdef(bmain, read_userdef_from_memory);
942         }
943
944         /* match the read WM with current WM */
945         wm_window_match_do(C, &wmbase, &bmain->wm, &bmain->wm);
946         WM_check(C); /* opens window(s), checks keymaps */
947
948         bmain->name[0] = '\0';
949
950         /* start with save preference untitled.blend */
951         G.save_over = 0;
952
953         wm_file_read_post(C, true, use_userdef);
954
955         return true;
956 }
957
958 /** \name WM History File API
959  * \{ */
960
961 void wm_history_file_read(void)
962 {
963         char name[FILE_MAX];
964         LinkNode *l, *lines;
965         struct RecentFile *recent;
966         const char *line;
967         int num;
968         const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);
969
970         if (!cfgdir) return;
971
972         BLI_make_file_string("/", name, cfgdir, BLENDER_HISTORY_FILE);
973
974         lines = BLI_file_read_as_lines(name);
975
976         BLI_listbase_clear(&G.recent_files);
977
978         /* read list of recent opened files from recent-files.txt to memory */
979         for (l = lines, num = 0; l && (num < U.recent_files); l = l->next) {
980                 line = l->link;
981                 /* don't check if files exist, causes slow startup for remote/external drives */
982                 if (line[0]) {
983                         recent = (RecentFile *)MEM_mallocN(sizeof(RecentFile), "RecentFile");
984                         BLI_addtail(&(G.recent_files), recent);
985                         recent->filepath = BLI_strdup(line);
986                         num++;
987                 }
988         }
989
990         BLI_file_free_lines(lines);
991 }
992
993 static RecentFile *wm_history_file_new(const char *filepath)
994 {
995         RecentFile *recent = MEM_mallocN(sizeof(RecentFile), "RecentFile");
996         recent->filepath = BLI_strdup(filepath);
997         return recent;
998 }
999
1000 static void wm_history_file_free(RecentFile *recent)
1001 {
1002         BLI_assert(BLI_findindex(&G.recent_files, recent) != -1);
1003         MEM_freeN(recent->filepath);
1004         BLI_freelinkN(&G.recent_files, recent);
1005 }
1006
1007 static RecentFile *wm_file_history_find(const char *filepath)
1008 {
1009         return BLI_findstring_ptr(&G.recent_files, filepath, offsetof(RecentFile, filepath));
1010 }
1011
1012 /**
1013  * Write #BLENDER_HISTORY_FILE as-is, without checking the environment
1014  * (that's handled by #wm_history_file_update).
1015  */
1016 static void wm_history_file_write(void)
1017 {
1018         const char *user_config_dir;
1019         char name[FILE_MAX];
1020         FILE *fp;
1021
1022         /* will be NULL in background mode */
1023         user_config_dir = BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, NULL);
1024         if (!user_config_dir)
1025                 return;
1026
1027         BLI_make_file_string("/", name, user_config_dir, BLENDER_HISTORY_FILE);
1028
1029         fp = BLI_fopen(name, "w");
1030         if (fp) {
1031                 struct RecentFile *recent;
1032                 for (recent = G.recent_files.first; recent; recent = recent->next) {
1033                         fprintf(fp, "%s\n", recent->filepath);
1034                 }
1035                 fclose(fp);
1036         }
1037 }
1038
1039 /**
1040  * Run after saving a file to refresh the #BLENDER_HISTORY_FILE list.
1041  */
1042 static void wm_history_file_update(void)
1043 {
1044         RecentFile *recent;
1045         const char *blendfile_name = BKE_main_blendfile_path_from_global();
1046
1047         /* no write history for recovered startup files */
1048         if (blendfile_name[0] == '\0') {
1049                 return;
1050         }
1051
1052         recent = G.recent_files.first;
1053         /* refresh recent-files.txt of recent opened files, when current file was changed */
1054         if (!(recent) || (BLI_path_cmp(recent->filepath, blendfile_name) != 0)) {
1055
1056                 recent = wm_file_history_find(blendfile_name);
1057                 if (recent) {
1058                         BLI_remlink(&G.recent_files, recent);
1059                 }
1060                 else {
1061                         RecentFile *recent_next;
1062                         for (recent = BLI_findlink(&G.recent_files, U.recent_files - 1); recent; recent = recent_next) {
1063                                 recent_next = recent->next;
1064                                 wm_history_file_free(recent);
1065                         }
1066                         recent = wm_history_file_new(blendfile_name);
1067                 }
1068
1069                 /* add current file to the beginning of list */
1070                 BLI_addhead(&(G.recent_files), recent);
1071
1072                 /* write current file to recent-files.txt */
1073                 wm_history_file_write();
1074
1075                 /* also update most recent files on System */
1076                 GHOST_addToSystemRecentFiles(blendfile_name);
1077         }
1078 }
1079
1080 /** \} */
1081
1082
1083 /* screen can be NULL */
1084 static ImBuf *blend_file_thumb(const bContext *C, Scene *scene, bScreen *screen, BlendThumbnail **thumb_pt)
1085 {
1086         /* will be scaled down, but gives some nice oversampling */
1087         ImBuf *ibuf;
1088         BlendThumbnail *thumb;
1089         char err_out[256] = "unknown";
1090
1091         /* screen if no camera found */
1092         ScrArea *sa = NULL;
1093         ARegion *ar = NULL;
1094         View3D *v3d = NULL;
1095
1096         /* In case we are given a valid thumbnail data, just generate image from it. */
1097         if (*thumb_pt) {
1098                 thumb = *thumb_pt;
1099                 return BKE_main_thumbnail_to_imbuf(NULL, thumb);
1100         }
1101
1102         /* scene can be NULL if running a script at startup and calling the save operator */
1103         if (G.background || scene == NULL)
1104                 return NULL;
1105
1106         if ((scene->camera == NULL) && (screen != NULL)) {
1107                 sa = BKE_screen_find_big_area(screen, SPACE_VIEW3D, 0);
1108                 ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
1109                 if (ar) {
1110                         v3d = sa->spacedata.first;
1111                 }
1112         }
1113
1114         if (scene->camera == NULL && v3d == NULL) {
1115                 return NULL;
1116         }
1117
1118         /* gets scaled to BLEN_THUMB_SIZE */
1119         Depsgraph *depsgraph = CTX_data_depsgraph(C);
1120
1121         if (scene->camera) {
1122                 ibuf = ED_view3d_draw_offscreen_imbuf_simple(
1123                         depsgraph, scene, OB_SOLID, scene->camera,
1124                         BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
1125                         IB_rect, V3D_OFSDRAW_NONE, R_ALPHAPREMUL, 0, NULL,
1126                         NULL, err_out);
1127         }
1128         else {
1129                 ibuf = ED_view3d_draw_offscreen_imbuf(
1130                         depsgraph, scene, OB_SOLID, v3d, ar,
1131                         BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
1132                         IB_rect, V3D_OFSDRAW_NONE, R_ALPHAPREMUL, 0, NULL,
1133                         NULL, err_out);
1134         }
1135
1136         if (ibuf) {
1137                 float aspect = (scene->r.xsch * scene->r.xasp) / (scene->r.ysch * scene->r.yasp);
1138
1139                 /* dirty oversampling */
1140                 IMB_scaleImBuf(ibuf, BLEN_THUMB_SIZE, BLEN_THUMB_SIZE);
1141
1142                 /* add pretty overlay */
1143                 IMB_thumb_overlay_blend(ibuf->rect, ibuf->x, ibuf->y, aspect);
1144
1145                 thumb = BKE_main_thumbnail_from_imbuf(NULL, ibuf);
1146         }
1147         else {
1148                 /* '*thumb_pt' needs to stay NULL to prevent a bad thumbnail from being handled */
1149                 fprintf(stderr, "blend_file_thumb failed to create thumbnail: %s\n", err_out);
1150                 thumb = NULL;
1151         }
1152
1153         /* must be freed by caller */
1154         *thumb_pt = thumb;
1155
1156         return ibuf;
1157 }
1158
1159 /* easy access from gdb */
1160 bool write_crash_blend(void)
1161 {
1162         char path[FILE_MAX];
1163         int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on crash file */
1164
1165         BLI_strncpy(path, BKE_main_blendfile_path_from_global(), sizeof(path));
1166         BLI_path_extension_replace(path, sizeof(path), "_crash.blend");
1167         if (BLO_write_file(G_MAIN, path, fileflags, NULL, NULL)) {
1168                 printf("written: %s\n", path);
1169                 return 1;
1170         }
1171         else {
1172                 printf("failed: %s\n", path);
1173                 return 0;
1174         }
1175 }
1176
1177 /**
1178  * \see #wm_homefile_write_exec wraps #BLO_write_file in a similar way.
1179  */
1180 static int wm_file_write(bContext *C, const char *filepath, int fileflags, ReportList *reports)
1181 {
1182         Main *bmain = CTX_data_main(C);
1183         Library *li;
1184         int len;
1185         int ret = -1;
1186         BlendThumbnail *thumb, *main_thumb;
1187         ImBuf *ibuf_thumb = NULL;
1188
1189         len = strlen(filepath);
1190
1191         if (len == 0) {
1192                 BKE_report(reports, RPT_ERROR, "Path is empty, cannot save");
1193                 return ret;
1194         }
1195
1196         if (len >= FILE_MAX) {
1197                 BKE_report(reports, RPT_ERROR, "Path too long, cannot save");
1198                 return ret;
1199         }
1200
1201         /* Check if file write permission is ok */
1202         if (BLI_exists(filepath) && !BLI_file_is_writable(filepath)) {
1203                 BKE_reportf(reports, RPT_ERROR, "Cannot save blend file, path '%s' is not writable", filepath);
1204                 return ret;
1205         }
1206
1207         /* note: used to replace the file extension (to ensure '.blend'),
1208          * no need to now because the operator ensures,
1209          * its handy for scripts to save to a predefined name without blender editing it */
1210
1211         /* send the OnSave event */
1212         for (li = bmain->library.first; li; li = li->id.next) {
1213                 if (BLI_path_cmp(li->filepath, filepath) == 0) {
1214                         BKE_reportf(reports, RPT_ERROR, "Cannot overwrite used library '%.240s'", filepath);
1215                         return ret;
1216                 }
1217         }
1218
1219         /* Call pre-save callbacks befores writing preview, that way you can generate custom file thumbnail... */
1220         BLI_callback_exec(bmain, NULL, BLI_CB_EVT_SAVE_PRE);
1221
1222         /* blend file thumbnail */
1223         /* save before exit_editmode, otherwise derivedmeshes for shared data corrupt #27765) */
1224         /* Main now can store a .blend thumbnail, useful for background mode or thumbnail customization. */
1225         main_thumb = thumb = bmain->blen_thumb;
1226         if ((U.flag & USER_SAVE_PREVIEWS) && BLI_thread_is_main()) {
1227                 ibuf_thumb = blend_file_thumb(C, CTX_data_scene(C), CTX_wm_screen(C), &thumb);
1228         }
1229
1230         /* operator now handles overwrite checks */
1231
1232         if (G.fileflags & G_AUTOPACK) {
1233                 packAll(bmain, reports, false);
1234         }
1235
1236         /* don't forget not to return without! */
1237         WM_cursor_wait(1);
1238
1239         ED_editors_flush_edits(C, false);
1240
1241         fileflags |= G_FILE_HISTORY; /* write file history */
1242
1243         /* first time saving */
1244         /* XXX temp solution to solve bug, real fix coming (ton) */
1245         if ((BKE_main_blendfile_path(bmain)[0] == '\0') && !(fileflags & G_FILE_SAVE_COPY)) {
1246                 BLI_strncpy(bmain->name, filepath, sizeof(bmain->name));
1247         }
1248
1249         /* XXX temp solution to solve bug, real fix coming (ton) */
1250         bmain->recovered = 0;
1251
1252         if (BLO_write_file(CTX_data_main(C), filepath, fileflags, reports, thumb)) {
1253                 const bool do_history = (G.background == false) && (CTX_wm_manager(C)->op_undo_depth == 0);
1254
1255                 if (!(fileflags & G_FILE_SAVE_COPY)) {
1256                         G.relbase_valid = 1;
1257                         BLI_strncpy(bmain->name, filepath, sizeof(bmain->name));  /* is guaranteed current file */
1258
1259                         G.save_over = 1; /* disable untitled.blend convention */
1260                 }
1261
1262                 SET_FLAG_FROM_TEST(G.fileflags, fileflags & G_FILE_COMPRESS, G_FILE_COMPRESS);
1263
1264                 /* prevent background mode scripts from clobbering history */
1265                 if (do_history) {
1266                         wm_history_file_update();
1267                 }
1268
1269                 BLI_callback_exec(bmain, NULL, BLI_CB_EVT_SAVE_POST);
1270
1271                 /* run this function after because the file cant be written before the blend is */
1272                 if (ibuf_thumb) {
1273                         IMB_thumb_delete(filepath, THB_FAIL); /* without this a failed thumb overrides */
1274                         ibuf_thumb = IMB_thumb_create(filepath, THB_LARGE, THB_SOURCE_BLEND, ibuf_thumb);
1275                 }
1276
1277                 ret = 0;  /* Success. */
1278         }
1279
1280         if (ibuf_thumb) {
1281                 IMB_freeImBuf(ibuf_thumb);
1282         }
1283         if (thumb && thumb != main_thumb) {
1284                 MEM_freeN(thumb);
1285         }
1286
1287         WM_cursor_wait(0);
1288
1289         return ret;
1290 }
1291
1292 /************************ autosave ****************************/
1293
1294 void wm_autosave_location(char *filepath)
1295 {
1296         const int pid = abs(getpid());
1297         char path[1024];
1298 #ifdef WIN32
1299         const char *savedir;
1300 #endif
1301
1302         if (G_MAIN && G.relbase_valid) {
1303                 const char *basename = BLI_path_basename(BKE_main_blendfile_path_from_global());
1304                 int len = strlen(basename) - 6;
1305                 BLI_snprintf(path, sizeof(path), "%.*s.blend", len, basename);
1306         }
1307         else {
1308                 BLI_snprintf(path, sizeof(path), "%d.blend", pid);
1309         }
1310
1311 #ifdef WIN32
1312         /* XXX Need to investigate how to handle default location of '/tmp/'
1313          * This is a relative directory on Windows, and it may be
1314          * found. Example:
1315          * Blender installed on D:\ drive, D:\ drive has D:\tmp\
1316          * Now, BLI_exists() will find '/tmp/' exists, but
1317          * BLI_make_file_string will create string that has it most likely on C:\
1318          * through get_default_root().
1319          * If there is no C:\tmp autosave fails. */
1320         if (!BLI_exists(BKE_tempdir_base())) {
1321                 savedir = BKE_appdir_folder_id_create(BLENDER_USER_AUTOSAVE, NULL);
1322                 BLI_make_file_string("/", filepath, savedir, path);
1323                 return;
1324         }
1325 #endif
1326
1327         BLI_make_file_string("/", filepath, BKE_tempdir_base(), path);
1328 }
1329
1330 void WM_autosave_init(wmWindowManager *wm)
1331 {
1332         wm_autosave_timer_ended(wm);
1333
1334         if (U.flag & USER_AUTOSAVE)
1335                 wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime * 60.0);
1336 }
1337
1338 void wm_autosave_timer(const bContext *C, wmWindowManager *wm, wmTimer *UNUSED(wt))
1339 {
1340         wmWindow *win;
1341         wmEventHandler *handler;
1342         char filepath[FILE_MAX];
1343
1344         WM_event_remove_timer(wm, NULL, wm->autosavetimer);
1345
1346         /* if a modal operator is running, don't autosave, but try again in 10 seconds */
1347         for (win = wm->windows.first; win; win = win->next) {
1348                 for (handler = win->modalhandlers.first; handler; handler = handler->next) {
1349                         if (handler->op) {
1350                                 wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, 10.0);
1351                                 if (G.debug) {
1352                                         printf("Skipping auto-save, modal operator running, retrying in ten seconds...\n");
1353                                 }
1354                                 return;
1355                         }
1356                 }
1357         }
1358
1359         wm_autosave_location(filepath);
1360
1361         if (U.uiflag & USER_GLOBALUNDO) {
1362                 /* fast save of last undobuffer, now with UI */
1363                 struct MemFile *memfile = ED_undosys_stack_memfile_get_active(wm->undo_stack);
1364                 if (memfile) {
1365                         BLO_memfile_write_file(memfile, filepath);
1366                 }
1367         }
1368         else {
1369                 /*  save as regular blend file */
1370                 int fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_HISTORY);
1371
1372                 ED_editors_flush_edits(C, false);
1373
1374                 /* Error reporting into console */
1375                 BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);
1376         }
1377         /* do timer after file write, just in case file write takes a long time */
1378         wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime * 60.0);
1379 }
1380
1381 void wm_autosave_timer_ended(wmWindowManager *wm)
1382 {
1383         if (wm->autosavetimer) {
1384                 WM_event_remove_timer(wm, NULL, wm->autosavetimer);
1385                 wm->autosavetimer = NULL;
1386         }
1387 }
1388
1389 void wm_autosave_delete(void)
1390 {
1391         char filename[FILE_MAX];
1392
1393         wm_autosave_location(filename);
1394
1395         if (BLI_exists(filename)) {
1396                 char str[FILE_MAX];
1397                 BLI_make_file_string("/", str, BKE_tempdir_base(), BLENDER_QUIT_FILE);
1398
1399                 /* if global undo; remove tempsave, otherwise rename */
1400                 if (U.uiflag & USER_GLOBALUNDO) BLI_delete(filename, false, false);
1401                 else BLI_rename(filename, str);
1402         }
1403 }
1404
1405 void wm_autosave_read(bContext *C, ReportList *reports)
1406 {
1407         char filename[FILE_MAX];
1408
1409         wm_autosave_location(filename);
1410         WM_file_read(C, filename, reports);
1411 }
1412
1413
1414 /** \name Initialize WM_OT_open_xxx properties
1415  *
1416  * Check if load_ui was set by the caller.
1417  * Fall back to user preference when file flags not specified.
1418  *
1419  * \{ */
1420
1421 void wm_open_init_load_ui(wmOperator *op, bool use_prefs)
1422 {
1423         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "load_ui");
1424         if (!RNA_property_is_set(op->ptr, prop)) {
1425                 bool value = use_prefs ?
1426                              ((U.flag & USER_FILENOUI) == 0) :
1427                              ((G.fileflags & G_FILE_NO_UI) == 0);
1428
1429                 RNA_property_boolean_set(op->ptr, prop, value);
1430         }
1431 }
1432
1433 void wm_open_init_use_scripts(wmOperator *op, bool use_prefs)
1434 {
1435         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_scripts");
1436         if (!RNA_property_is_set(op->ptr, prop)) {
1437                 /* use G_SCRIPT_AUTOEXEC rather than the userpref because this means if
1438                  * the flag has been disabled from the command line, then opening
1439                  * from the menu wont enable this setting. */
1440                 bool value = use_prefs ?
1441                              ((U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0) :
1442                              ((G.f & G_SCRIPT_AUTOEXEC) != 0);
1443
1444                 RNA_property_boolean_set(op->ptr, prop, value);
1445         }
1446 }
1447
1448 /** \} */
1449
1450 void WM_file_tag_modified(void)
1451 {
1452         wmWindowManager *wm = G_MAIN->wm.first;
1453         if (wm->file_saved) {
1454                 wm->file_saved = 0;
1455                 /* notifier that data changed, for save-over warning or header */
1456                 WM_main_add_notifier(NC_WM | ND_DATACHANGED, NULL);
1457         }
1458 }
1459
1460 /** \name Preferences/startup save & load.
1461  *
1462  * \{ */
1463
1464 /**
1465  * \see #wm_file_write wraps #BLO_write_file in a similar way.
1466  */
1467 static int wm_homefile_write_exec(bContext *C, wmOperator *op)
1468 {
1469         Main *bmain = CTX_data_main(C);
1470         wmWindowManager *wm = CTX_wm_manager(C);
1471         wmWindow *win = CTX_wm_window(C);
1472         char filepath[FILE_MAX];
1473         int fileflags;
1474
1475         const char *app_template = U.app_template[0] ? U.app_template : NULL;
1476         const char * const cfgdir = BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, app_template);
1477         if (cfgdir == NULL) {
1478                 BKE_report(op->reports, RPT_ERROR, "Unable to create user config path");
1479                 return OPERATOR_CANCELLED;
1480         }
1481
1482         BLI_callback_exec(bmain, NULL, BLI_CB_EVT_SAVE_PRE);
1483
1484         /* check current window and close it if temp */
1485         if (win && WM_window_is_temp_screen(win))
1486                 wm_window_close(C, wm, win);
1487
1488         /* update keymaps in user preferences */
1489         WM_keyconfig_update(wm);
1490
1491         BLI_path_join(filepath, sizeof(filepath), cfgdir, BLENDER_STARTUP_FILE, NULL);
1492
1493         printf("trying to save homefile at %s ", filepath);
1494
1495         ED_editors_flush_edits(C, false);
1496
1497         /*  force save as regular blend file */
1498         fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_HISTORY);
1499
1500         if (BLO_write_file(bmain, filepath, fileflags | G_FILE_USERPREFS, op->reports, NULL) == 0) {
1501                 printf("fail\n");
1502                 return OPERATOR_CANCELLED;
1503         }
1504
1505         printf("ok\n");
1506
1507         G.save_over = 0;
1508
1509         BLI_callback_exec(bmain, NULL, BLI_CB_EVT_SAVE_POST);
1510
1511         return OPERATOR_FINISHED;
1512 }
1513
1514 void WM_OT_save_homefile(wmOperatorType *ot)
1515 {
1516         ot->name = "Save Startup File";
1517         ot->idname = "WM_OT_save_homefile";
1518         ot->description = "Make the current file the default .blend file";
1519
1520         ot->invoke = WM_operator_confirm;
1521         ot->exec = wm_homefile_write_exec;
1522 }
1523
1524 static int wm_userpref_autoexec_add_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
1525 {
1526         bPathCompare *path_cmp = MEM_callocN(sizeof(bPathCompare), "bPathCompare");
1527         BLI_addtail(&U.autoexec_paths, path_cmp);
1528         return OPERATOR_FINISHED;
1529 }
1530
1531 void WM_OT_userpref_autoexec_path_add(wmOperatorType *ot)
1532 {
1533         ot->name = "Add Autoexec Path";
1534         ot->idname = "WM_OT_userpref_autoexec_path_add";
1535         ot->description = "Add path to exclude from autoexecution";
1536
1537         ot->exec = wm_userpref_autoexec_add_exec;
1538
1539         ot->flag = OPTYPE_INTERNAL;
1540 }
1541
1542 static int wm_userpref_autoexec_remove_exec(bContext *UNUSED(C), wmOperator *op)
1543 {
1544         const int index = RNA_int_get(op->ptr, "index");
1545         bPathCompare *path_cmp = BLI_findlink(&U.autoexec_paths, index);
1546         if (path_cmp) {
1547                 BLI_freelinkN(&U.autoexec_paths, path_cmp);
1548         }
1549         return OPERATOR_FINISHED;
1550 }
1551
1552 void WM_OT_userpref_autoexec_path_remove(wmOperatorType *ot)
1553 {
1554         ot->name = "Remove Autoexec Path";
1555         ot->idname = "WM_OT_userpref_autoexec_path_remove";
1556         ot->description = "Remove path to exclude from autoexecution";
1557
1558         ot->exec = wm_userpref_autoexec_remove_exec;
1559
1560         ot->flag = OPTYPE_INTERNAL;
1561
1562         RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, 1000);
1563 }
1564
1565 /* Only save the prefs block. operator entry */
1566 static int wm_userpref_write_exec(bContext *C, wmOperator *op)
1567 {
1568         wmWindowManager *wm = CTX_wm_manager(C);
1569         char filepath[FILE_MAX];
1570         const char *cfgdir;
1571         bool ok = true;
1572         bool use_template_userpref = wm_app_template_has_userpref(U.app_template);
1573
1574         /* update keymaps in user preferences */
1575         WM_keyconfig_update(wm);
1576
1577         if ((cfgdir = BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, NULL))) {
1578                 bool ok_write;
1579                 BLI_path_join(filepath, sizeof(filepath), cfgdir, BLENDER_USERPREF_FILE, NULL);
1580
1581                 if (use_template_userpref) {
1582                         ok_write = BKE_blendfile_userdef_write_app_template(filepath, op->reports);
1583                 }
1584                 else {
1585                         ok_write = BKE_blendfile_userdef_write(filepath, op->reports);
1586                 }
1587
1588                 if (ok_write) {
1589                         printf("ok\n");
1590                 }
1591                 else {
1592                         printf("fail\n");
1593                         ok = false;
1594                 }
1595         }
1596         else {
1597                 BKE_report(op->reports, RPT_ERROR, "Unable to create userpref path");
1598         }
1599
1600         if (use_template_userpref) {
1601                 if ((cfgdir = BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, U.app_template))) {
1602                         /* Also save app-template prefs */
1603                         BLI_path_join(filepath, sizeof(filepath), cfgdir, BLENDER_USERPREF_FILE, NULL);
1604                         if (BKE_blendfile_userdef_write(filepath, op->reports) != 0) {
1605                                 printf("ok\n");
1606                         }
1607                         else {
1608                                 printf("fail\n");
1609                                 ok = false;
1610                         }
1611                 }
1612                 else {
1613                         BKE_report(op->reports, RPT_ERROR, "Unable to create app-template userpref path");
1614                         ok = false;
1615                 }
1616         }
1617
1618         return ok ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1619 }
1620
1621 void WM_OT_save_userpref(wmOperatorType *ot)
1622 {
1623         ot->name = "Save User Settings";
1624         ot->idname = "WM_OT_save_userpref";
1625         ot->description = "Save user preferences separately, overrides startup file preferences";
1626
1627         ot->invoke = WM_operator_confirm;
1628         ot->exec = wm_userpref_write_exec;
1629 }
1630
1631 static int wm_history_file_read_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
1632 {
1633         ED_file_read_bookmarks();
1634         wm_history_file_read();
1635         return OPERATOR_FINISHED;
1636 }
1637
1638 void WM_OT_read_history(wmOperatorType *ot)
1639 {
1640         ot->name = "Reload History File";
1641         ot->idname = "WM_OT_read_history";
1642         ot->description = "Reloads history and bookmarks";
1643
1644         ot->invoke = WM_operator_confirm;
1645         ot->exec = wm_history_file_read_exec;
1646
1647         /* this operator is only used for loading settings from a previous blender install */
1648         ot->flag = OPTYPE_INTERNAL;
1649 }
1650
1651 static int wm_homefile_read_exec(bContext *C, wmOperator *op)
1652 {
1653         const bool use_factory_settings = (STREQ(op->type->idname, "WM_OT_read_factory_settings"));
1654         bool use_userdef = false;
1655         char filepath_buf[FILE_MAX];
1656         const char *filepath = NULL;
1657
1658         if (!use_factory_settings) {
1659                 PropertyRNA *prop = RNA_struct_find_property(op->ptr, "filepath");
1660
1661                 /* This can be used when loading of a start-up file should only change
1662                  * the scene content but keep the blender UI as it is. */
1663                 wm_open_init_load_ui(op, true);
1664                 SET_FLAG_FROM_TEST(G.fileflags, !RNA_boolean_get(op->ptr, "load_ui"), G_FILE_NO_UI);
1665
1666                 if (RNA_property_is_set(op->ptr, prop)) {
1667                         RNA_property_string_get(op->ptr, prop, filepath_buf);
1668                         filepath = filepath_buf;
1669                         if (BLI_access(filepath, R_OK)) {
1670                                 BKE_reportf(op->reports, RPT_ERROR, "Can't read alternative start-up file: '%s'", filepath);
1671                                 return OPERATOR_CANCELLED;
1672                         }
1673                 }
1674         }
1675         else {
1676                 /* always load UI for factory settings (prefs will re-init) */
1677                 G.fileflags &= ~G_FILE_NO_UI;
1678                 /* Always load preferences with factory settings. */
1679                 use_userdef = true;
1680         }
1681
1682         char app_template_buf[sizeof(U.app_template)];
1683         const char *app_template;
1684         PropertyRNA *prop_app_template = RNA_struct_find_property(op->ptr, "app_template");
1685         const bool use_splash = !use_factory_settings && RNA_boolean_get(op->ptr, "use_splash");
1686         const bool use_empty_data = RNA_boolean_get(op->ptr, "use_empty");
1687
1688         if (prop_app_template && RNA_property_is_set(op->ptr, prop_app_template)) {
1689                 RNA_property_string_get(op->ptr, prop_app_template, app_template_buf);
1690                 app_template = app_template_buf;
1691
1692                 if (!STREQ(app_template, U.app_template)) {
1693                         /* Always load UI when switching to another template. */
1694                         G.fileflags &= ~G_FILE_NO_UI;
1695                 }
1696
1697                 /* Always load preferences when switching templates with own preferences. */
1698                 use_userdef = wm_app_template_has_userpref(app_template) ||
1699                               wm_app_template_has_userpref(U.app_template);
1700
1701                 /* Turn override off, since we're explicitly loading a different app-template. */
1702                 WM_init_state_app_template_set(NULL);
1703         }
1704         else {
1705                 /* Normally NULL, only set when overriding from the command-line. */
1706                 app_template = WM_init_state_app_template_get();
1707         }
1708
1709         if (wm_homefile_read(C, op->reports, use_factory_settings, use_empty_data, use_userdef, filepath, app_template)) {
1710                 if (use_splash) {
1711                         WM_init_splash(C);
1712                 }
1713                 return OPERATOR_FINISHED;
1714         }
1715         else {
1716                 return OPERATOR_CANCELLED;
1717         }
1718 }
1719
1720 static int wm_homefile_read_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event))
1721 {
1722         /* Draw menu which includes default startup and application templates. */
1723         uiPopupMenu *pup = UI_popup_menu_begin(C, IFACE_("New File"), ICON_FILE);
1724         uiLayout *layout = UI_popup_menu_layout(pup);
1725
1726         MenuType *mt = WM_menutype_find("TOPBAR_MT_file_new", false);
1727         if (mt) {
1728                 UI_menutype_draw(C, mt, layout);
1729         }
1730
1731         UI_popup_menu_end(C, pup);
1732
1733         return OPERATOR_INTERFACE;
1734 }
1735
1736 void WM_OT_read_homefile(wmOperatorType *ot)
1737 {
1738         PropertyRNA *prop;
1739         ot->name = "Reload Start-Up File";
1740         ot->idname = "WM_OT_read_homefile";
1741         ot->description = "Open the default file (doesn't save the current file)";
1742
1743         ot->invoke = wm_homefile_read_invoke;
1744         ot->exec = wm_homefile_read_exec;
1745
1746         prop = RNA_def_string_file_path(ot->srna, "filepath", NULL,
1747                                         FILE_MAX, "File Path",
1748                                         "Path to an alternative start-up file");
1749         RNA_def_property_flag(prop, PROP_HIDDEN);
1750
1751         /* So scripts can use an alternative start-up file without the UI */
1752         prop = RNA_def_boolean(ot->srna, "load_ui", true, "Load UI",
1753                                "Load user interface setup from the .blend file");
1754         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1755
1756         prop = RNA_def_boolean(ot->srna, "use_empty", false, "Empty", "");
1757         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1758
1759         /* So the splash can be kept open after loading a file (for templates). */
1760         prop = RNA_def_boolean(ot->srna, "use_splash", false, "Splash", "");
1761         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1762
1763         prop = RNA_def_string(ot->srna, "app_template", "Template", sizeof(U.app_template), "", "");
1764         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1765
1766         /* omit poll to run in background mode */
1767 }
1768
1769 void WM_OT_read_factory_settings(wmOperatorType *ot)
1770 {
1771         PropertyRNA *prop;
1772
1773         ot->name = "Load Factory Settings";
1774         ot->idname = "WM_OT_read_factory_settings";
1775         ot->description = "Load default file and user preferences";
1776
1777         ot->invoke = WM_operator_confirm;
1778         ot->exec = wm_homefile_read_exec;
1779
1780         prop = RNA_def_string(ot->srna, "app_template", "Template", sizeof(U.app_template), "", "");
1781         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1782
1783         prop = RNA_def_boolean(ot->srna, "use_empty", false, "Empty", "");
1784         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1785
1786         /* omit poll to run in background mode */
1787 }
1788
1789 /** \} */
1790
1791 /** \name Open main .blend file.
1792  *
1793  * \{ */
1794
1795 /**
1796  * Wrap #WM_file_read, shared by file reading operators.
1797  */
1798 static bool wm_file_read_opwrap(bContext *C, const char *filepath, ReportList *reports,
1799                                 const bool autoexec_init)
1800 {
1801         bool success;
1802
1803         /* XXX wm in context is not set correctly after WM_file_read -> crash */
1804         /* do it before for now, but is this correct with multiple windows? */
1805         WM_event_add_notifier(C, NC_WINDOW, NULL);
1806
1807         if (autoexec_init) {
1808                 WM_file_autoexec_init(filepath);
1809         }
1810
1811         success = WM_file_read(C, filepath, reports);
1812
1813         return success;
1814 }
1815
1816 /* currently fits in a pointer */
1817 struct FileRuntime {
1818         bool is_untrusted;
1819 };
1820
1821 static int wm_open_mainfile_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1822 {
1823         Main *bmain = CTX_data_main(C);
1824         const char *openname = BKE_main_blendfile_path(bmain);
1825
1826         if (CTX_wm_window(C) == NULL) {
1827                 /* in rare cases this could happen, when trying to invoke in background
1828                  * mode on load for example. Don't use poll for this because exec()
1829                  * can still run without a window */
1830                 BKE_report(op->reports, RPT_ERROR, "Context window not set");
1831                 return OPERATOR_CANCELLED;
1832         }
1833
1834         /* if possible, get the name of the most recently used .blend file */
1835         if (G.recent_files.first) {
1836                 struct RecentFile *recent = G.recent_files.first;
1837                 openname = recent->filepath;
1838         }
1839
1840         RNA_string_set(op->ptr, "filepath", openname);
1841         wm_open_init_load_ui(op, true);
1842         wm_open_init_use_scripts(op, true);
1843         op->customdata = NULL;
1844
1845         WM_event_add_fileselect(C, op);
1846
1847         return OPERATOR_RUNNING_MODAL;
1848 }
1849
1850 static int wm_open_mainfile_exec(bContext *C, wmOperator *op)
1851 {
1852         char filepath[FILE_MAX];
1853         bool success;
1854
1855         RNA_string_get(op->ptr, "filepath", filepath);
1856
1857         /* re-use last loaded setting so we can reload a file without changing */
1858         wm_open_init_load_ui(op, false);
1859         wm_open_init_use_scripts(op, false);
1860
1861         if (RNA_boolean_get(op->ptr, "load_ui"))
1862                 G.fileflags &= ~G_FILE_NO_UI;
1863         else
1864                 G.fileflags |= G_FILE_NO_UI;
1865
1866         if (RNA_boolean_get(op->ptr, "use_scripts"))
1867                 G.f |= G_SCRIPT_AUTOEXEC;
1868         else
1869                 G.f &= ~G_SCRIPT_AUTOEXEC;
1870
1871         success = wm_file_read_opwrap(C, filepath, op->reports, !(G.f & G_SCRIPT_AUTOEXEC));
1872
1873         /* for file open also popup for warnings, not only errors */
1874         BKE_report_print_level_set(op->reports, RPT_WARNING);
1875
1876         if (success) {
1877                 return OPERATOR_FINISHED;
1878         }
1879         else {
1880                 return OPERATOR_CANCELLED;
1881         }
1882 }
1883
1884 static bool wm_open_mainfile_check(bContext *UNUSED(C), wmOperator *op)
1885 {
1886         struct FileRuntime *file_info = (struct FileRuntime *)&op->customdata;
1887         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_scripts");
1888         bool is_untrusted = false;
1889         char path[FILE_MAX];
1890         char *lslash;
1891
1892         RNA_string_get(op->ptr, "filepath", path);
1893
1894         /* get the dir */
1895         lslash = (char *)BLI_last_slash(path);
1896         if (lslash) *(lslash + 1) = '\0';
1897
1898         if ((U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0) {
1899                 if (BKE_autoexec_match(path) == true) {
1900                         RNA_property_boolean_set(op->ptr, prop, false);
1901                         is_untrusted = true;
1902                 }
1903         }
1904
1905         if (file_info) {
1906                 file_info->is_untrusted = is_untrusted;
1907         }
1908
1909         return is_untrusted;
1910 }
1911
1912 static void wm_open_mainfile_ui(bContext *UNUSED(C), wmOperator *op)
1913 {
1914         struct FileRuntime *file_info = (struct FileRuntime *)&op->customdata;
1915         uiLayout *layout = op->layout;
1916         uiLayout *col = op->layout;
1917         const char *autoexec_text;
1918
1919         uiItemR(layout, op->ptr, "load_ui", 0, NULL, ICON_NONE);
1920
1921         col = uiLayoutColumn(layout, false);
1922         if (file_info->is_untrusted) {
1923                 autoexec_text = IFACE_("Trusted Source [Untrusted Path]");
1924                 uiLayoutSetActive(col, false);
1925                 uiLayoutSetEnabled(col, false);
1926         }
1927         else {
1928                 autoexec_text = IFACE_("Trusted Source");
1929         }
1930
1931         uiItemR(col, op->ptr, "use_scripts", 0, autoexec_text, ICON_NONE);
1932 }
1933
1934 void WM_OT_open_mainfile(wmOperatorType *ot)
1935 {
1936         ot->name = "Open Blender File";
1937         ot->idname = "WM_OT_open_mainfile";
1938         ot->description = "Open a Blender file";
1939
1940         ot->invoke = wm_open_mainfile_invoke;
1941         ot->exec = wm_open_mainfile_exec;
1942         ot->check = wm_open_mainfile_check;
1943         ot->ui = wm_open_mainfile_ui;
1944         /* omit window poll so this can work in background mode */
1945
1946         WM_operator_properties_filesel(
1947                 ot, FILE_TYPE_FOLDER | FILE_TYPE_BLENDER, FILE_BLENDER, FILE_OPENFILE,
1948                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
1949
1950         RNA_def_boolean(ot->srna, "load_ui", true, "Load UI", "Load user interface setup in the .blend file");
1951         RNA_def_boolean(ot->srna, "use_scripts", true, "Trusted Source",
1952                         "Allow .blend file to execute scripts automatically, default available from system preferences");
1953 }
1954
1955 /** \} */
1956
1957 /** \name Reload (revert) main .blend file.
1958  *
1959  * \{ */
1960
1961 static int wm_revert_mainfile_exec(bContext *C, wmOperator *op)
1962 {
1963         Main *bmain = CTX_data_main(C);
1964         bool success;
1965         char filepath[FILE_MAX];
1966
1967         wm_open_init_use_scripts(op, false);
1968
1969         if (RNA_boolean_get(op->ptr, "use_scripts"))
1970                 G.f |= G_SCRIPT_AUTOEXEC;
1971         else
1972                 G.f &= ~G_SCRIPT_AUTOEXEC;
1973
1974         BLI_strncpy(filepath, BKE_main_blendfile_path(bmain), sizeof(filepath));
1975         success = wm_file_read_opwrap(C, filepath, op->reports, !(G.f & G_SCRIPT_AUTOEXEC));
1976
1977         if (success) {
1978                 return OPERATOR_FINISHED;
1979         }
1980         else {
1981                 return OPERATOR_CANCELLED;
1982         }
1983 }
1984
1985 static bool wm_revert_mainfile_poll(bContext *UNUSED(C))
1986 {
1987         return G.relbase_valid;
1988 }
1989
1990 void WM_OT_revert_mainfile(wmOperatorType *ot)
1991 {
1992         ot->name = "Revert";
1993         ot->idname = "WM_OT_revert_mainfile";
1994         ot->description = "Reload the saved file";
1995         ot->invoke = WM_operator_confirm;
1996
1997         RNA_def_boolean(ot->srna, "use_scripts", true, "Trusted Source",
1998                         "Allow .blend file to execute scripts automatically, default available from system preferences");
1999
2000         ot->exec = wm_revert_mainfile_exec;
2001         ot->poll = wm_revert_mainfile_poll;
2002 }
2003
2004 /** \} */
2005
2006 /** \name Recover last session & auto-save.
2007  *
2008  * \{ */
2009
2010 void WM_recover_last_session(bContext *C, ReportList *reports)
2011 {
2012         Main *bmain = CTX_data_main(C);
2013         char filepath[FILE_MAX];
2014
2015         BLI_make_file_string("/", filepath, BKE_tempdir_base(), BLENDER_QUIT_FILE);
2016         /* if reports==NULL, it's called directly without operator, we add a quick check here */
2017         if (reports || BLI_exists(filepath)) {
2018                 G.fileflags |= G_FILE_RECOVER;
2019
2020                 wm_file_read_opwrap(C, filepath, reports, true);
2021
2022                 G.fileflags &= ~G_FILE_RECOVER;
2023
2024                 /* XXX bad global... fixme */
2025                 if (BKE_main_blendfile_path(bmain)[0] != '\0') {
2026                         G.file_loaded = 1;      /* prevents splash to show */
2027                 }
2028                 else {
2029                         G.relbase_valid = 0;
2030                         G.save_over = 0;    /* start with save preference untitled.blend */
2031                 }
2032
2033         }
2034 }
2035
2036 static int wm_recover_last_session_exec(bContext *C, wmOperator *op)
2037 {
2038         WM_recover_last_session(C, op->reports);
2039         return OPERATOR_FINISHED;
2040 }
2041
2042 void WM_OT_recover_last_session(wmOperatorType *ot)
2043 {
2044         ot->name = "Recover Last Session";
2045         ot->idname = "WM_OT_recover_last_session";
2046         ot->description = "Open the last closed file (\"" BLENDER_QUIT_FILE "\")";
2047         ot->invoke = WM_operator_confirm;
2048
2049         ot->exec = wm_recover_last_session_exec;
2050 }
2051
2052 static int wm_recover_auto_save_exec(bContext *C, wmOperator *op)
2053 {
2054         char filepath[FILE_MAX];
2055         bool success;
2056
2057         RNA_string_get(op->ptr, "filepath", filepath);
2058
2059         G.fileflags |= G_FILE_RECOVER;
2060
2061         success = wm_file_read_opwrap(C, filepath, op->reports, true);
2062
2063         G.fileflags &= ~G_FILE_RECOVER;
2064
2065         if (success) {
2066                 return OPERATOR_FINISHED;
2067         }
2068         else {
2069                 return OPERATOR_CANCELLED;
2070         }
2071 }
2072
2073 static int wm_recover_auto_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2074 {
2075         char filename[FILE_MAX];
2076
2077         wm_autosave_location(filename);
2078         RNA_string_set(op->ptr, "filepath", filename);
2079         WM_event_add_fileselect(C, op);
2080
2081         return OPERATOR_RUNNING_MODAL;
2082 }
2083
2084 void WM_OT_recover_auto_save(wmOperatorType *ot)
2085 {
2086         ot->name = "Recover Auto Save";
2087         ot->idname = "WM_OT_recover_auto_save";
2088         ot->description = "Open an automatically saved file to recover it";
2089
2090         ot->exec = wm_recover_auto_save_exec;
2091         ot->invoke = wm_recover_auto_save_invoke;
2092
2093         WM_operator_properties_filesel(
2094                 ot, FILE_TYPE_BLENDER, FILE_BLENDER, FILE_OPENFILE,
2095                 WM_FILESEL_FILEPATH, FILE_LONGDISPLAY, FILE_SORT_TIME);
2096 }
2097
2098 /** \} */
2099
2100 /** \name Save main .blend file.
2101  *
2102  * \{ */
2103
2104 static void wm_filepath_default(char *filepath)
2105 {
2106         if (G.save_over == false) {
2107                 BLI_ensure_filename(filepath, FILE_MAX, "untitled.blend");
2108         }
2109 }
2110
2111 static void save_set_compress(wmOperator *op)
2112 {
2113         PropertyRNA *prop;
2114
2115         prop = RNA_struct_find_property(op->ptr, "compress");
2116         if (!RNA_property_is_set(op->ptr, prop)) {
2117                 if (G.save_over) {  /* keep flag for existing file */
2118                         RNA_property_boolean_set(op->ptr, prop, (G.fileflags & G_FILE_COMPRESS) != 0);
2119                 }
2120                 else {  /* use userdef for new file */
2121                         RNA_property_boolean_set(op->ptr, prop, (U.flag & USER_FILECOMPRESS) != 0);
2122                 }
2123         }
2124 }
2125
2126 static void save_set_filepath(bContext *C, wmOperator *op)
2127 {
2128         Main *bmain = CTX_data_main(C);
2129         PropertyRNA *prop;
2130         char name[FILE_MAX];
2131
2132         prop = RNA_struct_find_property(op->ptr, "filepath");
2133         if (!RNA_property_is_set(op->ptr, prop)) {
2134                 /* if not saved before, get the name of the most recently used .blend file */
2135                 if (BKE_main_blendfile_path(bmain)[0] == '\0' && G.recent_files.first) {
2136                         struct RecentFile *recent = G.recent_files.first;
2137                         BLI_strncpy(name, recent->filepath, FILE_MAX);
2138                 }
2139                 else {
2140                         BLI_strncpy(name, bmain->name, FILE_MAX);
2141                 }
2142
2143                 wm_filepath_default(name);
2144                 RNA_property_string_set(op->ptr, prop, name);
2145         }
2146 }
2147
2148 static int wm_save_as_mainfile_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2149 {
2150
2151         save_set_compress(op);
2152         save_set_filepath(C, op);
2153
2154         WM_event_add_fileselect(C, op);
2155
2156         return OPERATOR_RUNNING_MODAL;
2157 }
2158
2159 /* function used for WM_OT_save_mainfile too */
2160 static int wm_save_as_mainfile_exec(bContext *C, wmOperator *op)
2161 {
2162         Main *bmain = CTX_data_main(C);
2163         char path[FILE_MAX];
2164         int fileflags;
2165
2166         save_set_compress(op);
2167
2168         if (RNA_struct_property_is_set(op->ptr, "filepath")) {
2169                 RNA_string_get(op->ptr, "filepath", path);
2170         }
2171         else {
2172                 BLI_strncpy(path, BKE_main_blendfile_path(bmain), FILE_MAX);
2173                 wm_filepath_default(path);
2174         }
2175
2176         fileflags = G.fileflags & ~G_FILE_USERPREFS;
2177
2178         /* set compression flag */
2179         SET_FLAG_FROM_TEST(
2180                 fileflags, RNA_boolean_get(op->ptr, "compress"),
2181                 G_FILE_COMPRESS);
2182         SET_FLAG_FROM_TEST(
2183                 fileflags, RNA_boolean_get(op->ptr, "relative_remap"),
2184                 G_FILE_RELATIVE_REMAP);
2185         SET_FLAG_FROM_TEST(
2186                 fileflags,
2187                 (RNA_struct_property_is_set(op->ptr, "copy") &&
2188                  RNA_boolean_get(op->ptr, "copy")),
2189                 G_FILE_SAVE_COPY);
2190
2191         if (wm_file_write(C, path, fileflags, op->reports) != 0)
2192                 return OPERATOR_CANCELLED;
2193
2194         WM_event_add_notifier(C, NC_WM | ND_FILESAVE, NULL);
2195
2196 #if 0 /* XXX: Remove? This is not currently defined as a valid property */
2197         if (RNA_boolean_get(op->ptr, "exit")) {
2198                 wm_exit_schedule_delayed(C);
2199         }
2200 #endif
2201
2202         return OPERATOR_FINISHED;
2203 }
2204
2205 /* function used for WM_OT_save_mainfile too */
2206 static bool blend_save_check(bContext *UNUSED(C), wmOperator *op)
2207 {
2208         char filepath[FILE_MAX];
2209         RNA_string_get(op->ptr, "filepath", filepath);
2210         if (!BLO_has_bfile_extension(filepath)) {
2211                 /* some users would prefer BLI_path_extension_replace(),
2212                  * we keep getting nitpicking bug reports about this - campbell */
2213                 BLI_path_extension_ensure(filepath, FILE_MAX, ".blend");
2214                 RNA_string_set(op->ptr, "filepath", filepath);
2215                 return true;
2216         }
2217         return false;
2218 }
2219
2220 void WM_OT_save_as_mainfile(wmOperatorType *ot)
2221 {
2222         PropertyRNA *prop;
2223
2224         ot->name = "Save As Blender File";
2225         ot->idname = "WM_OT_save_as_mainfile";
2226         ot->description = "Save the current file in the desired location";
2227
2228         ot->invoke = wm_save_as_mainfile_invoke;
2229         ot->exec = wm_save_as_mainfile_exec;
2230         ot->check = blend_save_check;
2231         /* omit window poll so this can work in background mode */
2232
2233         WM_operator_properties_filesel(
2234                 ot, FILE_TYPE_FOLDER | FILE_TYPE_BLENDER, FILE_BLENDER, FILE_SAVE,
2235                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
2236         RNA_def_boolean(ot->srna, "compress", false, "Compress", "Write compressed .blend file");
2237         RNA_def_boolean(ot->srna, "relative_remap", true, "Remap Relative",
2238                         "Remap relative paths when saving in a different directory");
2239         prop = RNA_def_boolean(ot->srna, "copy", false, "Save Copy",
2240                         "Save a copy of the actual working state but does not make saved file active");
2241         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2242 }
2243
2244 static int wm_save_mainfile_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2245 {
2246         int ret;
2247
2248         /* cancel if no active window */
2249         if (CTX_wm_window(C) == NULL)
2250                 return OPERATOR_CANCELLED;
2251
2252         save_set_compress(op);
2253         save_set_filepath(C, op);
2254
2255         /* if we're saving for the first time and prefer relative paths - any existing paths will be absolute,
2256          * enable the option to remap paths to avoid confusion [#37240] */
2257         if ((G.relbase_valid == false) && (U.flag & USER_RELPATHS)) {
2258                 PropertyRNA *prop = RNA_struct_find_property(op->ptr, "relative_remap");
2259                 if (!RNA_property_is_set(op->ptr, prop)) {
2260                         RNA_property_boolean_set(op->ptr, prop, true);
2261                 }
2262         }
2263
2264         if (G.save_over) {
2265                 char path[FILE_MAX];
2266
2267                 RNA_string_get(op->ptr, "filepath", path);
2268                 if (RNA_boolean_get(op->ptr, "check_existing") && BLI_exists(path)) {
2269                         ret = WM_operator_confirm_message_ex(C, op, IFACE_("Save Over?"), ICON_QUESTION, path);
2270                 }
2271                 else {
2272                         ret = wm_save_as_mainfile_exec(C, op);
2273                         /* Without this there is no feedback the file was saved. */
2274                         BKE_reportf(op->reports, RPT_INFO, "Saved \"%s\"", BLI_path_basename(path));
2275                 }
2276         }
2277         else {
2278                 WM_event_add_fileselect(C, op);
2279                 ret = OPERATOR_RUNNING_MODAL;
2280         }
2281
2282         return ret;
2283 }
2284
2285 void WM_OT_save_mainfile(wmOperatorType *ot)
2286 {
2287         ot->name = "Save Blender File";
2288         ot->idname = "WM_OT_save_mainfile";
2289         ot->description = "Save the current Blender file";
2290
2291         ot->invoke = wm_save_mainfile_invoke;
2292         ot->exec = wm_save_as_mainfile_exec;
2293         ot->check = blend_save_check;
2294         /* omit window poll so this can work in background mode */
2295
2296         PropertyRNA *prop;
2297         WM_operator_properties_filesel(
2298                 ot, FILE_TYPE_FOLDER | FILE_TYPE_BLENDER, FILE_BLENDER, FILE_SAVE,
2299                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
2300         RNA_def_boolean(ot->srna, "compress", false, "Compress", "Write compressed .blend file");
2301         RNA_def_boolean(ot->srna, "relative_remap", false, "Remap Relative",
2302                         "Remap relative paths when saving in a different directory");
2303
2304         prop = RNA_def_boolean(ot->srna, "exit", false, "Exit", "Exit Blender after saving");
2305         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
2306 }
2307
2308 /** \} */