source/blender/windowmanager/intern/wm_init_exit.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) 2007 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  *
  24  * Contributor(s): Blender Foundation
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 /** \file blender/windowmanager/intern/wm_init_exit.c
  30  *  \ingroup wm
  31  */
  32
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37
  38 #include "MEM_guardedalloc.h"
  39 #include "MEM_CacheLimiterC-Api.h"
  40
  41 #include "IMB_imbuf_types.h"
  42 #include "IMB_imbuf.h"
  43
  44 #include "DNA_object_types.h"
  45 #include "DNA_scene_types.h"
  46 #include "DNA_userdef_types.h"
  47 #include "DNA_windowmanager_types.h"
  48
  49 #include "BKE_blender.h"
  50 #include "BKE_context.h"
  51 #include "BKE_screen.h"
  52 #include "BKE_curve.h"
  53 #include "BKE_displist.h"
  54 #include "BKE_DerivedMesh.h"
  55 #include "BKE_font.h"
  56 #include "BKE_global.h"
  57 #include "BKE_library.h"
  58 #include "BKE_main.h"
  59 #include "BKE_mball.h"
  60 #include "BKE_report.h"
  61
  62 #include "BKE_packedFile.h"
  63 #include "BKE_sequencer.h" /* free seq clipboard */
  64 #include "BKE_material.h" /* clear_matcopybuf */
  65
  66 #include "BLI_blenlib.h"
  67 #include "BLI_winstuff.h"
  68
  69 #include "RE_pipeline.h"                /* RE_ free stuff */
  70
  71 #ifdef WITH_PYTHON
  72 #include "BPY_extern.h"
  73 #endif
  74
  75 #ifdef WITH_GAMEENGINE
  76 #include "BL_System.h"
  77 #endif
  78 #include "GHOST_Path-api.h"
  79 #include "GHOST_C-api.h"
  80
  81 #include "RNA_define.h"
  82
  83 #include "WM_api.h"
  84 #include "WM_types.h"
  85
  86 #include "wm_cursors.h"
  87 #include "wm_event_system.h"
  88 #include "wm.h"
  89 #include "wm_files.h"
  90 #include "wm_window.h"
  91
  92 #include "ED_armature.h"
  93 #include "ED_keyframing.h"
  94 #include "ED_node.h"
  95 #include "ED_render.h"
  96 #include "ED_space_api.h"
  97 #include "ED_screen.h"
  98 #include "ED_util.h"
  99
 100 #include "UI_interface.h"
 101 #include "BLF_api.h"
 102
 103 #include "GPU_buffers.h"
 104 #include "GPU_extensions.h"
 105 #include "GPU_draw.h"
 106
 107 #include "BKE_depsgraph.h"
 108 #include "BKE_sound.h"
 109
 110 static void wm_init_reports(bContext *C)
 111 {
 112         BKE_reports_init(CTX_wm_reports(C), RPT_STORE);
 113 }
 114 static void wm_free_reports(bContext *C)
 115 {
 116         BKE_reports_clear(CTX_wm_reports(C));
 117 }
 118
 119 int wm_start_with_console = 0;
 120
 121 /* only called once, for startup */
 122 void WM_init(bContext *C, int argc, const char **argv)
 123 {
 124         if (!G.background) {
 125                 wm_ghost_init(C);       /* note: it assigns C to ghost! */
 126                 wm_init_cursor_data();
 127         }
 128         GHOST_CreateSystemPaths();
 129         wm_operatortype_init();
 130
 131         set_free_windowmanager_cb(wm_close_and_free);   /* library.c */
 132         set_blender_test_break_cb(wm_window_testbreak); /* blender.c */
 133         DAG_editors_update_cb(ED_render_id_flush_update); /* depsgraph.c */
 134
 135         ED_spacetypes_init();   /* editors/space_api/spacetype.c */
 136
 137         ED_file_init();                 /* for fsmenu */
 138         ED_init_node_butfuncs();
 139
 140         BLF_init(11, U.dpi); /* Please update source/gamengine/GamePlayer/GPG_ghost.cpp if you change this */
 141         BLF_lang_init();
 142         /* get the default database, plus a wm */
 143         WM_read_homefile(C, NULL, G.factory_startup);
 144
 145         /* note: there is a bug where python needs initializing before loading the
 146          * startup.blend because it may contain PyDrivers. It also needs to be after
 147          * initializing space types and other internal data.
 148          *
 149          * However cant redo this at the moment. Solution is to load python
 150          * before WM_read_homefile() or make py-drivers check if python is running.
 151          * Will try fix when the crash can be repeated. - campbell. */
 152
 153 #ifdef WITH_PYTHON
 154         BPY_context_set(C); /* necessary evil */
 155         BPY_python_start(argc, argv);
 156
 157         BPY_driver_reset();
 158         BPY_app_handlers_reset();
 159         BPY_modules_load_user(C);
 160 #else
 161         (void)argc; /* unused */
 162         (void)argv; /* unused */
 163 #endif
 164
 165         if (!G.background && !wm_start_with_console)
 166                 GHOST_toggleConsole(3);
 167
 168         wm_init_reports(C); /* reports cant be initialized before the wm */
 169
 170         if (!G.background) {
 171                 GPU_extensions_init();
 172                 GPU_set_mipmap(!(U.gameflags & USER_DISABLE_MIPMAP));
 173                 GPU_set_anisotropic(U.anisotropic_filter);
 174
 175                 UI_init();
 176         }
 177
 178         clear_matcopybuf();
 179         ED_render_clear_mtex_copybuf();
 180
 181         //      glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 182
 183         ED_preview_init_dbase();
 184
 185         G.ndofdevice = -1;      /* XXX bad initializer, needs set otherwise buttons show! */
 186
 187         WM_read_history();
 188
 189         /* allow a path of "", this is what happens when making a new file */
 190         /*
 191         if(G.main->name[0] == 0)
 192                 BLI_make_file_string("/", G.main->name, BLI_getDefaultDocumentFolder(), "untitled.blend");
 193         */
 194
 195         BLI_strncpy(G.lib, G.main->name, FILE_MAX);
 196 }
 197
 198 void WM_init_splash(bContext *C)
 199 {
 200         if((U.uiflag & USER_SPLASH_DISABLE) == 0) {
 201                 wmWindowManager *wm= CTX_wm_manager(C);
 202                 wmWindow *prevwin= CTX_wm_window(C);
 203
 204                 if(wm->windows.first) {
 205                         CTX_wm_window_set(C, wm->windows.first);
 206                         WM_operator_name_call(C, "WM_OT_splash", WM_OP_INVOKE_DEFAULT, NULL);
 207                         CTX_wm_window_set(C, prevwin);
 208                 }
 209         }
 210 }
 211
 212 static ScrArea *biggest_view3d(bContext *C)
 213 {
 214         bScreen *sc= CTX_wm_screen(C);
 215         ScrArea *sa, *big= NULL;
 216         int size, maxsize= 0;
 217
 218         for(sa= sc->areabase.first; sa; sa= sa->next) {
 219                 if(sa->spacetype==SPACE_VIEW3D) {
 220                         size= sa->winx * sa->winy;
 221                         if(size > maxsize) {
 222                                 maxsize= size;
 223                                 big= sa;
 224                         }
 225                 }
 226         }
 227         return big;
 228 }
 229
 230 int WM_init_game(bContext *C)
 231 {
 232         wmWindowManager *wm= CTX_wm_manager(C);
 233         wmWindow* win;
 234
 235         ScrArea *sa;
 236         ARegion *ar= NULL;
 237
 238         Scene *scene= CTX_data_scene(C);
 239
 240         if (!scene) {
 241                 // XXX, this should not be needed.
 242                 Main *bmain = CTX_data_main(C);
 243                 scene= bmain->scene.first;
 244         }
 245
 246         win = wm->windows.first;
 247
 248         //first to get a valid window
 249         if(win)
 250                 CTX_wm_window_set(C, win);
 251
 252         sa = biggest_view3d(C);
 253         ar= BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
 254
 255         // if we have a valid 3D view
 256         if (sa && ar) {
 257                 ARegion *arhide;
 258
 259                 CTX_wm_area_set(C, sa);
 260                 CTX_wm_region_set(C, ar);
 261
 262                 /* disable quad view */
 263                 if(ar->alignment == RGN_ALIGN_QSPLIT)
 264                         WM_operator_name_call(C, "SCREEN_OT_region_quadview", WM_OP_EXEC_DEFAULT, NULL);
 265
 266                 /* toolbox, properties panel and header are hidden */
 267                 for(arhide=sa->regionbase.first; arhide; arhide=arhide->next) {
 268                         if(arhide->regiontype != RGN_TYPE_WINDOW) {
 269                                 if(!(arhide->flag & RGN_FLAG_HIDDEN)) {
 270                                         ED_region_toggle_hidden(C, arhide);
 271                                 }
 272                         }
 273                 }
 274
 275                 /* full screen the area */
 276                 if(!sa->full) {
 277                         ED_screen_full_toggle(C, win, sa);
 278                 }
 279
 280                 /* Fullscreen */
 281                 if(scene->gm.fullscreen) {
 282                         WM_operator_name_call(C, "WM_OT_window_fullscreen_toggle", WM_OP_EXEC_DEFAULT, NULL);
 283                         wm_get_screensize(&ar->winrct.xmax, &ar->winrct.ymax);
 284                         ar->winx = ar->winrct.xmax + 1;
 285                         ar->winy = ar->winrct.ymax + 1;
 286                 }
 287                 else
 288                 {
 289                         GHOST_RectangleHandle rect = GHOST_GetClientBounds(win->ghostwin);
 290                         ar->winrct.ymax = GHOST_GetHeightRectangle(rect);
 291                         ar->winrct.xmax = GHOST_GetWidthRectangle(rect);
 292                         ar->winx = ar->winrct.xmax + 1;
 293                         ar->winy = ar->winrct.ymax + 1;
 294                         GHOST_DisposeRectangle(rect);
 295                 }
 296
 297                 WM_operator_name_call(C, "VIEW3D_OT_game_start", WM_OP_EXEC_DEFAULT, NULL);
 298
 299                 return 1;
 300         }
 301         else
 302         {
 303                 ReportTimerInfo *rti;
 304
 305                 BKE_report(&wm->reports, RPT_ERROR, "No valid 3D View found. Game auto start is not possible.");
 306
 307                 /* After adding the report to the global list, reset the report timer. */
 308                 WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
 309
 310                 /* Records time since last report was added */
 311                 wm->reports.reporttimer = WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.02);
 312
 313                 rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");
 314                 wm->reports.reporttimer->customdata = rti;
 315         }
 316         return 0;
 317 }
 318
 319 /* free strings of open recent files */
 320 static void free_openrecent(void)
 321 {
 322         struct RecentFile *recent;
 323
 324         for(recent = G.recent_files.first; recent; recent=recent->next)
 325                 MEM_freeN(recent->filepath);
 326
 327         BLI_freelistN(&(G.recent_files));
 328 }
 329
 330
 331 /* bad stuff*/
 332
 333 extern wchar_t *copybuf;
 334 extern wchar_t *copybufinfo;
 335
 336         // XXX copy/paste buffer stuff...
 337 extern void free_anim_copybuf(void);
 338 extern void free_anim_drivers_copybuf(void);
 339 extern void free_fmodifiers_copybuf(void);
 340 extern void free_posebuf(void);
 341
 342 /* called in creator.c even... tsk, split this! */
 343 void WM_exit(bContext *C)
 344 {
 345         wmWindow *win;
 346
 347         sound_exit();
 348
 349
 350         /* first wrap up running stuff, we assume only the active WM is running */
 351         /* modal handlers are on window level freed, others too? */
 352         /* note; same code copied in wm_files.c */
 353         if(C && CTX_wm_manager(C)) {
 354
 355                 WM_jobs_stop_all(CTX_wm_manager(C));
 356
 357                 for(win= CTX_wm_manager(C)->windows.first; win; win= win->next) {
 358
 359                         CTX_wm_window_set(C, win);      /* needed by operator close callbacks */
 360                         WM_event_remove_handlers(C, &win->handlers);
 361                         WM_event_remove_handlers(C, &win->modalhandlers);
 362                         ED_screen_exit(C, win, win->screen);
 363                 }
 364         }
 365         wm_operatortype_free();
 366         wm_dropbox_free();
 367         WM_menutype_free();
 368
 369         /* all non-screen and non-space stuff editors did, like editmode */
 370         if(C)
 371                 ED_editors_exit(C);
 372
 373 //      XXX
 374 //      BIF_GlobalReebFree();
 375 //      BIF_freeRetarget();
 376         BIF_freeTemplates(C);
 377
 378         free_ttfont(); /* bke_font.h */
 379
 380         free_openrecent();
 381
 382         BKE_freecubetable();
 383
 384         ED_preview_free_dbase();        /* frees a Main dbase, before free_blender! */
 385
 386         if(C && CTX_wm_manager(C))
 387                 wm_free_reports(C);                     /* before free_blender! - since the ListBases get freed there */
 388
 389         seq_free_clipboard(); /* sequencer.c */
 390
 391         free_blender();                         /* blender.c, does entire library and spacetypes */
 392 //      free_matcopybuf();
 393         free_anim_copybuf();
 394         free_anim_drivers_copybuf();
 395         free_fmodifiers_copybuf();
 396         free_posebuf();
 397
 398         BLF_exit();
 399
 400         ANIM_keyingset_infos_exit();
 401
 402         RE_FreeAllRender();
 403         RE_engines_exit();
 404
 405 //      free_txt_data();
 406
 407
 408 #ifdef WITH_PYTHON
 409         /* XXX - old note */
 410         /* before free_blender so py's gc happens while library still exists */
 411         /* needed at least for a rare sigsegv that can happen in pydrivers */
 412
 413         /* Update for blender 2.5, move after free_blender because blender now holds references to PyObject's
 414          * so decref'ing them after python ends causes bad problems every time
 415          * the pyDriver bug can be fixed if it happens again we can deal with it then */
 416         BPY_python_end();
 417 #endif
 418
 419         GPU_buffer_pool_free(NULL);
 420         GPU_free_unused_buffers();
 421         GPU_extensions_exit();
 422
 423 //      if (copybuf) MEM_freeN(copybuf);
 424 //      if (copybufinfo) MEM_freeN(copybufinfo);
 425         if (!G.background) {
 426                 BKE_undo_save_quit();   // saves quit.blend if global undo is on
 427         }
 428         BKE_reset_undo();
 429
 430         ED_file_exit(); /* for fsmenu */
 431
 432         UI_exit();
 433         BKE_userdef_free();
 434
 435         RNA_exit(); /* should be after BPY_python_end so struct python slots are cleared */
 436
 437         wm_ghost_exit();
 438
 439         CTX_free(C);
 440 #ifdef WITH_GAMEENGINE
 441         SYS_DeleteSystem(SYS_GetSystem());
 442 #endif
 443
 444         GHOST_DisposeSystemPaths();
 445
 446         if(MEM_get_memory_blocks_in_use()!=0) {
 447                 printf("Error: Not freed memory blocks: %d\n", MEM_get_memory_blocks_in_use());
 448                 MEM_printmemlist();
 449         }
 450         wm_autosave_delete();
 451
 452         printf("\nBlender quit\n");
 453
 454 #ifdef WIN32
 455         /* ask user to press enter when in debug mode */
 456         if(G.f & G_DEBUG) {
 457                 printf("press enter key to exit...\n\n");
 458                 getchar();
 459         }
 460 #endif
 461         exit(G.afbreek==1);
 462 }
 463