source/blender/blenkernel/intern/blender.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 /** \file blender/blenkernel/intern/blender.c
  31  *  \ingroup bke
  32  */
  33
  34
  35 #ifndef _WIN32
  36         #include <unistd.h> // for read close
  37 #else
  38         #include <io.h> // for open close read
  39         #define open _open
  40         #define read _read
  41         #define close _close
  42         #define write _write
  43 #endif
  44
  45 #include <stdlib.h>
  46 #include <stdio.h>
  47 #include <stddef.h>
  48 #include <string.h>
  49 #include <fcntl.h> // for open
  50
  51 #include "MEM_guardedalloc.h"
  52
  53 #include "DNA_userdef_types.h"
  54 #include "DNA_scene_types.h"
  55 #include "DNA_screen_types.h"
  56 #include "DNA_sequence_types.h"
  57 #include "DNA_sound_types.h"
  58
  59 #include "BLI_blenlib.h"
  60 #include "BLI_bpath.h"
  61 #include "BLI_dynstr.h"
  62 #include "BLI_path_util.h"
  63 #include "BLI_utildefines.h"
  64 #include "BLI_callbacks.h"
  65
  66 #include "IMB_imbuf.h"
  67
  68 #include "BKE_blender.h"
  69 #include "BKE_context.h"
  70 #include "BKE_depsgraph.h"
  71 #include "BKE_displist.h"
  72 #include "BKE_global.h"
  73 #include "BKE_idprop.h"
  74 #include "BKE_ipo.h"
  75 #include "BKE_library.h"
  76 #include "BKE_main.h"
  77 #include "BKE_node.h"
  78 #include "BKE_report.h"
  79 #include "BKE_scene.h"
  80 #include "BKE_screen.h"
  81 #include "BKE_sequencer.h"
  82 #include "BKE_sound.h"
  83
  84
  85 #include "BLO_undofile.h"
  86 #include "BLO_readfile.h"
  87 #include "BLO_writefile.h"
  88
  89 #include "BKE_utildefines.h"
  90
  91 #include "RNA_access.h"
  92
  93 #include "WM_api.h" // XXXXX BAD, very BAD dependency (bad level call) - remove asap, elubie
  94
  95 Global G;
  96 UserDef U;
  97 /* ListBase = {NULL, NULL}; */
  98
  99 char versionstr[48]= "";
 100
 101 /* ********** free ********** */
 102
 103 /* only to be called on exit blender */
 104 void free_blender(void)
 105 {
 106         /* samples are in a global list..., also sets G.main->sound->sample NULL */
 107         free_main(G.main);
 108         G.main= NULL;
 109
 110         BKE_spacetypes_free();          /* after free main, it uses space callbacks */
 111
 112         IMB_exit();
 113
 114         BLI_cb_finalize();
 115
 116         seq_stripelem_cache_destruct();
 117
 118         free_nodesystem();
 119 }
 120
 121 void initglobals(void)
 122 {
 123         memset(&G, 0, sizeof(Global));
 124
 125         U.savetime= 1;
 126
 127         G.main= MEM_callocN(sizeof(Main), "initglobals");
 128
 129         strcpy(G.ima, "//");
 130
 131         if(BLENDER_SUBVERSION)
 132                 BLI_snprintf(versionstr, sizeof(versionstr), "blender.org %d.%d", BLENDER_VERSION, BLENDER_SUBVERSION);
 133         else
 134                 BLI_snprintf(versionstr, sizeof(versionstr), "blender.org %d", BLENDER_VERSION);
 135
 136 #ifdef _WIN32   // FULLSCREEN
 137         G.windowstate = G_WINDOWSTATE_USERDEF;
 138 #endif
 139
 140         G.charstart = 0x0000;
 141         G.charmin = 0x0000;
 142         G.charmax = 0xffff;
 143
 144 #ifndef WITH_PYTHON_SECURITY /* default */
 145         G.f |= G_SCRIPT_AUTOEXEC;
 146 #else
 147         G.f &= ~G_SCRIPT_AUTOEXEC;
 148 #endif
 149 }
 150
 151 /***/
 152
 153 static void clear_global(void)
 154 {
 155 //      extern short winqueue_break;    /* screen.c */
 156
 157         free_main(G.main);                      /* free all lib data */
 158
 159 //      free_vertexpaint();
 160
 161         G.main= NULL;
 162 }
 163
 164 /* make sure path names are correct for OS */
 165 static void clean_paths(Main *main)
 166 {
 167         struct BPathIterator *bpi;
 168         char filepath_expanded[1024];
 169         Scene *scene;
 170
 171         for(BLI_bpathIterator_init(&bpi, main, main->name, BPATH_USE_PACKED); !BLI_bpathIterator_isDone(bpi); BLI_bpathIterator_step(bpi)) {
 172                 BLI_bpathIterator_getPath(bpi, filepath_expanded);
 173
 174                 BLI_clean(filepath_expanded);
 175
 176                 BLI_bpathIterator_setPath(bpi, filepath_expanded);
 177         }
 178
 179         BLI_bpathIterator_free(bpi);
 180
 181         for(scene= main->scene.first; scene; scene= scene->id.next) {
 182                 BLI_clean(scene->r.pic);
 183         }
 184 }
 185
 186 /* context matching */
 187 /* handle no-ui case */
 188
 189 /* note, this is called on Undo so any slow conversion functions here
 190  * should be avoided or check (mode!='u') */
 191
 192 static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath)
 193 {
 194         bScreen *curscreen= NULL;
 195         Scene *curscene= NULL;
 196         int recover;
 197         char mode;
 198
 199         /* 'u' = undo save, 'n' = no UI load */
 200         if(bfd->main->screen.first==NULL) mode= 'u';
 201         else if(G.fileflags & G_FILE_NO_UI) mode= 'n';
 202         else mode= 0;
 203
 204         recover= (G.fileflags & G_FILE_RECOVER);
 205
 206         /* Only make filepaths compatible when loading for real (not undo) */
 207         if(mode != 'u') {
 208                 clean_paths(bfd->main);
 209         }
 210
 211         /* XXX here the complex windowmanager matching */
 212
 213         /* no load screens? */
 214         if(mode) {
 215                 /* comes from readfile.c */
 216                 extern void lib_link_screen_restore(Main *, bScreen *, Scene *);
 217
 218                 SWAP(ListBase, G.main->wm, bfd->main->wm);
 219                 SWAP(ListBase, G.main->screen, bfd->main->screen);
 220                 SWAP(ListBase, G.main->script, bfd->main->script);
 221
 222                 /* we re-use current screen */
 223                 curscreen= CTX_wm_screen(C);
 224                 /* but use new Scene pointer */
 225                 curscene= bfd->curscene;
 226                 if(curscene==NULL) curscene= bfd->main->scene.first;
 227                 /* and we enforce curscene to be in current screen */
 228                 if(curscreen) curscreen->scene= curscene; /* can run in bgmode */
 229
 230                 /* clear_global will free G.main, here we can still restore pointers */
 231                 lib_link_screen_restore(bfd->main, curscreen, curscene);
 232         }
 233
 234         /* free G.main Main database */
 235 //      CTX_wm_manager_set(C, NULL);
 236         clear_global();
 237
 238         /* clear old property update cache, in case some old references are left dangling */
 239         RNA_property_update_cache_free();
 240
 241         G.main= bfd->main;
 242
 243         CTX_data_main_set(C, G.main);
 244
 245         sound_init_main(G.main);
 246
 247         if (bfd->user) {
 248
 249                 /* only here free userdef themes... */
 250                 BKE_userdef_free();
 251
 252                 U= *bfd->user;
 253                 MEM_freeN(bfd->user);
 254         }
 255
 256         /* case G_FILE_NO_UI or no screens in file */
 257         if(mode) {
 258                 /* leave entire context further unaltered? */
 259                 CTX_data_scene_set(C, curscene);
 260         }
 261         else {
 262                 G.winpos= bfd->winpos;
 263                 G.displaymode= bfd->displaymode;
 264                 G.fileflags= bfd->fileflags;
 265                 CTX_wm_manager_set(C, bfd->main->wm.first);
 266                 CTX_wm_screen_set(C, bfd->curscreen);
 267                 CTX_data_scene_set(C, bfd->curscreen->scene);
 268                 CTX_wm_area_set(C, NULL);
 269                 CTX_wm_region_set(C, NULL);
 270                 CTX_wm_menu_set(C, NULL);
 271         }
 272
 273         /* this can happen when active scene was lib-linked, and doesnt exist anymore */
 274         if(CTX_data_scene(C)==NULL) {
 275                 CTX_data_scene_set(C, bfd->main->scene.first);
 276                 CTX_wm_screen(C)->scene= CTX_data_scene(C);
 277                 curscene= CTX_data_scene(C);
 278         }
 279
 280         /* special cases, override loaded flags: */
 281         if(G.f != bfd->globalf) {
 282                 const int flags_keep= (G_DEBUG | G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
 283                 bfd->globalf= (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
 284         }
 285
 286
 287         G.f= bfd->globalf;
 288
 289         if (!G.background) {
 290                 //setscreen(G.curscreen);
 291         }
 292
 293         // FIXME: this version patching should really be part of the file-reading code,
 294         // but we still get too many unrelated data-corruption crashes otherwise...
 295         if (G.main->versionfile < 250)
 296                 do_versions_ipos_to_animato(G.main);
 297
 298         if(recover && bfd->filename[0] && G.relbase_valid) {
 299                 /* in case of autosave or quit.blend, use original filename instead
 300                  * use relbase_valid to make sure the file is saved, else we get <memory2> in the filename */
 301                 filepath= bfd->filename;
 302         }
 303 #if 0
 304         else if (!G.relbase_valid) {
 305                 /* otherwise, use an empty string as filename, rather than <memory2> */
 306                 filepath="";
 307         }
 308 #endif
 309
 310         /* these are the same at times, should never copy to the same location */
 311         if(G.main->name != filepath)
 312                 BLI_strncpy(G.main->name, filepath, FILE_MAX);
 313
 314         /* baseflags, groups, make depsgraph, etc */
 315         set_scene_bg(G.main, CTX_data_scene(C));
 316
 317         MEM_freeN(bfd);
 318
 319         (void)curscene; /* quiet warning */
 320 }
 321
 322 static int handle_subversion_warning(Main *main, ReportList *reports)
 323 {
 324         if(main->minversionfile > BLENDER_VERSION ||
 325            (main->minversionfile == BLENDER_VERSION &&
 326                  main->minsubversionfile > BLENDER_SUBVERSION)) {
 327                 BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary: %d.%d , expect loss of data!", main->minversionfile, main->minsubversionfile);
 328         }
 329
 330         return 1;
 331 }
 332
 333 static void keymap_item_free(wmKeyMapItem *kmi)
 334 {
 335         if(kmi->properties) {
 336                 IDP_FreeProperty(kmi->properties);
 337                 MEM_freeN(kmi->properties);
 338         }
 339         if(kmi->ptr)
 340                 MEM_freeN(kmi->ptr);
 341 }
 342
 343 void BKE_userdef_free(void)
 344 {
 345         wmKeyMap *km;
 346         wmKeyMapItem *kmi;
 347         wmKeyMapDiffItem *kmdi;
 348
 349         for(km=U.user_keymaps.first; km; km=km->next) {
 350                 for(kmdi=km->diff_items.first; kmdi; kmdi=kmdi->next) {
 351                         if(kmdi->add_item) {
 352                                 keymap_item_free(kmdi->add_item);
 353                                 MEM_freeN(kmdi->add_item);
 354                         }
 355                         if(kmdi->remove_item) {
 356                                 keymap_item_free(kmdi->remove_item);
 357                                 MEM_freeN(kmdi->remove_item);
 358                         }
 359                 }
 360
 361                 for(kmi=km->items.first; kmi; kmi=kmi->next)
 362                         keymap_item_free(kmi);
 363
 364                 BLI_freelistN(&km->diff_items);
 365                 BLI_freelistN(&km->items);
 366         }
 367
 368         BLI_freelistN(&U.uistyles);
 369         BLI_freelistN(&U.uifonts);
 370         BLI_freelistN(&U.themes);
 371         BLI_freelistN(&U.user_keymaps);
 372         BLI_freelistN(&U.addons);
 373 }
 374
 375 int BKE_read_file(bContext *C, const char *filepath, ReportList *reports)
 376 {
 377         BlendFileData *bfd;
 378         int retval= BKE_READ_FILE_OK;
 379
 380         if(strstr(filepath, BLENDER_STARTUP_FILE)==NULL) /* dont print user-pref loading */
 381                 printf("read blend: %s\n", filepath);
 382
 383         bfd= BLO_read_from_file(filepath, reports);
 384         if (bfd) {
 385                 if(bfd->user) retval= BKE_READ_FILE_OK_USERPREFS;
 386
 387                 if(0==handle_subversion_warning(bfd->main, reports)) {
 388                         free_main(bfd->main);
 389                         MEM_freeN(bfd);
 390                         bfd= NULL;
 391                         retval= BKE_READ_FILE_FAIL;
 392                 }
 393                 else
 394                         setup_app_data(C, bfd, filepath); // frees BFD
 395         }
 396         else
 397                 BKE_reports_prependf(reports, "Loading %s failed: ", filepath);
 398
 399         return (bfd?retval:BKE_READ_FILE_FAIL);
 400 }
 401
 402 int BKE_read_file_from_memory(bContext *C, char* filebuf, int filelength, ReportList *reports)
 403 {
 404         BlendFileData *bfd;
 405
 406         bfd= BLO_read_from_memory(filebuf, filelength, reports);
 407         if (bfd)
 408                 setup_app_data(C, bfd, "<memory2>");
 409         else
 410                 BKE_reports_prepend(reports, "Loading failed: ");
 411
 412         return (bfd?1:0);
 413 }
 414
 415 /* memfile is the undo buffer */
 416 int BKE_read_file_from_memfile(bContext *C, MemFile *memfile, ReportList *reports)
 417 {
 418         BlendFileData *bfd;
 419
 420         bfd= BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports);
 421         if (bfd)
 422                 setup_app_data(C, bfd, "<memory1>");
 423         else
 424                 BKE_reports_prepend(reports, "Loading failed: ");
 425
 426         return (bfd?1:0);
 427 }
 428
 429
 430 /* *****************  testing for break ************* */
 431
 432 static void (*blender_test_break_cb)(void)= NULL;
 433
 434 void set_blender_test_break_cb(void (*func)(void) )
 435 {
 436         blender_test_break_cb= func;
 437 }
 438
 439
 440 int blender_test_break(void)
 441 {
 442         if (!G.background) {
 443                 if (blender_test_break_cb)
 444                         blender_test_break_cb();
 445         }
 446
 447         return (G.afbreek==1);
 448 }
 449
 450
 451 /* ***************** GLOBAL UNDO *************** */
 452
 453 #define UNDO_DISK       0
 454
 455 #define MAXUNDONAME     64
 456 typedef struct UndoElem {
 457         struct UndoElem *next, *prev;
 458         char str[FILE_MAXDIR+FILE_MAXFILE];
 459         char name[MAXUNDONAME];
 460         MemFile memfile;
 461         uintptr_t undosize;
 462 } UndoElem;
 463
 464 static ListBase undobase={NULL, NULL};
 465 static UndoElem *curundo= NULL;
 466
 467
 468 static int read_undosave(bContext *C, UndoElem *uel)
 469 {
 470         char mainstr[sizeof(G.main->name)];
 471         int success=0, fileflags;
 472
 473         /* This is needed so undoing/redoing doesnt crash with threaded previews going */
 474         WM_jobs_stop_all(CTX_wm_manager(C));
 475
 476         BLI_strncpy(mainstr, G.main->name, sizeof(mainstr));    /* temporal store */
 477
 478         fileflags= G.fileflags;
 479         G.fileflags |= G_FILE_NO_UI;
 480
 481         if(UNDO_DISK)
 482                 success= (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL);
 483         else
 484                 success= BKE_read_file_from_memfile(C, &uel->memfile, NULL);
 485
 486         /* restore */
 487         BLI_strncpy(G.main->name, mainstr, sizeof(G.main->name)); /* restore */
 488         G.fileflags= fileflags;
 489
 490         if(success) {
 491                 /* important not to update time here, else non keyed tranforms are lost */
 492                 DAG_on_visible_update(G.main, FALSE);
 493         }
 494
 495         return success;
 496 }
 497
 498 /* name can be a dynamic string */
 499 void BKE_write_undo(bContext *C, const char *name)
 500 {
 501         uintptr_t maxmem, totmem, memused;
 502         int nr /*, success */ /* UNUSED */;
 503         UndoElem *uel;
 504
 505         if( (U.uiflag & USER_GLOBALUNDO)==0) return;
 506         if( U.undosteps==0) return;
 507
 508         /* remove all undos after (also when curundo==NULL) */
 509         while(undobase.last != curundo) {
 510                 uel= undobase.last;
 511                 BLI_remlink(&undobase, uel);
 512                 BLO_free_memfile(&uel->memfile);
 513                 MEM_freeN(uel);
 514         }
 515
 516         /* make new */
 517         curundo= uel= MEM_callocN(sizeof(UndoElem), "undo file");
 518         BLI_strncpy(uel->name, name, sizeof(uel->name));
 519         BLI_addtail(&undobase, uel);
 520
 521         /* and limit amount to the maximum */
 522         nr= 0;
 523         uel= undobase.last;
 524         while(uel) {
 525                 nr++;
 526                 if(nr==U.undosteps) break;
 527                 uel= uel->prev;
 528         }
 529         if(uel) {
 530                 while(undobase.first!=uel) {
 531                         UndoElem *first= undobase.first;
 532                         BLI_remlink(&undobase, first);
 533                         /* the merge is because of compression */
 534                         BLO_merge_memfile(&first->memfile, &first->next->memfile);
 535                         MEM_freeN(first);
 536                 }
 537         }
 538
 539
 540         /* disk save version */
 541         if(UNDO_DISK) {
 542                 static int counter= 0;
 543                 char filepath[FILE_MAXDIR+FILE_MAXFILE];
 544                 char numstr[32];
 545                 int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */
 546
 547                 /* calculate current filepath */
 548                 counter++;
 549                 counter= counter % U.undosteps;
 550
 551                 BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter);
 552                 BLI_make_file_string("/", filepath, BLI_temporary_dir(), numstr);
 553
 554                 /* success= */ /* UNUSED */ BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);
 555
 556                 BLI_strncpy(curundo->str, filepath, sizeof(curundo->str));
 557         }
 558         else {
 559                 MemFile *prevfile=NULL;
 560
 561                 if(curundo->prev) prevfile= &(curundo->prev->memfile);
 562
 563                 memused= MEM_get_memory_in_use();
 564                 /* success= */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags);
 565                 curundo->undosize= MEM_get_memory_in_use() - memused;
 566         }
 567
 568         if(U.undomemory != 0) {
 569                 /* limit to maximum memory (afterwards, we can't know in advance) */
 570                 totmem= 0;
 571                 maxmem= ((uintptr_t)U.undomemory)*1024*1024;
 572
 573                 /* keep at least two (original + other) */
 574                 uel= undobase.last;
 575                 while(uel && uel->prev) {
 576                         totmem+= uel->undosize;
 577                         if(totmem>maxmem) break;
 578                         uel= uel->prev;
 579                 }
 580
 581                 if(uel) {
 582                         if(uel->prev && uel->prev->prev)
 583                                 uel= uel->prev;
 584
 585                         while(undobase.first!=uel) {
 586                                 UndoElem *first= undobase.first;
 587                                 BLI_remlink(&undobase, first);
 588                                 /* the merge is because of compression */
 589                                 BLO_merge_memfile(&first->memfile, &first->next->memfile);
 590                                 MEM_freeN(first);
 591                         }
 592                 }
 593         }
 594 }
 595
 596 /* 1= an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
 597 void BKE_undo_step(bContext *C, int step)
 598 {
 599
 600         if(step==0) {
 601                 read_undosave(C, curundo);
 602         }
 603         else if(step==1) {
 604                 /* curundo should never be NULL, after restart or load file it should call undo_save */
 605                 if(curundo==NULL || curundo->prev==NULL) ; // XXX error("No undo available");
 606                 else {
 607                         if(G.f & G_DEBUG) printf("undo %s\n", curundo->name);
 608                         curundo= curundo->prev;
 609                         read_undosave(C, curundo);
 610                 }
 611         }
 612         else {
 613
 614                 /* curundo has to remain current situation! */
 615
 616                 if(curundo==NULL || curundo->next==NULL) ; // XXX error("No redo available");
 617                 else {
 618                         read_undosave(C, curundo->next);
 619                         curundo= curundo->next;
 620                         if(G.f & G_DEBUG) printf("redo %s\n", curundo->name);
 621                 }
 622         }
 623 }
 624
 625 void BKE_reset_undo(void)
 626 {
 627         UndoElem *uel;
 628
 629         uel= undobase.first;
 630         while(uel) {
 631                 BLO_free_memfile(&uel->memfile);
 632                 uel= uel->next;
 633         }
 634
 635         BLI_freelistN(&undobase);
 636         curundo= NULL;
 637 }
 638
 639 /* based on index nr it does a restore */
 640 void BKE_undo_number(bContext *C, int nr)
 641 {
 642         curundo= BLI_findlink(&undobase, nr);
 643         BKE_undo_step(C, 0);
 644 }
 645
 646 /* go back to the last occurance of name in stack */
 647 void BKE_undo_name(bContext *C, const char *name)
 648 {
 649         UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
 650
 651         if(uel && uel->prev) {
 652                 curundo= uel->prev;
 653                 BKE_undo_step(C, 0);
 654         }
 655 }
 656
 657 /* name optional */
 658 int BKE_undo_valid(const char *name)
 659 {
 660         if(name) {
 661                 UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
 662                 return uel && uel->prev;
 663         }
 664
 665         return undobase.last != undobase.first;
 666 }
 667
 668 /* get name of undo item, return null if no item with this index */
 669 /* if active pointer, set it to 1 if true */
 670 char *BKE_undo_get_name(int nr, int *active)
 671 {
 672         UndoElem *uel= BLI_findlink(&undobase, nr);
 673
 674         if(active) *active= 0;
 675
 676         if(uel) {
 677                 if(active && uel==curundo)
 678                         *active= 1;
 679                 return uel->name;
 680         }
 681         return NULL;
 682 }
 683
 684 char *BKE_undo_menu_string(void)
 685 {
 686         UndoElem *uel;
 687         DynStr *ds= BLI_dynstr_new();
 688         char *menu;
 689
 690         BLI_dynstr_append(ds, "Global Undo History %t");
 691
 692         for(uel= undobase.first; uel; uel= uel->next) {
 693                 BLI_dynstr_append(ds, "|");
 694                 BLI_dynstr_append(ds, uel->name);
 695         }
 696
 697         menu= BLI_dynstr_get_cstring(ds);
 698         BLI_dynstr_free(ds);
 699
 700         return menu;
 701 }
 702
 703         /* saves quit.blend */
 704 void BKE_undo_save_quit(void)
 705 {
 706         UndoElem *uel;
 707         MemFileChunk *chunk;
 708         int file;
 709         char str[FILE_MAXDIR+FILE_MAXFILE];
 710
 711         if( (U.uiflag & USER_GLOBALUNDO)==0) return;
 712
 713         uel= curundo;
 714         if(uel==NULL) {
 715                 printf("No undo buffer to save recovery file\n");
 716                 return;
 717         }
 718
 719         /* no undo state to save */
 720         if(undobase.first==undobase.last) return;
 721
 722         BLI_make_file_string("/", str, BLI_temporary_dir(), "quit.blend");
 723
 724         file = open(str,O_BINARY+O_WRONLY+O_CREAT+O_TRUNC, 0666);
 725         if(file == -1) {
 726                 //XXX error("Unable to save %s, check you have permissions", str);
 727                 return;
 728         }
 729
 730         chunk= uel->memfile.chunks.first;
 731         while(chunk) {
 732                 if( write(file, chunk->buf, chunk->size) != chunk->size) break;
 733                 chunk= chunk->next;
 734         }
 735
 736         close(file);
 737
 738         if(chunk) ; //XXX error("Unable to save %s, internal error", str);
 739         else printf("Saved session recovery to %s\n", str);
 740 }
 741
 742 /* sets curscene */
 743 Main *BKE_undo_get_main(Scene **scene)
 744 {
 745         Main *mainp= NULL;
 746         BlendFileData *bfd= BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL);
 747
 748         if(bfd) {
 749                 mainp= bfd->main;
 750                 if(scene)
 751                         *scene= bfd->curscene;
 752
 753                 MEM_freeN(bfd);
 754         }
 755
 756         return mainp;
 757 }
 758