]> de.git.xonotic.org Git - xonotic/netradiant.git/blob - radiant/main.cpp
386f7106c2dacbd8e5e5b7e88b1481052b3aa7c7
[xonotic/netradiant.git] / radiant / main.cpp
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 /*! \mainpage GtkRadiant Documentation Index
23
24    \section intro_sec Introduction
25
26    This documentation is generated from comments in the source code.
27
28    \section links_sec Useful Links
29
30    \link include/itextstream.h include/itextstream.h \endlink - Global output and error message streams, similar to std::cout and std::cerr. \n
31
32    FileInputStream - similar to std::ifstream (binary mode) \n
33    FileOutputStream - similar to std::ofstream (binary mode) \n
34    TextFileInputStream - similar to std::ifstream (text mode) \n
35    TextFileOutputStream - similar to std::ofstream (text mode) \n
36    StringOutputStream - similar to std::stringstream \n
37
38    \link string/string.h string/string.h \endlink - C-style string comparison and memory management. \n
39    \link os/path.h os/path.h \endlink - Path manipulation for radiant's standard path format \n
40    \link os/file.h os/file.h \endlink - OS file-system access. \n
41
42    ::CopiedString - automatic string memory management \n
43    Array - automatic array memory management \n
44    HashTable - generic hashtable, similar to std::hash_map \n
45
46    \link math/vector.h math/vector.h \endlink - Vectors \n
47    \link math/matrix.h math/matrix.h \endlink - Matrices \n
48    \link math/quaternion.h math/quaternion.h \endlink - Quaternions \n
49    \link math/plane.h math/plane.h \endlink - Planes \n
50    \link math/aabb.h math/aabb.h \endlink - AABBs \n
51
52    Callback MemberCaller0 FunctionCaller - callbacks similar to using boost::function with boost::bind \n
53    SmartPointer SmartReference - smart-pointer and smart-reference similar to Loki's SmartPtr \n
54
55    \link generic/bitfield.h generic/bitfield.h \endlink - Type-safe bitfield \n
56    \link generic/enumeration.h generic/enumeration.h \endlink - Type-safe enumeration \n
57
58    DefaultAllocator - Memory allocation using new/delete, compliant with std::allocator interface \n
59
60    \link debugging/debugging.h debugging/debugging.h \endlink - Debugging macros \n
61
62  */
63
64 #include "main.h"
65 #include "globaldefs.h"
66
67 #include "version.h"
68
69 #include "debugging/debugging.h"
70
71 #include "iundo.h"
72
73 #include "uilib/uilib.h"
74
75 #include "cmdlib.h"
76 #include "os/file.h"
77 #include "os/path.h"
78 #include "stream/stringstream.h"
79 #include "stream/textfilestream.h"
80
81 #include "gtkutil/messagebox.h"
82 #include "gtkutil/image.h"
83 #include "console.h"
84 #include "texwindow.h"
85 #include "map.h"
86 #include "mainframe.h"
87 #include "commands.h"
88 #include "preferences.h"
89 #include "environment.h"
90 #include "referencecache.h"
91 #include "stacktrace.h"
92
93 #if GDEF_OS_WINDOWS
94 #include <windows.h>
95 #endif
96
97 void show_splash();
98 void hide_splash();
99
100 void error_redirect( const gchar *domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data ){
101         gboolean in_recursion;
102         gboolean is_fatal;
103         char buf[256];
104
105         in_recursion = ( log_level & G_LOG_FLAG_RECURSION ) != 0;
106         is_fatal = ( log_level & G_LOG_FLAG_FATAL ) != 0;
107         log_level = (GLogLevelFlags) ( log_level & G_LOG_LEVEL_MASK );
108
109         if ( !message ) {
110                 message = "(0) message";
111         }
112
113         if ( domain ) {
114                 strcpy( buf, domain );
115         }
116         else{
117                 strcpy( buf, "**" );
118         }
119         strcat( buf, "-" );
120
121         switch ( log_level )
122         {
123         case G_LOG_LEVEL_ERROR:
124                 if ( in_recursion ) {
125                         strcat( buf, "ERROR (recursed) **: " );
126                 }
127                 else{
128                         strcat( buf, "ERROR **: " );
129                 }
130                 break;
131         case G_LOG_LEVEL_CRITICAL:
132                 if ( in_recursion ) {
133                         strcat( buf, "CRITICAL (recursed) **: " );
134                 }
135                 else{
136                         strcat( buf, "CRITICAL **: " );
137                 }
138                 break;
139         case G_LOG_LEVEL_WARNING:
140                 if ( in_recursion ) {
141                         strcat( buf, "WARNING (recursed) **: " );
142                 }
143                 else{
144                         strcat( buf, "WARNING **: " );
145                 }
146                 break;
147         case G_LOG_LEVEL_MESSAGE:
148                 if ( in_recursion ) {
149                         strcat( buf, "Message (recursed): " );
150                 }
151                 else{
152                         strcat( buf, "Message: " );
153                 }
154                 break;
155         case G_LOG_LEVEL_INFO:
156                 if ( in_recursion ) {
157                         strcat( buf, "INFO (recursed): " );
158                 }
159                 else{
160                         strcat( buf, "INFO: " );
161                 }
162                 break;
163         case G_LOG_LEVEL_DEBUG:
164                 if ( in_recursion ) {
165                         strcat( buf, "DEBUG (recursed): " );
166                 }
167                 else{
168                         strcat( buf, "DEBUG: " );
169                 }
170                 break;
171         default:
172                 /* we are used for a log level that is not defined by GLib itself,
173                  * try to make the best out of it.
174                  */
175                 if ( in_recursion ) {
176                         strcat( buf, "LOG (recursed:" );
177                 }
178                 else{
179                         strcat( buf, "LOG (" );
180                 }
181                 if ( log_level ) {
182                         gchar string[] = "0x00): ";
183                         gchar *p = string + 2;
184                         guint i;
185
186                         i = g_bit_nth_msf( log_level, -1 );
187                         *p = i >> 4;
188                         p++;
189                         *p = '0' + ( i & 0xf );
190                         if ( *p > '9' ) {
191                                 *p += 'A' - '9' - 1;
192                         }
193
194                         strcat( buf, string );
195                 }
196                 else{
197                         strcat( buf, "): " );
198                 }
199         }
200
201         strcat( buf, message );
202         if ( is_fatal ) {
203                 strcat( buf, "\naborting...\n" );
204         }
205         else{
206                 strcat( buf, "\n" );
207         }
208
209         // spam it...
210         globalErrorStream() << buf << "\n";
211
212         if (is_fatal) {
213             ERROR_MESSAGE( "GTK+ error: " << buf );
214     }
215 }
216
217 #if GDEF_COMPILER_MSVC && GDEF_DEBUG
218 #include "crtdbg.h"
219 #endif
220
221 void crt_init(){
222 #if GDEF_COMPILER_MSVC && GDEF_DEBUG
223         _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
224 #endif
225 }
226
227 class Lock
228 {
229 bool m_locked;
230 public:
231 Lock() : m_locked( false ){
232 }
233 void lock(){
234         m_locked = true;
235 }
236 void unlock(){
237         m_locked = false;
238 }
239 bool locked() const {
240         return m_locked;
241 }
242 };
243
244 class ScopedLock
245 {
246 Lock& m_lock;
247 public:
248 ScopedLock( Lock& lock ) : m_lock( lock ){
249         m_lock.lock();
250 }
251 ~ScopedLock(){
252         m_lock.unlock();
253 }
254 };
255
256 class LineLimitedTextOutputStream : public TextOutputStream
257 {
258 TextOutputStream& outputStream;
259 std::size_t count;
260 public:
261 LineLimitedTextOutputStream( TextOutputStream& outputStream, std::size_t count )
262         : outputStream( outputStream ), count( count ){
263 }
264 std::size_t write( const char* buffer, std::size_t length ){
265         if ( count != 0 ) {
266                 const char* p = buffer;
267                 const char* end = buffer + length;
268                 for (;; )
269                 {
270                         p = std::find( p, end, '\n' );
271                         if ( p == end ) {
272                                 break;
273                         }
274                         ++p;
275                         if ( --count == 0 ) {
276                                 length = p - buffer;
277                                 break;
278                         }
279                 }
280                 outputStream.write( buffer, length );
281         }
282         return length;
283 }
284 };
285
286 class PopupDebugMessageHandler : public DebugMessageHandler
287 {
288 StringOutputStream m_buffer;
289 Lock m_lock;
290 public:
291 TextOutputStream& getOutputStream(){
292         if ( !m_lock.locked() ) {
293                 return m_buffer;
294         }
295         return globalErrorStream();
296 }
297 bool handleMessage(){
298         getOutputStream() << "----------------\n";
299         LineLimitedTextOutputStream outputStream( getOutputStream(), 24 );
300         write_stack_trace( outputStream );
301         getOutputStream() << "----------------\n";
302         globalErrorStream() << m_buffer.c_str();
303         if ( !m_lock.locked() ) {
304                 ScopedLock lock( m_lock );
305         if (GDEF_DEBUG) {
306             m_buffer << "Break into the debugger?\n";
307             bool handled = ui::alert(ui::root, m_buffer.c_str(), RADIANT_NAME " - Runtime Error", ui::alert_type::YESNO, ui::alert_icon::Error) == ui::alert_response::NO;
308             m_buffer.clear();
309             return handled;
310         } else {
311             m_buffer << "Please report this error to the developers\n";
312             ui::alert(ui::root, m_buffer.c_str(), RADIANT_NAME " - Runtime Error", ui::alert_type::OK, ui::alert_icon::Error);
313             m_buffer.clear();
314         }
315         }
316         return true;
317 }
318 };
319
320 typedef Static<PopupDebugMessageHandler> GlobalPopupDebugMessageHandler;
321
322 void streams_init(){
323         GlobalErrorStream::instance().setOutputStream( getSysPrintErrorStream() );
324         GlobalOutputStream::instance().setOutputStream( getSysPrintOutputStream() );
325 }
326
327 void paths_init(){
328         g_strSettingsPath = environment_get_home_path();
329
330         Q_mkdir( g_strSettingsPath.c_str() );
331
332         g_strAppPath = environment_get_app_path();
333         g_strLibPath = environment_get_lib_path();
334         g_strDataPath = environment_get_data_path();
335
336         // radiant is installed in the parent dir of "tools/"
337         // NOTE: this is not very easy for debugging
338         // maybe add options to lookup in several places?
339         // (for now I had to create symlinks)
340         {
341                 StringOutputStream path( 256 );
342                 path << g_strDataPath.c_str() << "bitmaps/";
343                 BitmapsPath_set( path.c_str() );
344         }
345
346         // we will set this right after the game selection is done
347         g_strGameToolsPath = g_strDataPath;
348 }
349
350 bool check_version_file( const char* filename, const char* version ){
351         TextFileInputStream file( filename );
352         if ( !file.failed() ) {
353                 char buf[10];
354                 buf[file.read( buf, 9 )] = '\0';
355
356                 // chomp it (the hard way)
357                 int chomp = 0;
358                 while ( buf[chomp] >= '0' && buf[chomp] <= '9' )
359                         chomp++;
360                 buf[chomp] = '\0';
361
362                 return string_equal( buf, version );
363         }
364         return false;
365 }
366
367 void create_global_pid(){
368         /*!
369            the global prefs loading / game selection dialog might fail for any reason we don't know about
370            we need to catch when it happens, to cleanup the stateful prefs which might be killing it
371            and to turn on console logging for lookup of the problem
372            this is the first part of the two step .pid system
373            http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=297
374          */
375         StringOutputStream g_pidFile( 256 ); ///< the global .pid file (only for global part of the startup)
376
377         g_pidFile << SettingsPath_get() << "radiant.pid";
378
379         FILE *pid;
380         pid = fopen( g_pidFile.c_str(), "r" );
381         if ( pid != 0 ) {
382                 fclose( pid );
383
384                 if ( remove( g_pidFile.c_str() ) == -1 ) {
385                         StringOutputStream msg( 256 );
386                         msg << "WARNING: Could not delete " << g_pidFile.c_str();
387                         ui::alert( ui::root, msg.c_str(), RADIANT_NAME, ui::alert_type::OK, ui::alert_icon::Error );
388                 }
389
390                 // in debug, never prompt to clean registry, turn console logging auto after a failed start
391                 if (!GDEF_DEBUG) {
392                         StringOutputStream msg(256);
393                         msg << RADIANT_NAME " failed to start properly the last time it was run.\n"
394                                         "The failure may be related to current global preferences.\n"
395                                         "Do you want to reset global preferences to defaults?";
396
397                         if (ui::alert(ui::root, msg.c_str(), RADIANT_NAME " - Startup Failure", ui::alert_type::YESNO, ui::alert_icon::Question) == ui::alert_response::YES) {
398                                 g_GamesDialog.Reset();
399                         }
400
401                         msg.clear();
402                         msg << "Logging console output to " << SettingsPath_get()
403                                 << "radiant.log\nRefer to the log if " RADIANT_NAME " fails to start again.";
404
405                         ui::alert(ui::root, msg.c_str(), RADIANT_NAME " - Console Log", ui::alert_type::OK);
406                 }
407
408                 // set without saving, the class is not in a coherent state yet
409                 // just do the value change and call to start logging, CGamesDialog will pickup when relevant
410                 g_GamesDialog.m_bForceLogConsole = true;
411                 Sys_LogFile( true );
412         }
413
414         // create a primary .pid for global init run
415         pid = fopen( g_pidFile.c_str(), "w" );
416         if ( pid ) {
417                 fclose( pid );
418         }
419 }
420
421 void remove_global_pid(){
422         StringOutputStream g_pidFile( 256 );
423         g_pidFile << SettingsPath_get() << "radiant.pid";
424
425         // close the primary
426         if ( remove( g_pidFile.c_str() ) == -1 ) {
427                 StringOutputStream msg( 256 );
428                 msg << "WARNING: Could not delete " << g_pidFile.c_str();
429                 ui::alert( ui::root, msg.c_str(), RADIANT_NAME, ui::alert_type::OK, ui::alert_icon::Error );
430         }
431 }
432
433 /*!
434    now the secondary game dependant .pid file
435    http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=297
436  */
437 void create_local_pid(){
438         StringOutputStream g_pidGameFile( 256 ); ///< the game-specific .pid file
439         g_pidGameFile << SettingsPath_get() << g_pGameDescription->mGameFile.c_str() << "/radiant-game.pid";
440
441         FILE *pid = fopen( g_pidGameFile.c_str(), "r" );
442         if ( pid != 0 ) {
443                 fclose( pid );
444                 if ( remove( g_pidGameFile.c_str() ) == -1 ) {
445                         StringOutputStream msg;
446                         msg << "WARNING: Could not delete " << g_pidGameFile.c_str();
447                         ui::alert( ui::root, msg.c_str(), RADIANT_NAME, ui::alert_type::OK, ui::alert_icon::Error );
448                 }
449
450                 // in debug, never prompt to clean registry, turn console logging auto after a failed start
451                 if (!GDEF_DEBUG) {
452                         StringOutputStream msg;
453                         msg << RADIANT_NAME " failed to start properly the last time it was run.\n"
454                                         "The failure may be caused by current preferences.\n"
455                                         "Do you want to reset all preferences to defaults?";
456
457                         if (ui::alert(ui::root, msg.c_str(), RADIANT_NAME " - Startup Failure", ui::alert_type::YESNO, ui::alert_icon::Question) == ui::alert_response::YES) {
458                                 Preferences_Reset();
459                         }
460
461                         msg.clear();
462                         msg << "Logging console output to " << SettingsPath_get()
463                                 << "radiant.log\nRefer to the log if " RADIANT_NAME " fails to start again.";
464
465                         ui::alert(ui::root, msg.c_str(), RADIANT_NAME " - Console Log", ui::alert_type::OK);
466                 }
467
468                 // force console logging on! (will go in prefs too)
469                 g_GamesDialog.m_bForceLogConsole = true;
470                 Sys_LogFile( true );
471         }
472         else
473         {
474                 // create one, will remove right after entering message loop
475                 pid = fopen( g_pidGameFile.c_str(), "w" );
476                 if ( pid ) {
477                         fclose( pid );
478                 }
479         }
480 }
481
482
483 /*!
484    now the secondary game dependant .pid file
485    http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=297
486  */
487 void remove_local_pid(){
488         StringOutputStream g_pidGameFile( 256 );
489         g_pidGameFile << SettingsPath_get() << g_pGameDescription->mGameFile.c_str() << "/radiant-game.pid";
490         remove( g_pidGameFile.c_str() );
491 }
492
493 void user_shortcuts_init(){
494         StringOutputStream path( 256 );
495         path << SettingsPath_get() << g_pGameDescription->mGameFile.c_str() << '/';
496         LoadCommandMap( path.c_str() );
497         SaveCommandMap( path.c_str() );
498 }
499
500 void user_shortcuts_save(){
501         StringOutputStream path( 256 );
502         path << SettingsPath_get() << g_pGameDescription->mGameFile.c_str() << '/';
503         SaveCommandMap( path.c_str() );
504 }
505
506 int main( int argc, char* argv[] ){
507         crt_init();
508
509         streams_init();
510
511 #if GDEF_OS_WINDOWS
512         HMODULE lib;
513         lib = LoadLibrary( "dwmapi.dll" );
514         if ( lib != 0 ) {
515                 void ( WINAPI *qDwmEnableComposition )( bool bEnable ) = ( void (WINAPI *) ( bool bEnable ) )GetProcAddress( lib, "DwmEnableComposition" );
516                 if ( qDwmEnableComposition ) {
517                         qDwmEnableComposition( FALSE );
518                 }
519                 FreeLibrary( lib );
520         }
521 #endif
522
523         const char* mapname = NULL;
524     char const *error = NULL;
525         if ( !ui::init( &argc, &argv, "<filename.map>", &error) ) {
526                 g_print( "%s\n", error );
527                 return -1;
528         }
529
530         // Gtk already removed parsed `--options`
531         if (argc == 2) {
532                 if ( strlen( argv[1] ) > 1 ) {
533                         if ( g_str_has_suffix( argv[1], ".map" ) ) {
534                                 if ( g_path_is_absolute( argv[1] ) ) {
535                                         mapname = argv[1];
536                                 }
537                                 else {
538                                         mapname = g_build_filename( g_get_current_dir(), argv[1], NULL );
539                                 }
540                         }
541                         else {
542                                 g_print( "bad file name, will not load: %s\n", argv[1] );
543                         }
544                 }
545         }
546         else if (argc > 2) {
547                 g_print ( "%s\n", "too many arguments" );
548                 return -1;
549         }
550
551         // redirect Gtk warnings to the console
552         g_log_set_handler( "Gdk", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
553                                                                                                 G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION ), error_redirect, 0 );
554         g_log_set_handler( "Gtk", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
555                                                                                                 G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION ), error_redirect, 0 );
556         g_log_set_handler( "GtkGLExt", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
557                                                                                                          G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION ), error_redirect, 0 );
558         g_log_set_handler( "GLib", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
559                                                                                                  G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION ), error_redirect, 0 );
560         g_log_set_handler( 0, (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
561                                                                                         G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION ), error_redirect, 0 );
562
563         GlobalDebugMessageHandler::instance().setHandler( GlobalPopupDebugMessageHandler::instance() );
564
565         environment_init(argc, (char const **) argv);
566
567         paths_init();
568
569         show_splash();
570
571         create_global_pid();
572
573         GlobalPreferences_Init();
574
575         g_GamesDialog.Init();
576
577         g_strGameToolsPath = g_pGameDescription->mGameToolsPath;
578
579         remove_global_pid();
580
581         g_Preferences.Init(); // must occur before create_local_pid() to allow preferences to be reset
582
583         create_local_pid();
584
585         // in a very particular post-.pid startup
586         // we may have the console turned on and want to keep it that way
587         // so we use a latching system
588         if ( g_GamesDialog.m_bForceLogConsole ) {
589                 Sys_LogFile( true );
590                 g_Console_enableLogging = true;
591                 g_GamesDialog.m_bForceLogConsole = false;
592         }
593
594
595         Radiant_Initialise();
596
597         user_shortcuts_init();
598
599         g_pParentWnd = 0;
600         g_pParentWnd = new MainFrame();
601
602         hide_splash();
603
604         if ( mapname != NULL ) {
605                 Map_LoadFile( mapname );
606         }
607         else if ( g_bLoadLastMap && !g_strLastMap.empty() ) {
608                 Map_LoadFile( g_strLastMap.c_str() );
609         }
610         else
611         {
612                 Map_New();
613         }
614
615         // load up shaders now that we have the map loaded
616         // eviltypeguy
617         TextureBrowser_ShowStartupShaders( GlobalTextureBrowser() );
618
619
620         remove_local_pid();
621
622         ui::main();
623
624         // avoid saving prefs when the app is minimized
625         if ( g_pParentWnd->IsSleeping() ) {
626                 globalOutputStream() << "Shutdown while sleeping, not saving prefs\n";
627                 g_preferences_globals.disable_ini = true;
628         }
629
630         Map_Free();
631
632         if ( !Map_Unnamed( g_map ) ) {
633                 g_strLastMap = Map_Name( g_map );
634         }
635
636         delete g_pParentWnd;
637
638         user_shortcuts_save();
639
640         Radiant_Shutdown();
641
642         // close the log file if any
643         Sys_LogFile( false );
644
645         return EXIT_SUCCESS;
646 }