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