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