ce722c732e66ee7f092833ef8dbb95b7a5b1bc50
[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.
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 "DNA_object_types.h"
66 #include "DNA_space_types.h"
67 #include "DNA_userdef_types.h"
68 #include "DNA_scene_types.h"
69 #include "DNA_screen_types.h"
70 #include "DNA_windowmanager_types.h"
71
72 #include "BKE_appdir.h"
73 #include "BKE_utildefines.h"
74 #include "BKE_autoexec.h"
75 #include "BKE_blender.h"
76 #include "BKE_context.h"
77 #include "BKE_depsgraph.h"
78 #include "BKE_global.h"
79 #include "BKE_library.h"
80 #include "BKE_main.h"
81 #include "BKE_packedFile.h"
82 #include "BKE_report.h"
83 #include "BKE_sound.h"
84 #include "BKE_scene.h"
85 #include "BKE_screen.h"
86
87 #include "BLO_readfile.h"
88 #include "BLO_writefile.h"
89
90 #include "RNA_access.h"
91
92 #include "IMB_imbuf.h"
93 #include "IMB_imbuf_types.h"
94 #include "IMB_thumbs.h"
95
96 #include "ED_datafiles.h"
97 #include "ED_fileselect.h"
98 #include "ED_screen.h"
99 #include "ED_view3d.h"
100 #include "ED_util.h"
101
102 #include "GHOST_C-api.h"
103 #include "GHOST_Path-api.h"
104
105 #include "UI_interface.h"
106 #include "UI_view2d.h"
107
108 #include "GPU_draw.h"
109
110 /* only to report a missing engine */
111 #include "RE_engine.h"
112
113 #ifdef WITH_PYTHON
114 #include "BPY_extern.h"
115 #endif
116
117 #include "WM_api.h"
118 #include "WM_types.h"
119 #include "wm.h"
120 #include "wm_files.h"
121 #include "wm_window.h"
122 #include "wm_event_system.h"
123
124 static RecentFile *wm_file_history_find(const char *filepath);
125 static void wm_history_file_free(RecentFile *recent);
126 static void wm_history_file_update(void);
127 static void wm_history_file_write(void);
128
129
130 /* To be able to read files without windows closing, opening, moving
131  * we try to prepare for worst case:
132  * - active window gets active screen from file
133  * - restoring the screens from non-active windows
134  * Best case is all screens match, in that case they get assigned to proper window
135  */
136 static void wm_window_match_init(bContext *C, ListBase *wmlist)
137 {
138         wmWindowManager *wm;
139         wmWindow *win, *active_win;
140         
141         *wmlist = G.main->wm;
142         BLI_listbase_clear(&G.main->wm);
143         
144         active_win = CTX_wm_window(C);
145
146         /* first wrap up running stuff */
147         /* code copied from wm_init_exit.c */
148         for (wm = wmlist->first; wm; wm = wm->id.next) {
149                 
150                 WM_jobs_kill_all(wm);
151                 
152                 for (win = wm->windows.first; win; win = win->next) {
153                 
154                         CTX_wm_window_set(C, win);  /* needed by operator close callbacks */
155                         WM_event_remove_handlers(C, &win->handlers);
156                         WM_event_remove_handlers(C, &win->modalhandlers);
157                         ED_screen_exit(C, win, win->screen);
158                 }
159         }
160         
161         /* reset active window */
162         CTX_wm_window_set(C, active_win);
163
164         /* XXX Hack! We have to clear context menu here, because removing all modalhandlers above frees the active menu
165          *     (at least, in the 'startup splash' case), causing use-after-free error in later handling of the button
166          *     callbacks in UI code (see ui_apply_but_funcs_after()).
167          *     Tried solving this by always NULL-ing context's menu when setting wm/win/etc., but it broke popups refreshing
168          *     (see T47632), so for now just handling this specific case here. */
169         CTX_wm_menu_set(C, NULL);
170
171         ED_editors_exit(C);
172
173         /* just had return; here from r12991, this code could just get removed?*/
174 #if 0
175         if (wm == NULL) return;
176         if (G.fileflags & G_FILE_NO_UI) return;
177         
178         /* we take apart the used screens from non-active window */
179         for (win = wm->windows.first; win; win = win->next) {
180                 BLI_strncpy(win->screenname, win->screen->id.name, MAX_ID_NAME);
181                 if (win != wm->winactive) {
182                         BLI_remlink(&G.main->screen, win->screen);
183                         //BLI_addtail(screenbase, win->screen);
184                 }
185         }
186 #endif
187 }
188
189 static void wm_window_substitute_old(wmWindowManager *wm, wmWindow *oldwin, wmWindow *win)
190 {
191         win->ghostwin = oldwin->ghostwin;
192         win->multisamples = oldwin->multisamples;
193         win->active = oldwin->active;
194         if (win->active)
195                 wm->winactive = win;
196
197         if (!G.background) /* file loading in background mode still calls this */
198                 GHOST_SetWindowUserData(win->ghostwin, win);    /* pointer back */
199
200         oldwin->ghostwin = NULL;
201         oldwin->multisamples = 0;
202
203         win->eventstate = oldwin->eventstate;
204         oldwin->eventstate = NULL;
205
206         /* ensure proper screen rescaling */
207         win->sizex = oldwin->sizex;
208         win->sizey = oldwin->sizey;
209         win->posx = oldwin->posx;
210         win->posy = oldwin->posy;
211 }
212
213 /* match old WM with new, 4 cases:
214  * 1- no current wm, no read wm: make new default
215  * 2- no current wm, but read wm: that's OK, do nothing
216  * 3- current wm, but not in file: try match screen names
217  * 4- current wm, and wm in file: try match ghostwin
218  */
219
220 static void wm_window_match_do(bContext *C, ListBase *oldwmlist)
221 {
222         wmWindowManager *oldwm, *wm;
223         wmWindow *oldwin, *win;
224         
225         /* cases 1 and 2 */
226         if (BLI_listbase_is_empty(oldwmlist)) {
227                 if (G.main->wm.first) {
228                         /* nothing todo */
229                 }
230                 else {
231                         wm_add_default(C);
232                 }
233         }
234         else {
235                 /* cases 3 and 4 */
236                 
237                 /* we've read file without wm..., keep current one entirely alive */
238                 if (BLI_listbase_is_empty(&G.main->wm)) {
239                         bScreen *screen = NULL;
240
241                         /* when loading without UI, no matching needed */
242                         if (!(G.fileflags & G_FILE_NO_UI) && (screen = CTX_wm_screen(C))) {
243
244                                 /* match oldwm to new dbase, only old files */
245                                 for (wm = oldwmlist->first; wm; wm = wm->id.next) {
246                                         
247                                         for (win = wm->windows.first; win; win = win->next) {
248                                                 /* all windows get active screen from file */
249                                                 if (screen->winid == 0)
250                                                         win->screen = screen;
251                                                 else 
252                                                         win->screen = ED_screen_duplicate(win, screen);
253                                                 
254                                                 BLI_strncpy(win->screenname, win->screen->id.name + 2, sizeof(win->screenname));
255                                                 win->screen->winid = win->winid;
256                                         }
257                                 }
258                         }
259                         
260                         G.main->wm = *oldwmlist;
261                         
262                         /* screens were read from file! */
263                         ED_screens_initialize(G.main->wm.first);
264                 }
265                 else {
266                         bool has_match = false;
267
268                         /* what if old was 3, and loaded 1? */
269                         /* this code could move to setup_appdata */
270                         oldwm = oldwmlist->first;
271                         wm = G.main->wm.first;
272
273                         /* preserve key configurations in new wm, to preserve their keymaps */
274                         wm->keyconfigs = oldwm->keyconfigs;
275                         wm->addonconf = oldwm->addonconf;
276                         wm->defaultconf = oldwm->defaultconf;
277                         wm->userconf = oldwm->userconf;
278
279                         BLI_listbase_clear(&oldwm->keyconfigs);
280                         oldwm->addonconf = NULL;
281                         oldwm->defaultconf = NULL;
282                         oldwm->userconf = NULL;
283
284                         /* ensure making new keymaps and set space types */
285                         wm->initialized = 0;
286                         wm->winactive = NULL;
287
288                         /* only first wm in list has ghostwins */
289                         for (win = wm->windows.first; win; win = win->next) {
290                                 for (oldwin = oldwm->windows.first; oldwin; oldwin = oldwin->next) {
291
292                                         if (oldwin->winid == win->winid) {
293                                                 has_match = true;
294
295                                                 wm_window_substitute_old(wm, oldwin, win);
296                                         }
297                                 }
298                         }
299
300                         /* make sure at least one window is kept open so we don't lose the context, check T42303 */
301                         if (!has_match) {
302                                 oldwin = oldwm->windows.first;
303                                 win = wm->windows.first;
304
305                                 wm_window_substitute_old(wm, oldwin, win);
306                         }
307
308                         wm_close_and_free_all(C, oldwmlist);
309                 }
310         }
311 }
312
313 /* in case UserDef was read, we re-initialize all, and do versioning */
314 static void wm_init_userdef(bContext *C, const bool from_memory)
315 {
316         Main *bmain = CTX_data_main(C);
317
318         /* versioning is here */
319         UI_init_userdef();
320         
321         MEM_CacheLimiter_set_maximum(((size_t)U.memcachelimit) * 1024 * 1024);
322         BKE_sound_init(bmain);
323
324         /* needed so loading a file from the command line respects user-pref [#26156] */
325         BKE_BIT_TEST_SET(G.fileflags, U.flag & USER_FILENOUI, G_FILE_NO_UI);
326
327         /* set the python auto-execute setting from user prefs */
328         /* enabled by default, unless explicitly enabled in the command line which overrides */
329         if ((G.f & G_SCRIPT_OVERRIDE_PREF) == 0) {
330                 BKE_BIT_TEST_SET(G.f, (U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0, G_SCRIPT_AUTOEXEC);
331         }
332
333         /* avoid re-saving for every small change to our prefs, allow overrides */
334         if (from_memory) {
335                 BLO_update_defaults_userpref_blend();
336         }
337
338         /* update tempdir from user preferences */
339         BKE_tempdir_init(U.tempdir);
340
341         BKE_userdef_state();
342 }
343
344
345
346 /* return codes */
347 #define BKE_READ_EXOTIC_FAIL_PATH       -3 /* file format is not supported */
348 #define BKE_READ_EXOTIC_FAIL_FORMAT     -2 /* file format is not supported */
349 #define BKE_READ_EXOTIC_FAIL_OPEN       -1 /* Can't open the file */
350 #define BKE_READ_EXOTIC_OK_BLEND         0 /* .blend file */
351 #if 0
352 #define BKE_READ_EXOTIC_OK_OTHER         1 /* other supported formats */
353 #endif
354
355
356 /* intended to check for non-blender formats but for now it only reads blends */
357 static int wm_read_exotic(const char *name)
358 {
359         int len;
360         gzFile gzfile;
361         char header[7];
362         int retval;
363
364         /* make sure we're not trying to read a directory.... */
365
366         len = strlen(name);
367         if (len > 0 && ELEM(name[len - 1], '/', '\\')) {
368                 retval = BKE_READ_EXOTIC_FAIL_PATH;
369         }
370         else {
371                 gzfile = BLI_gzopen(name, "rb");
372                 if (gzfile == NULL) {
373                         retval = BKE_READ_EXOTIC_FAIL_OPEN;
374                 }
375                 else {
376                         len = gzread(gzfile, header, sizeof(header));
377                         gzclose(gzfile);
378                         if (len == sizeof(header) && STREQLEN(header, "BLENDER", 7)) {
379                                 retval = BKE_READ_EXOTIC_OK_BLEND;
380                         }
381                         else {
382 #if 0           /* historic stuff - no longer used */
383                                 WM_cursor_wait(true);
384
385                                 if (is_foo_format(name)) {
386                                         read_foo(name);
387                                         retval = BKE_READ_EXOTIC_OK_OTHER;
388                                 }
389                                 else
390 #endif
391                                 {
392                                         retval = BKE_READ_EXOTIC_FAIL_FORMAT;
393                                 }
394 #if 0
395                                 WM_cursor_wait(false);
396 #endif
397                         }
398                 }
399         }
400
401         return retval;
402 }
403
404 void WM_file_autoexec_init(const char *filepath)
405 {
406         if (G.f & G_SCRIPT_OVERRIDE_PREF) {
407                 return;
408         }
409
410         if (G.f & G_SCRIPT_AUTOEXEC) {
411                 char path[FILE_MAX];
412                 BLI_split_dir_part(filepath, path, sizeof(path));
413                 if (BKE_autoexec_match(path)) {
414                         G.f &= ~G_SCRIPT_AUTOEXEC;
415                 }
416         }
417 }
418
419 void wm_file_read_report(bContext *C)
420 {
421         ReportList *reports = NULL;
422         Scene *sce;
423
424         for (sce = G.main->scene.first; sce; sce = sce->id.next) {
425                 if (sce->r.engine[0] &&
426                     BLI_findstring(&R_engines, sce->r.engine, offsetof(RenderEngineType, idname)) == NULL)
427                 {
428                         if (reports == NULL) {
429                                 reports = CTX_wm_reports(C);
430                         }
431
432                         BKE_reportf(reports, RPT_ERROR,
433                                     "Engine '%s' not available for scene '%s' "
434                                     "(an addon may need to be installed or enabled)",
435                                     sce->r.engine, sce->id.name + 2);
436                 }
437         }
438
439         if (reports) {
440                 if (!G.background) {
441                         WM_report_banner_show();
442                 }
443         }
444 }
445
446 /**
447  * Logic shared between #WM_file_read & #wm_homefile_read,
448  * updates to make after reading a file.
449  */
450 static void wm_file_read_post(bContext *C, bool is_startup_file)
451 {
452         bool addons_loaded = false;
453         wmWindowManager *wm = CTX_wm_manager(C);
454
455         if (!G.background) {
456                 /* remove windows which failed to be added via WM_check */
457                 wm_window_ghostwindows_remove_invalid(C, wm);
458         }
459
460         CTX_wm_window_set(C, wm->windows.first);
461
462         ED_editors_init(C);
463         DAG_on_visible_update(CTX_data_main(C), true);
464
465 #ifdef WITH_PYTHON
466         if (is_startup_file) {
467                 /* possible python hasn't been initialized */
468                 if (CTX_py_init_get(C)) {
469                         /* sync addons, these may have changed from the defaults */
470                         BPY_execute_string(C, "__import__('addon_utils').reset_all()");
471
472                         BPY_python_reset(C);
473                         addons_loaded = true;
474                 }
475         }
476         else {
477                 /* run any texts that were loaded in and flagged as modules */
478                 BPY_python_reset(C);
479                 addons_loaded = true;
480         }
481 #else
482         UNUSED_VARS(is_startup_file);
483 #endif  /* WITH_PYTHON */
484
485         WM_operatortype_last_properties_clear_all();
486
487         /* important to do before NULL'ing the context */
488         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_VERSION_UPDATE);
489         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_POST);
490
491         /* would otherwise be handled by event loop */
492         if (G.background) {
493                 Main *bmain = CTX_data_main(C);
494                 BKE_scene_update_tagged(bmain->eval_ctx, bmain, CTX_data_scene(C));
495         }
496
497         WM_event_add_notifier(C, NC_WM | ND_FILEREAD, NULL);
498
499         /* report any errors.
500          * currently disabled if addons aren't yet loaded */
501         if (addons_loaded) {
502                 wm_file_read_report(C);
503         }
504
505         if (!G.background) {
506                 /* in background mode this makes it hard to load
507                  * a blend file and do anything since the screen
508                  * won't be set to a valid value again */
509                 CTX_wm_window_set(C, NULL); /* exits queues */
510         }
511
512         if (!G.background) {
513 //              undo_editmode_clear();
514                 BKE_undo_reset();
515                 BKE_undo_write(C, "original");  /* save current state */
516         }
517 }
518
519 bool WM_file_read(bContext *C, const char *filepath, ReportList *reports)
520 {
521         /* assume automated tasks with background, don't write recent file list */
522         const bool do_history = (G.background == false) && (CTX_wm_manager(C)->op_undo_depth == 0);
523         bool success = false;
524         int retval;
525
526         /* so we can get the error message */
527         errno = 0;
528
529         WM_cursor_wait(1);
530
531         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_PRE);
532
533         UI_view2d_zoom_cache_reset();
534
535         /* first try to append data from exotic file formats... */
536         /* it throws error box when file doesn't exist and returns -1 */
537         /* note; it should set some error message somewhere... (ton) */
538         retval = wm_read_exotic(filepath);
539         
540         /* we didn't succeed, now try to read Blender file */
541         if (retval == BKE_READ_EXOTIC_OK_BLEND) {
542                 int G_f = G.f;
543                 ListBase wmbase;
544
545                 /* put aside screens to match with persistent windows later */
546                 /* also exit screens and editors */
547                 wm_window_match_init(C, &wmbase); 
548                 
549                 /* confusing this global... */
550                 G.relbase_valid = 1;
551                 retval = BKE_read_file(C, filepath, reports);
552                 /* when loading startup.blend's, we can be left with a blank path */
553                 if (G.main->name[0]) {
554                         G.save_over = 1;
555                 }
556                 else {
557                         G.save_over = 0;
558                         G.relbase_valid = 0;
559                 }
560
561                 /* this flag is initialized by the operator but overwritten on read.
562                  * need to re-enable it here else drivers + registered scripts wont work. */
563                 if (G.f != G_f) {
564                         const int flags_keep = (G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
565                         G.f = (G.f & ~flags_keep) | (G_f & flags_keep);
566                 }
567
568                 /* match the read WM with current WM */
569                 wm_window_match_do(C, &wmbase);
570                 WM_check(C); /* opens window(s), checks keymaps */
571
572                 if (retval == BKE_READ_FILE_OK_USERPREFS) {
573                         /* in case a userdef is read from regular .blend */
574                         wm_init_userdef(C, false);
575                 }
576                 
577                 if (retval != BKE_READ_FILE_FAIL) {
578                         if (do_history) {
579                                 wm_history_file_update();
580                         }
581                 }
582
583                 wm_file_read_post(C, false);
584
585                 success = true;
586         }
587 #if 0
588         else if (retval == BKE_READ_EXOTIC_OK_OTHER)
589                 BKE_undo_write(C, "Import file");
590 #endif
591         else if (retval == BKE_READ_EXOTIC_FAIL_OPEN) {
592                 BKE_reportf(reports, RPT_ERROR, "Cannot read file '%s': %s", filepath,
593                             errno ? strerror(errno) : TIP_("unable to open the file"));
594         }
595         else if (retval == BKE_READ_EXOTIC_FAIL_FORMAT) {
596                 BKE_reportf(reports, RPT_ERROR, "File format is not supported in file '%s'", filepath);
597         }
598         else if (retval == BKE_READ_EXOTIC_FAIL_PATH) {
599                 BKE_reportf(reports, RPT_ERROR, "File path '%s' invalid", filepath);
600         }
601         else {
602                 BKE_reportf(reports, RPT_ERROR, "Unknown error loading '%s'", filepath);
603                 BLI_assert(!"invalid 'retval'");
604         }
605
606
607         if (success == false) {
608                 /* remove from recent files list */
609                 if (do_history) {
610                         RecentFile *recent = wm_file_history_find(filepath);
611                         if (recent) {
612                                 wm_history_file_free(recent);
613                                 wm_history_file_write();
614                         }
615                 }
616         }
617
618         WM_cursor_wait(0);
619
620         return success;
621
622 }
623
624
625 /**
626  * called on startup,  (context entirely filled with NULLs)
627  * or called for 'New File'
628  * both startup.blend and userpref.blend are checked
629  * the optional parameter custom_file points to an alternative startup page
630  * custom_file can be NULL
631  */
632 int wm_homefile_read(bContext *C, ReportList *reports, bool from_memory, const char *custom_file)
633 {
634         ListBase wmbase;
635         char startstr[FILE_MAX];
636         char prefstr[FILE_MAX];
637         int success = 0;
638
639         /* Indicates whether user preferences were really load from memory.
640          *
641          * This is used for versioning code, and for this we can not rely on from_memory
642          * passed via argument. This is because there might be configuration folder
643          * exists but it might not have userpref.blend and in this case we fallback to
644          * reading home file from memory.
645          *
646          * And in this case versioning code is to be run.
647          */
648         bool read_userdef_from_memory = true;
649
650         /* options exclude eachother */
651         BLI_assert((from_memory && custom_file) == 0);
652
653         if ((G.f & G_SCRIPT_OVERRIDE_PREF) == 0) {
654                 BKE_BIT_TEST_SET(G.f, (U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0, G_SCRIPT_AUTOEXEC);
655         }
656
657         BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_PRE);
658
659         UI_view2d_zoom_cache_reset();
660
661         G.relbase_valid = 0;
662         if (!from_memory) {
663                 const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);
664                 if (custom_file) {
665                         BLI_strncpy(startstr, custom_file, FILE_MAX);
666
667                         if (cfgdir) {
668                                 BLI_make_file_string(G.main->name, prefstr, cfgdir, BLENDER_USERPREF_FILE);
669                         }
670                         else {
671                                 prefstr[0] = '\0';
672                         }
673                 }
674                 else if (cfgdir) {
675                         BLI_make_file_string(G.main->name, startstr, cfgdir, BLENDER_STARTUP_FILE);
676                         BLI_make_file_string(G.main->name, prefstr, cfgdir, BLENDER_USERPREF_FILE);
677                 }
678                 else {
679                         startstr[0] = '\0';
680                         prefstr[0] = '\0';
681                         from_memory = 1;
682                 }
683         }
684         
685         /* put aside screens to match with persistent windows later */
686         wm_window_match_init(C, &wmbase);
687         
688         if (!from_memory) {
689                 if (BLI_access(startstr, R_OK) == 0) {
690                         success = (BKE_read_file(C, startstr, NULL) != BKE_READ_FILE_FAIL);
691                 }
692                 if (BLI_listbase_is_empty(&U.themes)) {
693                         if (G.debug & G_DEBUG)
694                                 printf("\nNote: No (valid) '%s' found, fall back to built-in default.\n\n", startstr);
695                         success = 0;
696                 }
697         }
698
699         if (success == 0 && custom_file && reports) {
700                 BKE_reportf(reports, RPT_ERROR, "Could not read '%s'", custom_file);
701                 /*We can not return from here because wm is already reset*/
702         }
703
704         if (success == 0) {
705                 success = BKE_read_file_from_memory(C, datatoc_startup_blend, datatoc_startup_blend_size, NULL, true);
706                 if (BLI_listbase_is_empty(&wmbase)) {
707                         wm_clear_default_size(C);
708                 }
709                 BKE_tempdir_init(U.tempdir);
710
711 #ifdef WITH_PYTHON_SECURITY
712                 /* use alternative setting for security nuts
713                  * otherwise we'd need to patch the binary blob - startup.blend.c */
714                 U.flag |= USER_SCRIPT_AUTOEXEC_DISABLE;
715 #endif
716         }
717         
718         /* check new prefs only after startup.blend was finished */
719         if (!from_memory && BLI_exists(prefstr)) {
720                 int done = BKE_read_file_userdef(prefstr, NULL);
721                 if (done != BKE_READ_FILE_FAIL) {
722                         read_userdef_from_memory = false;
723                         printf("Read new prefs: %s\n", prefstr);
724                 }
725         }
726         
727         /* prevent buggy files that had G_FILE_RELATIVE_REMAP written out by mistake. Screws up autosaves otherwise
728          * can remove this eventually, only in a 2.53 and older, now its not written */
729         G.fileflags &= ~G_FILE_RELATIVE_REMAP;
730         
731         /* check userdef before open window, keymaps etc */
732         wm_init_userdef(C, read_userdef_from_memory);
733         
734         /* match the read WM with current WM */
735         wm_window_match_do(C, &wmbase); 
736         WM_check(C); /* opens window(s), checks keymaps */
737
738         G.main->name[0] = '\0';
739
740         /* When loading factory settings, the reset solid OpenGL lights need to be applied. */
741         if (!G.background) GPU_default_lights();
742         
743         /* XXX */
744         G.save_over = 0;    // start with save preference untitled.blend
745         G.fileflags &= ~G_FILE_AUTOPLAY;    /*  disable autoplay in startup.blend... */
746
747         wm_file_read_post(C, true);
748
749         return true;
750 }
751
752 int wm_history_file_read_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
753 {
754         ED_file_read_bookmarks();
755         wm_history_file_read();
756         return OPERATOR_FINISHED;
757 }
758
759 int wm_homefile_read_exec(bContext *C, wmOperator *op)
760 {
761         const bool from_memory = (STREQ(op->type->idname, "WM_OT_read_factory_settings"));
762         char filepath_buf[FILE_MAX];
763         const char *filepath = NULL;
764
765         if (!from_memory) {
766                 PropertyRNA *prop = RNA_struct_find_property(op->ptr, "filepath");
767
768                 /* This can be used when loading of a start-up file should only change
769                  * the scene content but keep the blender UI as it is. */
770                 wm_open_init_load_ui(op, true);
771                 BKE_BIT_TEST_SET(G.fileflags, !RNA_boolean_get(op->ptr, "load_ui"), G_FILE_NO_UI);
772
773                 if (RNA_property_is_set(op->ptr, prop)) {
774                         RNA_property_string_get(op->ptr, prop, filepath_buf);
775                         filepath = filepath_buf;
776                         if (BLI_access(filepath, R_OK)) {
777                                 BKE_reportf(op->reports, RPT_ERROR, "Can't read alternative start-up file: '%s'", filepath);
778                                 return OPERATOR_CANCELLED;
779                         }
780                 }
781         }
782         else {
783                 /* always load UI for factory settings (prefs will re-init) */
784                 G.fileflags &= ~G_FILE_NO_UI;
785         }
786
787         return wm_homefile_read(C, op->reports, from_memory, filepath) ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
788 }
789
790 /** \name WM History File API
791  * \{ */
792
793 void wm_history_file_read(void)
794 {
795         char name[FILE_MAX];
796         LinkNode *l, *lines;
797         struct RecentFile *recent;
798         const char *line;
799         int num;
800         const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);
801
802         if (!cfgdir) return;
803
804         BLI_make_file_string("/", name, cfgdir, BLENDER_HISTORY_FILE);
805
806         lines = BLI_file_read_as_lines(name);
807
808         BLI_listbase_clear(&G.recent_files);
809
810         /* read list of recent opened files from recent-files.txt to memory */
811         for (l = lines, num = 0; l && (num < U.recent_files); l = l->next) {
812                 line = l->link;
813                 /* don't check if files exist, causes slow startup for remote/external drives */
814                 if (line[0]) {
815                         recent = (RecentFile *)MEM_mallocN(sizeof(RecentFile), "RecentFile");
816                         BLI_addtail(&(G.recent_files), recent);
817                         recent->filepath = BLI_strdup(line);
818                         num++;
819                 }
820         }
821         
822         BLI_file_free_lines(lines);
823 }
824
825 static RecentFile *wm_history_file_new(const char *filepath)
826 {
827         RecentFile *recent = MEM_mallocN(sizeof(RecentFile), "RecentFile");
828         recent->filepath = BLI_strdup(filepath);
829         return recent;
830 }
831
832 static void wm_history_file_free(RecentFile *recent)
833 {
834         BLI_assert(BLI_findindex(&G.recent_files, recent) != -1);
835         MEM_freeN(recent->filepath);
836         BLI_freelinkN(&G.recent_files, recent);
837 }
838
839 static RecentFile *wm_file_history_find(const char *filepath)
840 {
841         return BLI_findstring_ptr(&G.recent_files, filepath, offsetof(RecentFile, filepath));
842 }
843
844 /**
845  * Write #BLENDER_HISTORY_FILE as-is, without checking the environment
846  * (thats handled by #wm_history_file_update).
847  */
848 static void wm_history_file_write(void)
849 {
850         const char *user_config_dir;
851         char name[FILE_MAX];
852         FILE *fp;
853
854         /* will be NULL in background mode */
855         user_config_dir = BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, NULL);
856         if (!user_config_dir)
857                 return;
858
859         BLI_make_file_string("/", name, user_config_dir, BLENDER_HISTORY_FILE);
860
861         fp = BLI_fopen(name, "w");
862         if (fp) {
863                 struct RecentFile *recent;
864                 for (recent = G.recent_files.first; recent; recent = recent->next) {
865                         fprintf(fp, "%s\n", recent->filepath);
866                 }
867                 fclose(fp);
868         }
869 }
870
871 /**
872  * Run after saving a file to refresh the #BLENDER_HISTORY_FILE list.
873  */
874 static void wm_history_file_update(void)
875 {
876         RecentFile *recent;
877
878         /* no write history for recovered startup files */
879         if (G.main->name[0] == 0)
880                 return;
881
882         recent = G.recent_files.first;
883         /* refresh recent-files.txt of recent opened files, when current file was changed */
884         if (!(recent) || (BLI_path_cmp(recent->filepath, G.main->name) != 0)) {
885
886                 recent = wm_file_history_find(G.main->name);
887                 if (recent) {
888                         BLI_remlink(&G.recent_files, recent);
889                 }
890                 else {
891                         RecentFile *recent_next;
892                         for (recent = BLI_findlink(&G.recent_files, U.recent_files - 1); recent; recent = recent_next) {
893                                 recent_next = recent->next;
894                                 wm_history_file_free(recent);
895                         }
896                         recent = wm_history_file_new(G.main->name);
897                 }
898
899                 /* add current file to the beginning of list */
900                 BLI_addhead(&(G.recent_files), recent);
901
902                 /* write current file to recent-files.txt */
903                 wm_history_file_write();
904
905                 /* also update most recent files on System */
906                 GHOST_addToSystemRecentFiles(G.main->name);
907         }
908 }
909
910 /** \} */
911
912
913 /* screen can be NULL */
914 static ImBuf *blend_file_thumb(Scene *scene, bScreen *screen, BlendThumbnail **thumb_pt)
915 {
916         /* will be scaled down, but gives some nice oversampling */
917         ImBuf *ibuf;
918         BlendThumbnail *thumb;
919         char err_out[256] = "unknown";
920
921         /* screen if no camera found */
922         ScrArea *sa = NULL;
923         ARegion *ar = NULL;
924         View3D *v3d = NULL;
925
926         /* In case we are given a valid thumbnail data, just generate image from it. */
927         if (*thumb_pt) {
928                 thumb = *thumb_pt;
929                 return BKE_main_thumbnail_to_imbuf(NULL, thumb);
930         }
931
932         /* scene can be NULL if running a script at startup and calling the save operator */
933         if (G.background || scene == NULL)
934                 return NULL;
935
936         if ((scene->camera == NULL) && (screen != NULL)) {
937                 sa = BKE_screen_find_big_area(screen, SPACE_VIEW3D, 0);
938                 ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
939                 if (ar) {
940                         v3d = sa->spacedata.first;
941                 }
942         }
943
944         if (scene->camera == NULL && v3d == NULL) {
945                 return NULL;
946         }
947
948         /* gets scaled to BLEN_THUMB_SIZE */
949         if (scene->camera) {
950                 ibuf = ED_view3d_draw_offscreen_imbuf_simple(
951                         scene, scene->camera,
952                         BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
953                         IB_rect, OB_SOLID, false, false, false, R_ALPHAPREMUL, 0, false, NULL,
954                         NULL, NULL, err_out);
955         }
956         else {
957                 ibuf = ED_view3d_draw_offscreen_imbuf(
958                         scene, v3d, ar,
959                         BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
960                         IB_rect, false, R_ALPHAPREMUL, 0, false, NULL,
961                         NULL, NULL, err_out);
962         }
963
964         if (ibuf) {
965                 float aspect = (scene->r.xsch * scene->r.xasp) / (scene->r.ysch * scene->r.yasp);
966
967                 /* dirty oversampling */
968                 IMB_scaleImBuf(ibuf, BLEN_THUMB_SIZE, BLEN_THUMB_SIZE);
969
970                 /* add pretty overlay */
971                 IMB_thumb_overlay_blend(ibuf->rect, ibuf->x, ibuf->y, aspect);
972                 
973                 thumb = BKE_main_thumbnail_from_imbuf(NULL, ibuf);
974         }
975         else {
976                 /* '*thumb_pt' needs to stay NULL to prevent a bad thumbnail from being handled */
977                 fprintf(stderr, "blend_file_thumb failed to create thumbnail: %s\n", err_out);
978                 thumb = NULL;
979         }
980         
981         /* must be freed by caller */
982         *thumb_pt = thumb;
983         
984         return ibuf;
985 }
986
987 /* easy access from gdb */
988 bool write_crash_blend(void)
989 {
990         char path[FILE_MAX];
991         int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on crash file */
992
993         BLI_strncpy(path, G.main->name, sizeof(path));
994         BLI_replace_extension(path, sizeof(path), "_crash.blend");
995         if (BLO_write_file(G.main, path, fileflags, NULL, NULL)) {
996                 printf("written: %s\n", path);
997                 return 1;
998         }
999         else {
1000                 printf("failed: %s\n", path);
1001                 return 0;
1002         }
1003 }
1004
1005 /**
1006  * \see #wm_homefile_write_exec wraps #BLO_write_file in a similar way.
1007  */
1008 int wm_file_write(bContext *C, const char *filepath, int fileflags, ReportList *reports)
1009 {
1010         Library *li;
1011         int len;
1012         int ret = -1;
1013         BlendThumbnail *thumb, *main_thumb;
1014         ImBuf *ibuf_thumb = NULL;
1015
1016         len = strlen(filepath);
1017         
1018         if (len == 0) {
1019                 BKE_report(reports, RPT_ERROR, "Path is empty, cannot save");
1020                 return ret;
1021         }
1022
1023         if (len >= FILE_MAX) {
1024                 BKE_report(reports, RPT_ERROR, "Path too long, cannot save");
1025                 return ret;
1026         }
1027         
1028         /* Check if file write permission is ok */
1029         if (BLI_exists(filepath) && !BLI_file_is_writable(filepath)) {
1030                 BKE_reportf(reports, RPT_ERROR, "Cannot save blend file, path '%s' is not writable", filepath);
1031                 return ret;
1032         }
1033  
1034         /* note: used to replace the file extension (to ensure '.blend'),
1035          * no need to now because the operator ensures,
1036          * its handy for scripts to save to a predefined name without blender editing it */
1037         
1038         /* send the OnSave event */
1039         for (li = G.main->library.first; li; li = li->id.next) {
1040                 if (BLI_path_cmp(li->filepath, filepath) == 0) {
1041                         BKE_reportf(reports, RPT_ERROR, "Cannot overwrite used library '%.240s'", filepath);
1042                         return ret;
1043                 }
1044         }
1045
1046         /* Call pre-save callbacks befores writing preview, that way you can generate custom file thumbnail... */
1047         BLI_callback_exec(G.main, NULL, BLI_CB_EVT_SAVE_PRE);
1048
1049         /* blend file thumbnail */
1050         /* save before exit_editmode, otherwise derivedmeshes for shared data corrupt #27765) */
1051         /* Main now can store a .blend thumbnail, usefull for background mode or thumbnail customization. */
1052         main_thumb = thumb = CTX_data_main(C)->blen_thumb;
1053         if ((U.flag & USER_SAVE_PREVIEWS) && BLI_thread_is_main()) {
1054                 ibuf_thumb = blend_file_thumb(CTX_data_scene(C), CTX_wm_screen(C), &thumb);
1055         }
1056
1057         /* operator now handles overwrite checks */
1058
1059         if (G.fileflags & G_AUTOPACK) {
1060                 packAll(G.main, reports, false);
1061         }
1062
1063         /* don't forget not to return without! */
1064         WM_cursor_wait(1);
1065         
1066         ED_editors_flush_edits(C, false);
1067
1068         fileflags |= G_FILE_HISTORY; /* write file history */
1069
1070         /* first time saving */
1071         /* XXX temp solution to solve bug, real fix coming (ton) */
1072         if ((G.main->name[0] == '\0') && !(fileflags & G_FILE_SAVE_COPY)) {
1073                 BLI_strncpy(G.main->name, filepath, sizeof(G.main->name));
1074         }
1075
1076         /* XXX temp solution to solve bug, real fix coming (ton) */
1077         G.main->recovered = 0;
1078         
1079         if (BLO_write_file(CTX_data_main(C), filepath, fileflags, reports, thumb)) {
1080                 const bool do_history = (G.background == false) && (CTX_wm_manager(C)->op_undo_depth == 0);
1081
1082                 if (!(fileflags & G_FILE_SAVE_COPY)) {
1083                         G.relbase_valid = 1;
1084                         BLI_strncpy(G.main->name, filepath, sizeof(G.main->name));  /* is guaranteed current file */
1085         
1086                         G.save_over = 1; /* disable untitled.blend convention */
1087                 }
1088
1089                 BKE_BIT_TEST_SET(G.fileflags, fileflags & G_FILE_COMPRESS, G_FILE_COMPRESS);
1090                 BKE_BIT_TEST_SET(G.fileflags, fileflags & G_FILE_AUTOPLAY, G_FILE_AUTOPLAY);
1091
1092                 /* prevent background mode scripts from clobbering history */
1093                 if (do_history) {
1094                         wm_history_file_update();
1095                 }
1096
1097                 BLI_callback_exec(G.main, NULL, BLI_CB_EVT_SAVE_POST);
1098
1099                 /* run this function after because the file cant be written before the blend is */
1100                 if (ibuf_thumb) {
1101                         IMB_thumb_delete(filepath, THB_FAIL); /* without this a failed thumb overrides */
1102                         ibuf_thumb = IMB_thumb_create(filepath, THB_LARGE, THB_SOURCE_BLEND, ibuf_thumb);
1103                 }
1104
1105                 ret = 0;  /* Success. */
1106         }
1107
1108         if (ibuf_thumb) {
1109                 IMB_freeImBuf(ibuf_thumb);
1110         }
1111         if (thumb && thumb != main_thumb) {
1112                 MEM_freeN(thumb);
1113         }
1114
1115         WM_cursor_wait(0);
1116
1117         return ret;
1118 }
1119
1120 /**
1121  * \see #wm_file_write wraps #BLO_write_file in a similar way.
1122  */
1123 int wm_homefile_write_exec(bContext *C, wmOperator *op)
1124 {
1125         wmWindowManager *wm = CTX_wm_manager(C);
1126         wmWindow *win = CTX_wm_window(C);
1127         char filepath[FILE_MAX];
1128         int fileflags;
1129
1130         BLI_callback_exec(G.main, NULL, BLI_CB_EVT_SAVE_PRE);
1131
1132         /* check current window and close it if temp */
1133         if (win && win->screen->temp)
1134                 wm_window_close(C, wm, win);
1135         
1136         /* update keymaps in user preferences */
1137         WM_keyconfig_update(wm);
1138         
1139         BLI_make_file_string("/", filepath, BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, NULL), BLENDER_STARTUP_FILE);
1140         printf("trying to save homefile at %s ", filepath);
1141         
1142         ED_editors_flush_edits(C, false);
1143
1144         /*  force save as regular blend file */
1145         fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_AUTOPLAY | G_FILE_HISTORY);
1146
1147         if (BLO_write_file(CTX_data_main(C), filepath, fileflags | G_FILE_USERPREFS, op->reports, NULL) == 0) {
1148                 printf("fail\n");
1149                 return OPERATOR_CANCELLED;
1150         }
1151         
1152         printf("ok\n");
1153
1154         G.save_over = 0;
1155
1156         BLI_callback_exec(G.main, NULL, BLI_CB_EVT_SAVE_POST);
1157
1158         return OPERATOR_FINISHED;
1159 }
1160
1161 /* Only save the prefs block. operator entry */
1162 int wm_userpref_write_exec(bContext *C, wmOperator *op)
1163 {
1164         wmWindowManager *wm = CTX_wm_manager(C);
1165         char filepath[FILE_MAX];
1166         
1167         /* update keymaps in user preferences */
1168         WM_keyconfig_update(wm);
1169         
1170         BLI_make_file_string("/", filepath, BKE_appdir_folder_id_create(BLENDER_USER_CONFIG, NULL), BLENDER_USERPREF_FILE);
1171         printf("trying to save userpref at %s ", filepath);
1172         
1173         if (BKE_write_file_userdef(filepath, op->reports) == 0) {
1174                 printf("fail\n");
1175                 return OPERATOR_CANCELLED;
1176         }
1177         
1178         printf("ok\n");
1179         
1180         return OPERATOR_FINISHED;
1181 }
1182
1183 /************************ autosave ****************************/
1184
1185 void wm_autosave_location(char *filepath)
1186 {
1187         const int pid = abs(getpid());
1188         char path[1024];
1189 #ifdef WIN32
1190         const char *savedir;
1191 #endif
1192
1193         if (G.main && G.relbase_valid) {
1194                 const char *basename = BLI_path_basename(G.main->name);
1195                 int len = strlen(basename) - 6;
1196                 BLI_snprintf(path, sizeof(path), "%.*s.blend", len, basename);
1197         }
1198         else {
1199                 BLI_snprintf(path, sizeof(path), "%d.blend", pid);
1200         }
1201
1202 #ifdef WIN32
1203         /* XXX Need to investigate how to handle default location of '/tmp/'
1204          * This is a relative directory on Windows, and it may be
1205          * found. Example:
1206          * Blender installed on D:\ drive, D:\ drive has D:\tmp\
1207          * Now, BLI_exists() will find '/tmp/' exists, but
1208          * BLI_make_file_string will create string that has it most likely on C:\
1209          * through get_default_root().
1210          * If there is no C:\tmp autosave fails. */
1211         if (!BLI_exists(BKE_tempdir_base())) {
1212                 savedir = BKE_appdir_folder_id_create(BLENDER_USER_AUTOSAVE, NULL);
1213                 BLI_make_file_string("/", filepath, savedir, path);
1214                 return;
1215         }
1216 #endif
1217
1218         BLI_make_file_string("/", filepath, BKE_tempdir_base(), path);
1219 }
1220
1221 void WM_autosave_init(wmWindowManager *wm)
1222 {
1223         wm_autosave_timer_ended(wm);
1224
1225         if (U.flag & USER_AUTOSAVE)
1226                 wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime * 60.0);
1227 }
1228
1229 void wm_autosave_timer(const bContext *C, wmWindowManager *wm, wmTimer *UNUSED(wt))
1230 {
1231         wmWindow *win;
1232         wmEventHandler *handler;
1233         char filepath[FILE_MAX];
1234         
1235         WM_event_remove_timer(wm, NULL, wm->autosavetimer);
1236
1237         /* if a modal operator is running, don't autosave, but try again in 10 seconds */
1238         for (win = wm->windows.first; win; win = win->next) {
1239                 for (handler = win->modalhandlers.first; handler; handler = handler->next) {
1240                         if (handler->op) {
1241                                 wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, 10.0);
1242                                 return;
1243                         }
1244                 }
1245         }
1246
1247         wm_autosave_location(filepath);
1248
1249         if (U.uiflag & USER_GLOBALUNDO) {
1250                 /* fast save of last undobuffer, now with UI */
1251                 BKE_undo_save_file(filepath);
1252         }
1253         else {
1254                 /*  save as regular blend file */
1255                 int fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_AUTOPLAY | G_FILE_HISTORY);
1256
1257                 ED_editors_flush_edits(C, false);
1258
1259                 /* no error reporting to console */
1260                 BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);
1261         }
1262         /* do timer after file write, just in case file write takes a long time */
1263         wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime * 60.0);
1264 }
1265
1266 void wm_autosave_timer_ended(wmWindowManager *wm)
1267 {
1268         if (wm->autosavetimer) {
1269                 WM_event_remove_timer(wm, NULL, wm->autosavetimer);
1270                 wm->autosavetimer = NULL;
1271         }
1272 }
1273
1274 void wm_autosave_delete(void)
1275 {
1276         char filename[FILE_MAX];
1277         
1278         wm_autosave_location(filename);
1279
1280         if (BLI_exists(filename)) {
1281                 char str[FILE_MAX];
1282                 BLI_make_file_string("/", str, BKE_tempdir_base(), BLENDER_QUIT_FILE);
1283
1284                 /* if global undo; remove tempsave, otherwise rename */
1285                 if (U.uiflag & USER_GLOBALUNDO) BLI_delete(filename, false, false);
1286                 else BLI_rename(filename, str);
1287         }
1288 }
1289
1290 void wm_autosave_read(bContext *C, ReportList *reports)
1291 {
1292         char filename[FILE_MAX];
1293
1294         wm_autosave_location(filename);
1295         WM_file_read(C, filename, reports);
1296 }
1297
1298
1299 /** \name Initialize WM_OT_open_xxx properties
1300  *
1301  * Check if load_ui was set by the caller.
1302  * Fall back to user preference when file flags not specified.
1303  *
1304  * \{ */
1305
1306 void wm_open_init_load_ui(wmOperator *op, bool use_prefs)
1307 {
1308         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "load_ui");
1309         if (!RNA_property_is_set(op->ptr, prop)) {
1310                 bool value = use_prefs ?
1311                              ((U.flag & USER_FILENOUI) == 0) :
1312                              ((G.fileflags & G_FILE_NO_UI) == 0);
1313
1314                 RNA_property_boolean_set(op->ptr, prop, value);
1315         }
1316 }
1317
1318 void wm_open_init_use_scripts(wmOperator *op, bool use_prefs)
1319 {
1320         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_scripts");
1321         if (!RNA_property_is_set(op->ptr, prop)) {
1322                 /* use G_SCRIPT_AUTOEXEC rather than the userpref because this means if
1323                  * the flag has been disabled from the command line, then opening
1324                  * from the menu wont enable this setting. */
1325                 bool value = use_prefs ?
1326                              ((U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0) :
1327                              ((G.f & G_SCRIPT_AUTOEXEC) != 0);
1328
1329                 RNA_property_boolean_set(op->ptr, prop, value);
1330         }
1331 }
1332
1333 /** \} */
1334
1335 void WM_file_tag_modified(const bContext *C)
1336 {
1337         wmWindowManager *wm = CTX_wm_manager(C);
1338         if (wm->file_saved) {
1339                 wm->file_saved = 0;
1340                 /* notifier that data changed, for save-over warning or header */
1341                 WM_event_add_notifier(C, NC_WM | ND_DATACHANGED, NULL);
1342         }
1343 }