]> git.xonotic.org Git - xonotic/netradiant.git/blob - radiant/main.cpp
fix warning: format not a string literal and no format arguments
[xonotic/netradiant.git] / radiant / main.cpp
1 /*
2    Copyright (C) 1999-2007 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 #if defined ( __linux__ ) || defined ( __APPLE__ )
23   #include <gdk/gdkx.h>
24   #include <pwd.h>
25   #include <unistd.h>
26   #ifdef __linux__
27         #include <mntent.h>
28   #endif
29   #include <dirent.h>
30   #include <pthread.h>
31   #include <sys/wait.h>
32   #include <signal.h>
33   #include <sys/stat.h>
34 #endif
35
36 #include <gtk/gtk.h>
37 #include <gtk/gtkgl.h>
38 #include <glib/gi18n.h>
39 #include "stdafx.h"
40 #include <assert.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43
44 #include <stdlib.h>
45
46 #include "watchbsp.h"
47 #include "filters.h"
48 #include "glwidget.h"
49
50 bool g_bBuildList = false;
51 int g_argc;
52 char** g_argv;
53
54 // =============================================================================
55 // Splash screen
56
57 // get rid of it when debugging
58 #if defined ( _DEBUG )
59   #define SKIP_SPLASH
60 #endif
61
62 static GtkWidget *splash_screen;
63
64 // called based on a timer, or in particular cases when we don't want to keep it around
65 gint try_destroy_splash( gpointer data ){
66         if ( splash_screen ) {
67                 gtk_widget_destroy( splash_screen );
68                 splash_screen = NULL;
69         }
70         return FALSE;
71 }
72
73 static void create_splash(){
74         GtkWidget *alert_frame, *alert_frame1, *pixmap;
75
76         splash_screen = gtk_window_new( GTK_WINDOW_POPUP );
77         gtk_window_position( GTK_WINDOW( splash_screen ), GTK_WIN_POS_CENTER );
78         gtk_widget_realize( splash_screen );
79
80         alert_frame1 = gtk_frame_new( NULL );
81         gtk_widget_show( alert_frame1 );
82         gtk_container_add( GTK_CONTAINER( splash_screen ), alert_frame1 );
83         gtk_frame_set_shadow_type( GTK_FRAME( alert_frame1 ), GTK_SHADOW_OUT );
84
85         alert_frame = gtk_frame_new( NULL );
86         gtk_widget_show( alert_frame );
87
88         gtk_container_add( GTK_CONTAINER( alert_frame1 ), alert_frame );
89         gtk_frame_set_shadow_type( GTK_FRAME( alert_frame ), GTK_SHADOW_IN );
90         gtk_container_border_width( GTK_CONTAINER( alert_frame ), 3 );
91
92         pixmap = gtk_preview_new( GTK_PREVIEW_COLOR );
93         gtk_widget_show( pixmap );
94         gtk_container_add( GTK_CONTAINER( alert_frame ), pixmap );
95
96         CString str;
97         guint16 width, height;
98         unsigned char *buf;
99
100         str = g_strGameToolsPath;
101         str += "bitmaps/splash.bmp";
102
103         unsigned char* load_bitmap_file( const char* filename, guint16* width, guint16* height );
104         buf = load_bitmap_file( str.GetBuffer(), &width, &height );
105
106         if ( !buf ) {
107                 str = g_strBitmapsPath;
108                 str += "splash.bmp";
109
110                 buf = load_bitmap_file( str.GetBuffer(), &width, &height );
111         }
112
113         if ( buf ) {
114                 GtkPreview *preview = GTK_PREVIEW( pixmap );
115                 gtk_preview_size( preview, width, height );
116                 for ( int y = 0; y < height; y++ )
117                         gtk_preview_draw_row( preview, buf + y * width * 3, 0, y, width );
118         }
119
120         gtk_widget_show_all( splash_screen );
121
122         while ( gtk_events_pending() )
123                 gtk_main_iteration();
124 }
125
126 // =============================================================================
127 // Loki stuff
128
129 #if defined ( __linux__ ) || defined ( __APPLE__ )
130
131 /* A short game name, could be used as argv[0] */
132 static char game_name[100] = "";
133
134 /* The directory where the data files can be found (run directory) */
135 static char datapath[PATH_MAX];
136
137 char *loki_gethomedir( void ){
138         char *home = NULL;
139
140         home = getenv( "HOME" );
141         if ( home == NULL ) {
142                 uid_t id = getuid();
143                 struct passwd *pwd;
144
145                 setpwent();
146                 while ( ( pwd = getpwent() ) != NULL )
147                 {
148                         if ( pwd->pw_uid == id ) {
149                                 home = pwd->pw_dir;
150                                 break;
151                         }
152                 }
153                 endpwent();
154         }
155         return home;
156 }
157
158 /* Must be called BEFORE loki_initialize */
159 void loki_setgamename( const char *n ){
160         strncpy( game_name, n, sizeof( game_name ) );
161 }
162
163   #ifdef __linux__
164 /* Code to determine the mount point of a CD-ROM */
165 int loki_getmountpoint( const char *device, char *mntpt, int max_size ){
166         char devpath[PATH_MAX], mntdevpath[PATH_MAX];
167         FILE * mountfp;
168         struct mntent *mntent;
169         int mounted;
170
171         /* Nothing to do with no device file */
172         if ( device == NULL ) {
173                 *mntpt = '\0';
174                 return -1;
175         }
176
177         /* Get the fully qualified path of the CD-ROM device */
178         if ( realpath( device, devpath ) == NULL ) {
179                 perror( "realpath() on your CD-ROM failed" );
180                 return( -1 );
181         }
182
183         /* Get the mount point */
184         mounted = -1;
185         memset( mntpt, 0, max_size );
186         mountfp = setmntent( _PATH_MNTTAB, "r" );
187         if ( mountfp != NULL ) {
188                 mounted = 0;
189                 while ( ( mntent = getmntent( mountfp ) ) != NULL )
190                 {
191                         char *tmp, mntdev[1024];
192
193                         strcpy( mntdev, mntent->mnt_fsname );
194                         if ( strcmp( mntent->mnt_type, "supermount" ) == 0 ) {
195                                 tmp = strstr( mntent->mnt_opts, "dev=" );
196                                 if ( tmp ) {
197                                         strcpy( mntdev, tmp + strlen( "dev=" ) );
198                                         tmp = strchr( mntdev, ',' );
199                                         if ( tmp ) {
200                                                 *tmp = '\0';
201                                         }
202                                 }
203                         }
204                         if ( strncmp( mntdev, "/dev", 4 ) ||
205                                  realpath( mntdev, mntdevpath ) == NULL ) {
206                                 continue;
207                         }
208                         if ( strcmp( mntdevpath, devpath ) == 0 ) {
209                                 mounted = 1;
210                                 assert( (int)strlen( mntent->mnt_dir ) < max_size );
211                                 strncpy( mntpt, mntent->mnt_dir, max_size - 1 );
212                                 mntpt[max_size - 1] = '\0';
213                                 break;
214                         }
215                 }
216                 endmntent( mountfp );
217         }
218         return( mounted );
219 }
220   #endif
221
222 /*
223     This function gets the directory containing the running program.
224     argv0 - the 0'th argument to the program
225  */
226 // FIXME TTimo
227 // I don't understand this function. It looks like something cut from another piece of software
228 // we somehow get the g_strAppPath from it, but it's done through a weird scan across $PATH env. var.
229 // even worse, it doesn't behave the same in all cases .. works well when ran through gdb and borks when ran from a shell
230 void loki_initpaths( char *argv0 ){
231         char temppath[PATH_MAX]; //, env[100];
232         char *home; //, *ptr, *data_env;
233
234         home = loki_gethomedir();
235         if ( home == NULL ) {
236                 home = ".";
237         }
238
239         if ( *game_name == 0 ) { /* Game name defaults to argv[0] */
240                 loki_setgamename( argv0 );
241         }
242
243         strcpy( temppath, argv0 ); /* If this overflows, it's your own fault :) */
244         if ( !strrchr( temppath, '/' ) ) {
245                 char *path;
246                 char *last;
247                 int found;
248
249                 found = 0;
250                 path = getenv( "PATH" );
251                 do
252                 {
253                         /* Initialize our filename variable */
254                         temppath[0] = '\0';
255
256                         /* Get next entry from path variable */
257                         last = strchr( path, ':' );
258                         if ( !last ) {
259                                 last = path + strlen( path );
260                         }
261
262                         /* Perform tilde expansion */
263                         if ( *path == '~' ) {
264                                 strcpy( temppath, home );
265                                 ++path;
266                         }
267
268                         /* Fill in the rest of the filename */
269                         if ( last > ( path + 1 ) ) {
270                                 strncat( temppath, path, ( last - path ) );
271                                 strcat( temppath, "/" );
272                         }
273                         strcat( temppath, "./" );
274                         strcat( temppath, argv0 );
275
276                         /* See if it exists, and update path */
277                         if ( access( temppath, X_OK ) == 0 ) {
278                                 ++found;
279                         }
280                         path = last + 1;
281
282                 } while ( *last && !found );
283
284         }
285         else
286         {
287                 /* Increment argv0 to the basename */
288                 argv0 = strrchr( argv0, '/' ) + 1;
289         }
290
291         /* Now canonicalize it to a full pathname for the data path */
292         if ( realpath( temppath, datapath ) ) {
293                 /* There should always be '/' in the path */
294                 *( strrchr( datapath, '/' ) ) = '\0';
295         }
296 }
297
298 char *loki_getdatapath( void ){
299         return( datapath );
300 }
301
302 #endif
303
304 // end of Loki stuff
305 // =============================================================================
306
307 void error_redirect( const gchar *domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data ){
308         gboolean in_recursion;
309         gboolean is_fatal;
310         char buf[256];
311
312         in_recursion = ( log_level & G_LOG_FLAG_RECURSION ) != 0;
313         is_fatal = ( log_level & G_LOG_FLAG_FATAL ) != 0;
314         log_level = (GLogLevelFlags) ( log_level & G_LOG_LEVEL_MASK );
315
316         if ( !message ) {
317                 message = "(NULL) message";
318         }
319
320         if ( domain ) {
321                 strcpy( buf, domain );
322         }
323         else{
324                 strcpy( buf, "**" );
325         }
326         strcat( buf, "-" );
327
328         switch ( log_level )
329         {
330         case G_LOG_LEVEL_ERROR:
331                 if ( in_recursion ) {
332                         strcat( buf, "ERROR (recursed) **: " );
333                 }
334                 else{
335                         strcat( buf, "ERROR **: " );
336                 }
337                 break;
338         case G_LOG_LEVEL_CRITICAL:
339                 if ( in_recursion ) {
340                         strcat( buf, "CRITICAL (recursed) **: " );
341                 }
342                 else{
343                         strcat( buf, "CRITICAL **: " );
344                 }
345                 break;
346         case G_LOG_LEVEL_WARNING:
347                 if ( in_recursion ) {
348                         strcat( buf, "WARNING (recursed) **: " );
349                 }
350                 else{
351                         strcat( buf, "WARNING **: " );
352                 }
353                 break;
354         case G_LOG_LEVEL_MESSAGE:
355                 if ( in_recursion ) {
356                         strcat( buf, "Message (recursed): " );
357                 }
358                 else{
359                         strcat( buf, "Message: " );
360                 }
361                 break;
362         case G_LOG_LEVEL_INFO:
363                 if ( in_recursion ) {
364                         strcat( buf, "INFO (recursed): " );
365                 }
366                 else{
367                         strcat( buf, "INFO: " );
368                 }
369                 break;
370         case G_LOG_LEVEL_DEBUG:
371                 if ( in_recursion ) {
372                         strcat( buf, "DEBUG (recursed): " );
373                 }
374                 else{
375                         strcat( buf, "DEBUG: " );
376                 }
377                 break;
378         default:
379                 /* we are used for a log level that is not defined by GLib itself,
380                  * try to make the best out of it.
381                  */
382                 if ( in_recursion ) {
383                         strcat( buf, "LOG (recursed:" );
384                 }
385                 else{
386                         strcat( buf, "LOG (" );
387                 }
388                 if ( log_level ) {
389                         gchar string[] = "0x00): ";
390                         gchar *p = string + 2;
391                         guint i;
392
393                         i = g_bit_nth_msf( log_level, -1 );
394                         *p = i >> 4;
395                         p++;
396                         *p = '0' + ( i & 0xf );
397                         if ( *p > '9' ) {
398                                 *p += 'A' - '9' - 1;
399                         }
400
401                         strcat( buf, string );
402                 }
403                 else{
404                         strcat( buf, "): " );
405                 }
406         }
407
408         strcat( buf, message );
409         if ( is_fatal ) {
410                 strcat( buf, "\naborting...\n" );
411         }
412         else{
413                 strcat( buf, "\n" );
414         }
415
416         printf( "%s\n", buf );
417         Sys_FPrintf( SYS_WRN, buf );
418         // TTimo NOTE: in some cases it may be handy to log only to the file
419 //  Sys_FPrintf (SYS_NOCON, buf);
420 }
421
422 #define GETTEXT_PACKAGE "radiant"
423 #define LOCALEDIR "lang"
424
425 int main( int argc, char* argv[] ) {
426         char *libgl, *ptr;
427         int i, j, k;
428
429
430         /*
431            Rambetter on Sat Nov 13, 2010:
432
433            The following line fixes parsing and writing of floating point numbers in locales such as
434            Italy, Germany, and others outside of en_US.  In particular, in such problem locales, users
435            are not able to use certain map entities such as "light" because the definitions of these entities
436            in the entity definition files contain floating point values written in the standard "C" format
437            (containing a dot instead of, for example, a comma).  The call sscanf() is all over the code,
438            including parsing entity definition files and reading Radiant preferences.  sscanf() is sensitive
439            to locale (in particular when reading floating point numbers).
440
441            The line below is the minimalistic way to address only this particular problem - the parsing
442            and writing of floating point values.  There may be other yet-undiscovered bugs related to
443            locale still lingering in the code.  When such bugs are discovered, they should be addressed by
444            setting more than just "LC_NUMERIC=C" (for example LC_CTYPE for regular expression matching)
445            or by fixing the problem in the actual code instead of fiddling with LC_* variables.
446
447            Another way to fix the floating point format problem is to locate all calls such as *scanf()
448            and *printf() in the code and replace them with other functions.  However, we're also using
449            external libraries such as libxml and [maybe?] they use locale to parse their numeric values.
450            I'm just saying, it may get ugly if we try to fix the problem without setting LC_NUMERIC.
451
452            Usage of sscanf() throughout the code looks like so:
453             sscanf(str, "%f %f %f", &val1, &val2, &val3);
454            Code like this exists in many files, here are 4 examples:
455             tools/quake3/q3map2/light.c
456             tools/quake3/q3map2/model.c
457             radiant/preferences.cpp
458             plugins/entity/miscmodel.cpp
459
460            Also affected are printf() calls when using formats that contain "%f".
461
462            I did some research and putenv() seems to be the best choice for being cross-platform.  It
463            used to be a function in Windows (now deprecated):
464             http://msdn.microsoft.com/en-us/library/ms235321(VS.80).aspx
465            And of course it's defined in UNIX.
466
467            One more thing.  the gtk_init() call below modifies all of the locale settings.  In fact if it
468            weren't for gtk_init(), we wouldn't have to set LC_NUMERIC (parsing of floating points with
469            a dot works just fine before the gtk_init() call on a sample Linux system).  If we were to
470            just setlocale() here, it would get clobbered by gtk_init().  So instead of using setlocale()
471            _after_ gtk_init(), I chose to fix this problem via environment variable.  I think it's cleaner
472            that way.
473          */
474         putenv( "LC_NUMERIC=C" );
475
476 #ifdef _WIN32
477         libgl = "opengl32.dll";
478 #endif
479
480 #if defined ( __linux__ )
481         libgl = "libGL.so.1";
482 #endif
483
484 #ifdef __APPLE__
485         libgl = "/usr/X11R6/lib/libGL.1.dylib";
486 #endif
487
488 #if defined ( __linux__ ) || defined ( __APPLE__ )
489         // Give away unnecessary root privileges.
490         // Important: must be done before calling gtk_init().
491         char *loginname;
492         struct passwd *pw;
493         seteuid( getuid() );
494         if ( geteuid() == 0 && ( loginname = getlogin() ) != NULL && ( pw = getpwnam( loginname ) ) != NULL ) {
495                 setuid( pw->pw_uid );
496         }
497 #endif
498
499
500         bindtextdomain( GETTEXT_PACKAGE, LOCALEDIR );
501         bind_textdomain_codeset( GETTEXT_PACKAGE, "UTF-8" );
502         textdomain( GETTEXT_PACKAGE );
503 //  gtk_disable_setlocale();
504
505         gtk_init( &argc, &argv );
506         gtk_gl_init( &argc, &argv );
507         gdk_gl_init( &argc, &argv );
508
509         // TODO: Find a better place to call this.
510         gtk_glwidget_create_font();
511
512         if ( ( ptr = getenv( "Q3R_LIBGL" ) ) != NULL ) {
513                 libgl = ptr;
514         }
515
516         for ( i = 1; i < argc; i++ )
517         {
518                 char* param = argv[i];
519
520                 if ( param[0] == '-' && param[1] == '-' ) {
521                         param += 2;
522
523                         if ( ( strcmp( param, "libgl" ) == 0 ) && ( i != argc ) ) {
524                                 libgl = argv[i + 1];
525                                 argv[i] = argv[i + 1] = NULL;
526                                 i++;
527                         }
528                         else if ( strcmp( param, "builddefs" ) == 0 ) {
529                                 g_bBuildList = true;
530                                 argv[i] = NULL;
531                         }
532                 }
533         }
534
535         for ( i = 1; i < argc; i++ )
536         {
537                 for ( k = i; k < argc; k++ )
538                         if ( argv[k] != NULL ) {
539                                 break;
540                         }
541
542                 if ( k > i ) {
543                         k -= i;
544                         for ( j = i + k; j < argc; j++ )
545                                 argv[j - k] = argv[j];
546                         argc -= k;
547                 }
548         }
549
550         g_argc = argc;
551         g_argv = argv;
552
553         g_strPluginsDir = "plugins/";
554         g_strModulesDir = "modules/";
555
556 #ifdef _WIN32
557         // get path to the editor
558         char* pBuffer = g_strAppPath.GetBufferSetLength( _MAX_PATH + 1 );
559         GetModuleFileName( NULL, pBuffer, _MAX_PATH );
560         pBuffer[g_strAppPath.ReverseFind( '\\' ) + 1] = '\0';
561         QE_ConvertDOSToUnixName( pBuffer, pBuffer );
562         g_strAppPath.ReleaseBuffer();
563
564         g_strBitmapsPath = g_strAppPath;
565         g_strBitmapsPath += "bitmaps/";
566
567         CGameDialog::UpdateNetrun( false ); // read the netrun configuration
568
569         if ( CGameDialog::GetNetrun() ) {
570                 // we have to find a per-user g_strTempPath
571                 // this behaves the same as on Linux
572                 g_strTempPath = getenv( "USERPROFILE" );
573                 if ( !g_strTempPath.GetLength() ) {
574                         CString msg;
575                         msg = "Radiant is configured to run from a network installation.\n";
576                         msg += "I couldn't find the environement variable USERPROFILE\n";
577                         msg += "I'm going to use C:\\RadiantSettings. Please set USERPROFILE\n";
578                         gtk_MessageBox( NULL, msg, "Radiant - Network mode", MB_OK );
579                         g_strTempPath = "C:\\";
580                 }
581                 g_strTempPath += "\\RadiantSettings\\";
582                 Q_mkdir( g_strTempPath.GetBuffer(), 0755 );
583                 g_strTempPath += RADIANT_VERSION;
584                 g_strTempPath += "\\";
585                 Q_mkdir( g_strTempPath.GetBuffer(), 0755 );
586         }
587         else
588         {
589                 // use the core path as temp (to save commandlist.txt, and do the .pid files)
590                 g_strTempPath = g_strAppPath;
591         }
592
593 #endif
594
595 #if defined ( __linux__ ) || defined ( __APPLE__ )
596         Str home;
597         home = g_get_home_dir();
598         AddSlash( home );
599         home += ".radiant/";
600         Q_mkdir( home.GetBuffer(), 0775 );
601         home += RADIANT_VERSION;
602         Q_mkdir( home.GetBuffer(), 0775 );
603         g_strTempPath = home.GetBuffer();
604         AddSlash( g_strTempPath );
605
606         loki_initpaths( argv[0] );
607
608         // NOTE: we build g_strAppPath with a '/' (or '\' on WIN32)
609         // it's a general convention in Radiant to have the slash at the end of directories
610         char real[PATH_MAX];
611         realpath( loki_getdatapath(), real );
612         if ( real[strlen( real ) - 1] != '/' ) {
613                 strcat( real, "/" );
614         }
615
616         g_strAppPath = real;
617
618         // radiant is installed in the parent dir of "tools/"
619         // NOTE: this is not very easy for debugging
620         // maybe add options to lookup in several places?
621         // (for now I had to create symlinks)
622         g_strBitmapsPath = g_strAppPath;
623         g_strBitmapsPath += "bitmaps/";
624
625         // we will set this right after the game selection is done
626         g_strGameToolsPath = g_strAppPath;
627
628 #endif
629
630         // init the DTD path
631         g_strDTDPath = g_strAppPath;
632         g_strDTDPath += "dtds/";
633
634         /*!
635            the global prefs loading / game selection dialog might fail for any reason we don't know about
636            we need to catch when it happens, to cleanup the stateful prefs which might be killing it
637            and to turn on console logging for lookup of the problem
638            this is the first part of the two step .pid system
639          */
640         g_pidFile = g_strTempPath.GetBuffer();
641         g_pidFile += "radiant.pid";
642
643         FILE *pid;
644         pid = fopen( g_pidFile.GetBuffer(), "r" );
645         if ( pid != NULL ) {
646                 fclose( pid );
647                 CString msg;
648
649                 if ( remove( g_pidFile.GetBuffer() ) == -1 ) {
650                         msg = "WARNING: Could not delete "; msg += g_pidFile;
651                         gtk_MessageBox( NULL, msg, "Radiant", MB_OK | MB_ICONERROR );
652                 }
653
654                 // in debug, never prompt to clean registry, turn console logging auto after a failed start
655 #if !defined( _DEBUG )
656                 msg = "Found the file ";
657                 msg += g_pidFile;
658                 msg += ".\nThis indicates that Radiant failed during the game selection startup last time it was run.\n"
659                            "Choose YES to clean Radiant's registry settings and shut down Radiant.\n"
660                            "WARNING: the global prefs will be lost if you choose YES.";
661
662                 if ( gtk_MessageBox( NULL, msg, "Radiant - Reset global startup?", MB_YESNO | MB_ICONQUESTION ) == IDYES ) {
663                         // remove global prefs and shutdown
664                         g_PrefsDlg.mGamesDialog.Reset();
665                         // remove the prefs file (like a full reset of the registry)
666                         //remove (g_PrefsDlg.m_inipath->str);
667                         gtk_MessageBox( NULL, "Removed global settings, choose OK to close Radiant.", "Radiant", MB_OK );
668                         _exit( -1 );
669                 }
670                 msg = "Logging console output to ";
671                 msg += g_strTempPath;
672                 msg += "radiant.log\nRefer to the log if Radiant fails to start again.";
673
674                 gtk_MessageBox( NULL, msg, "Radiant - Console Log", MB_OK );
675 #endif
676
677                 // set without saving, the class is not in a coherent state yet
678                 // just do the value change and call to start logging, CGamesDialog will pickup when relevant
679                 g_PrefsDlg.mGamesDialog.m_bLogConsole = true;
680                 g_PrefsDlg.mGamesDialog.m_bForceLogConsole = true;
681                 Sys_LogFile();
682         }
683
684         // create a primary .pid for global init run
685         pid = fopen( g_pidFile.GetBuffer(), "w" );
686         if ( pid ) {
687                 fclose( pid );
688         }
689
690         // a safe check to avoid people running broken installations
691         // (otherwise, they run it, crash it, and blame us for not forcing them hard enough to pay attention while installing)
692         // make something idiot proof and someone will make better idiots, this may be overkill
693         // let's leave it disabled in debug mode in any case
694 #ifndef _DEBUG
695         //#define CHECK_VERSION
696 #endif
697 #ifdef CHECK_VERSION
698         // locate and open RADIANT_MAJOR and RADIANT_MINOR
699         qboolean bVerIsGood = true;
700         Str ver_file_name;
701         ver_file_name = g_strAppPath;
702         ver_file_name += "RADIANT_MAJOR";
703         FILE *ver_file = fopen( ver_file_name.GetBuffer(), "r" );
704         if ( ver_file ) {
705                 char buf[10];
706                 int chomp;
707                 fread( buf, 1, 10, ver_file );
708                 // chomp it (the hard way)
709                 chomp = 0;
710                 while ( buf[chomp] >= '0' && buf[chomp] <= '9' )
711                         chomp++;
712                 buf[chomp] = '\0';
713                 if ( strcmp( buf, RADIANT_MAJOR_VERSION ) ) {
714                         Sys_Printf( "ERROR: file RADIANT_MAJOR doesn't match ('%s')\n", buf );
715                         bVerIsGood = false;
716                 }
717         }
718         else
719         {
720                 Sys_Printf( "ERROR: can't find RADIANT_MAJOR in '%s'\n", ver_file_name.GetBuffer() );
721                 bVerIsGood = false;
722         }
723         ver_file_name = g_strAppPath;
724         ver_file_name += "RADIANT_MINOR";
725         ver_file = fopen( ver_file_name.GetBuffer(), "r" );
726         if ( ver_file ) {
727                 char buf[10];
728                 int chomp;
729                 fread( buf, 1, 10, ver_file );
730                 // chomp it (the hard way)
731                 chomp = 0;
732                 while ( buf[chomp] >= '0' && buf[chomp] <= '9' )
733                         chomp++;
734                 buf[chomp] = '\0';
735                 if ( strcmp( buf, RADIANT_MINOR_VERSION ) ) {
736                         Sys_Printf( "ERROR: file RADIANT_MINOR doesn't match ('%s')\n", buf );
737                         bVerIsGood = false;
738                 }
739         }
740         else
741         {
742                 Sys_Printf( "ERROR: can't find RADIANT_MINOR in '%s'\n", ver_file_name.GetBuffer() );
743                 bVerIsGood = false;
744         }
745         if ( !bVerIsGood ) {
746                 CString msg;
747                 msg = "This editor binary (" RADIANT_VERSION ") doesn't match what the latest setup has configured in this directory\n";
748                 msg += "Make sure you run the right/latest editor binary you installed\n";
749                 msg += g_strAppPath; msg += "\n";
750                 msg += "Check http://www.qeradiant.com/faq/index.cgi?file=219 for more information";
751                 gtk_MessageBox( NULL, msg.GetBuffer(), "Radiant", MB_OK, "http://www.qeradiant.com/faq/index.cgi?file=219" );
752                 _exit( -1 );
753         }
754 #endif
755
756         g_qeglobals.disable_ini = false;
757         g_PrefsDlg.Init();
758
759         // close the primary
760         if ( remove( g_pidFile.GetBuffer() ) == -1 ) {
761                 CString msg;
762                 msg = "WARNING: Could not delete "; msg += g_pidGameFile;
763                 gtk_MessageBox( NULL, msg, "Radiant", MB_OK | MB_ICONERROR );
764         }
765
766         /*!
767            now the secondary game dependant .pid file
768          */
769         g_pidGameFile = g_PrefsDlg.m_rc_path->str;
770         g_pidGameFile += "radiant-game.pid";
771
772         pid = fopen( g_pidGameFile.GetBuffer(), "r" );
773         if ( pid != NULL ) {
774                 fclose( pid );
775                 CString msg;
776                 if ( remove( g_pidGameFile.GetBuffer() ) == -1 ) {
777                         msg = "WARNING: Could not delete "; msg += g_pidGameFile;
778                         gtk_MessageBox( NULL, msg, "Radiant", MB_OK | MB_ICONERROR );
779                 }
780
781                 msg = "Found the file ";
782                 msg += g_pidGameFile;
783                 msg += ".\nThis indicates that Radiant failed to load the last time it was run.\n"
784                            "Choose YES to clean Radiant's registry settings and shut down Radiant.\n"
785                            "WARNING: preferences will be lost if you choose YES.";
786
787                 // in debug, never prompt to clean registry, turn console logging auto after a failed start
788 #if !defined( _DEBUG )
789                 //bleh
790                 if ( gtk_MessageBox( NULL, msg, "Radiant - Clean Registry?", MB_YESNO | MB_ICONQUESTION ) == IDYES ) {
791                         // remove the game prefs files
792                         remove( g_PrefsDlg.m_inipath->str );
793                         char buf[PATH_MAX];
794                         sprintf( buf, "%sSavedInfo.bin", g_PrefsDlg.m_rc_path->str );
795                         remove( buf );
796                         // remove the global pref too
797                         g_PrefsDlg.mGamesDialog.Reset();
798                         gtk_MessageBox( NULL, "Cleaned registry settings, choose OK to close Radiant.\nThe next time Radiant runs it will use default settings.", "Radiant", MB_OK );
799                         _exit( -1 );
800                 }
801                 msg = "Logging console output to ";
802                 msg += g_strTempPath;
803                 msg += "radiant.log\nRefer to the log if Radiant fails to start again.";
804
805                 gtk_MessageBox( NULL, msg, "Radiant - Console Log", MB_OK );
806 #endif
807
808                 // force console logging on! (will go in prefs too)
809                 g_PrefsDlg.mGamesDialog.m_bLogConsole = true;
810                 g_PrefsDlg.mGamesDialog.SavePrefs();
811                 Sys_LogFile();
812
813                 g_PrefsDlg.LoadPrefs();
814
815         }
816         else
817         {
818                 // create one, will remove right after entering message loop
819                 pid = fopen( g_pidGameFile.GetBuffer(), "w" );
820                 if ( pid ) {
821                         fclose( pid );
822                 }
823
824                 g_PrefsDlg.LoadPrefs();
825
826 #ifndef _DEBUG // I can't be arsed about that prompt in debug mode
827                 // if console logging is on in the prefs, warn about performance hit
828                 if ( g_PrefsDlg.mGamesDialog.m_bLogConsole ) {
829                         if ( gtk_MessageBox( NULL, "Preferences indicate that console logging is on. This affects performance.\n"
830                                                                            "Turn it off?", "Radiant", MB_YESNO | MB_ICONQUESTION ) == IDYES ) {
831                                 g_PrefsDlg.mGamesDialog.m_bLogConsole = false;
832                                 g_PrefsDlg.mGamesDialog.SavePrefs();
833                         }
834                 }
835 #endif
836                 // toggle console logging if necessary
837                 Sys_LogFile();
838         }
839
840         // we should search in g_strTempPath, then move over to look at g_strAppPath?
841 #ifdef _WIN32
842         // fine tune the look of the app using a gtk rc file
843         // we try to load an RC file placed in the application directory
844         // build the full path
845         Str sRCFile;
846         sRCFile = g_strAppPath;
847         sRCFile += "radiantgtkrc";
848         // we load that file with g_new in gtk_rc_parse_file (gtkrc.c), change the '/' into '\\'
849         pBuffer = (char *)sRCFile.GetBuffer();
850         for ( i = 0; i < sRCFile.GetLength(); i++ )
851         {
852                 if ( pBuffer[i] == '/' ) {
853                         pBuffer[i] = '\\';
854                 }
855         }
856         // check the file exists
857         if ( access( sRCFile.GetBuffer(), R_OK ) != 0 ) {
858                 Sys_Printf( "RC file %s not found\n", sRCFile.GetBuffer() );
859         }
860         else
861         {
862                 Sys_Printf( "Attemping to load RC file %s\n", sRCFile.GetBuffer() );
863                 gtk_rc_parse( sRCFile.GetBuffer() );
864         }
865 #endif
866
867 #ifndef SKIP_SPLASH
868         create_splash();
869 #endif
870
871         if ( !QGL_Init( libgl, "" ) ) {
872                 Sys_FPrintf( SYS_ERR, "Failed to load OpenGL libraries\n" );
873                 _exit( 1 );
874                 return 1;
875         }
876
877 #if defined ( __linux__ ) || defined ( __APPLE__ )
878         if ( ( qglXQueryExtension == NULL ) || ( qglXQueryExtension( GDK_DISPLAY(),NULL,NULL ) != True ) ) {
879                 Sys_FPrintf( SYS_ERR, "glXQueryExtension failed\n" );
880                 _exit( 1 );
881                 return 1;
882         }
883 #endif
884
885         // redirect Gtk warnings to the console
886         g_log_set_handler( "Gdk", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
887                                                                                                 G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG ), error_redirect, NULL );
888         g_log_set_handler( "Gtk", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
889                                                                                                 G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG ), error_redirect, NULL );
890
891         // spog - creates new filters list for the first time
892         g_qeglobals.d_savedinfo.filters = NULL;
893         g_qeglobals.d_savedinfo.filters = FilterAddBase( g_qeglobals.d_savedinfo.filters );
894
895         g_pParentWnd = new MainFrame();
896
897         if ( g_PrefsDlg.m_bLoadLastMap && g_PrefsDlg.m_strLastMap.GetLength() > 0 ) {
898                 Map_LoadFile( g_PrefsDlg.m_strLastMap.GetBuffer() );
899         }
900         else {
901                 Map_New();
902         }
903
904         // load up shaders now that we have the map loaded
905         // eviltypeguy
906         Texture_ShowStartupShaders();
907
908 #ifndef SKIP_SPLASH
909         gdk_window_raise( splash_screen->window );
910         gtk_window_set_transient_for( GTK_WINDOW( splash_screen ), GTK_WINDOW( g_pParentWnd->m_pWidget ) );
911         gtk_timeout_add( 1000, try_destroy_splash, NULL );
912 #endif
913
914         g_pParentWnd->GetSynapseServer().DumpActiveClients();
915
916         //++timo: temporary debug
917         g_pParentWnd->DoWatchBSP();
918
919         gtk_main();
920
921         // close the log file if any
922         // NOTE: don't save prefs past this point!
923         g_PrefsDlg.mGamesDialog.m_bLogConsole = false;
924         // set the console window to NULL to avoid Sys_Printf crashing
925         g_qeglobals_gui.d_edit = NULL;
926         Sys_LogFile();
927
928         // NOTE TTimo not sure what this _exit(0) call is worth
929         //   restricting it to linux build
930 #ifdef __linux__
931         _exit( 0 );
932 #endif
933         return 0;
934 }
935
936 // ydnar: quick and dirty fix, just make the buffer bigger
937 #define BIG_PATH_MAX    4096
938
939 // TTimo: decompose the BSP command into several steps so we can monitor them eventually
940 void QE_ExpandBspString( char *bspaction, GPtrArray *out_array, char *mapname ){
941         const char  *in;
942         char  *out;
943         char src[BIG_PATH_MAX];
944         char rsh[BIG_PATH_MAX];
945         char base[BIG_PATH_MAX];
946
947         strcpy( src, mapname );
948         strlwr( src );
949         in = strstr( src, "maps/" );
950         if ( !in ) {
951                 in = strstr( src, "maps/" );
952         }
953         if ( in ) {
954                 in += 5;
955                 strcpy( base, in );
956                 out = base;
957                 while ( *out )
958                 {
959                         if ( *out == '\\' ) {
960                                 *out = '/';
961                         }
962                         out++;
963                 }
964         }
965         else
966         {
967                 ExtractFileName( mapname, base );
968         }
969
970         // this important step alters the map name to add fs_game
971         // NOTE: it used to add fs_basepath too
972         // the fs_basepath addition moved to being in the project file during the bug fixing rush
973         // but it may not have been the right thing to do
974
975         // HACK: halflife compiler tools don't support -fs_game
976         // HACK: neither does JKII/SoF2/ etc..
977         // do we use & have fs_game?
978
979         if ( g_pGameDescription->mGameFile != "hl.game" &&
980                  *ValueForKey( g_qeglobals.d_project_entity,"gamename" ) != '\0' ) {
981                 // set with fs_game
982                 sprintf( src, "-fs_game %s \"%s\"", ValueForKey( g_qeglobals.d_project_entity,"gamename" ), mapname );
983         }
984         else
985         {
986                 sprintf( src, "\"%s\"", mapname );
987         }
988
989         rsh[0] = 0;
990
991         QE_ConvertDOSToUnixName( src, src );
992
993         // initialise the first step
994         out = new char[BIG_PATH_MAX]; //% PATH_MAX
995         g_ptr_array_add( out_array, out );
996
997         in = ValueForKey( g_qeglobals.d_project_entity, bspaction );
998         while ( *in )
999         {
1000                 if ( in[0] == '!' ) {
1001                         strcpy( out, rsh );
1002                         out += strlen( rsh );
1003                         in++;
1004                         continue;
1005                 }
1006                 if ( in[0] == '#' ) {
1007                         char tmp[2048];
1008                         // we process these only if monitoring
1009                         if ( g_PrefsDlg.m_bWatchBSP ) {
1010                                 // -connect global option (the only global option so far anyway)
1011                                 strcpy( tmp, " -connect 127.0.0.1:39000 " );
1012                                 strcpy( out, tmp );
1013                                 out += strlen( tmp );
1014                         }
1015                         in++;
1016                         continue;
1017                 }
1018                 if ( in[0] == '$' ) {
1019                         // $ expansion
1020                         strcpy( out, src );
1021                         out += strlen( src );
1022                         in++;
1023                         continue;
1024                 }
1025                 if ( in[0] == '@' ) {
1026                         *out++ = '"';
1027                         in++;
1028                         continue;
1029                 }
1030                 if ( in[0] == '&' ) {
1031                         if ( in[1] == '&' ) {
1032                                 // start a new step
1033                                 *out = 0;
1034                                 in = in + 2;
1035                                 out = new char[BIG_PATH_MAX]; //% PATH_MAX
1036                                 g_ptr_array_add( out_array, out );
1037                         }
1038                 }
1039                 *out++ = *in++;
1040         }
1041         *out = 0;
1042 }
1043
1044 void FindReplace( CString& strContents, const char* pTag, const char* pValue ){
1045         if ( strcmp( pTag, pValue ) == 0 ) {
1046                 return;
1047         }
1048         for ( int nPos = strContents.Find( pTag ); nPos >= 0; nPos = strContents.Find( pTag ) )
1049         {
1050                 int nRightLen = strContents.GetLength() - strlen( pTag ) - nPos;
1051                 CString strLeft = strContents.Left( nPos );
1052                 CString strRight = strContents.Right( nRightLen );
1053                 strLeft += pValue;
1054                 strLeft += strRight;
1055                 strContents = strLeft;
1056         }
1057 }
1058
1059 // save the map, deals with regioning
1060 void SaveWithRegion( char *name ){
1061         strcpy( name, currentmap );
1062         if ( region_active ) {
1063                 // temporary cut the region to save regular map
1064                 region_active = false;
1065                 Map_SaveFile( name, false );
1066                 region_active = true;
1067                 StripExtension( name );
1068                 strcat( name, ".reg" );
1069         }
1070
1071         Map_SaveFile( name, region_active );
1072 }
1073
1074 void RunBsp( char *command ){
1075         GPtrArray *sys;
1076         char batpath[BIG_PATH_MAX]; //% PATH_MAX
1077         char temppath[BIG_PATH_MAX]; //% PATH_MAX
1078         char name[BIG_PATH_MAX];    //% PATH_MAX
1079         char cWork[BIG_PATH_MAX];   //% PATH_MAX
1080         FILE  *hFile;
1081         unsigned int i;
1082
1083         SetInspectorMode( W_CONSOLE );
1084
1085         strcpy( temppath, g_strTempPath.GetBuffer() );
1086
1087         SaveWithRegion( name );
1088
1089         const char *rsh = ValueForKey( g_qeglobals.d_project_entity, "rshcmd" );
1090         if ( rsh == NULL ) {
1091                 CString strPath, strFile;
1092
1093                 ExtractPath_and_Filename( name, strPath, strFile );
1094                 AddSlash( strPath );
1095                 strncpy( cWork, strPath, 1024 );
1096                 strcat( cWork, strFile );
1097         }
1098         else
1099         {
1100                 strcpy( cWork, name );
1101         }
1102
1103         // get the array ready
1104         //++timo TODO: free the array, free the strings ourselves with delete[]
1105         sys = g_ptr_array_new();
1106
1107         QE_ExpandBspString( command, sys, cWork );
1108
1109         if ( g_PrefsDlg.m_bWatchBSP ) {
1110                 // grab the file name for engine running
1111                 char *bspname = new char[1024];
1112                 ExtractFileName( currentmap, bspname );
1113                 StripExtension( bspname );
1114                 g_pParentWnd->GetWatchBSP()->DoMonitoringLoop( sys, bspname );
1115         }
1116         else
1117         {
1118                 // write all the steps in a single BAT / .sh file and run it, don't bother monitoring it
1119                 CString strSys;
1120                 for ( i = 0; i < sys->len; i++ )
1121                 {
1122                         strSys += (char *)g_ptr_array_index( sys, i );
1123 #ifdef _WIN32  // write temp\junk.txt in win32... NOTE: stops output to shell prompt window
1124                         if ( i == 0 ) {
1125                                 strSys += " >";
1126                         }
1127                         else{
1128                                 strSys += " >>";
1129                         }
1130                         strSys += "\"";
1131                         strSys += temppath;
1132                         strSys += "junk.txt\"";
1133 #endif
1134                         strSys += "\n";
1135                 };
1136
1137 #if defined ( __linux__ ) || defined ( __APPLE__ )
1138
1139                 // write qe3bsp.sh
1140                 sprintf( batpath, "%sqe3bsp.sh", temppath );
1141                 Sys_Printf( "Writing the compile script to '%s'\n", batpath );
1142                 Sys_Printf( "The build output will be saved in '%sjunk.txt'\n", temppath );
1143                 hFile = fopen( batpath, "w" );
1144                 if ( !hFile ) {
1145                         Error( "Can't write to %s", batpath );
1146                 }
1147                 fprintf( hFile, "#!/bin/sh \n\n" );
1148                 fprintf( hFile, "%s", strSys.GetBuffer() );
1149                 fclose( hFile );
1150                 chmod( batpath, 0744 );
1151 #endif
1152
1153 #ifdef _WIN32
1154                 sprintf( batpath, "%sqe3bsp.bat", temppath );
1155                 Sys_Printf( "Writing the compile script to '%s'\n", batpath );
1156                 Sys_Printf( "The build output will be saved in '%sjunk.txt'\n", temppath );
1157                 hFile = fopen( batpath, "w" );
1158                 if ( !hFile ) {
1159                         Error( "Can't write to %s", batpath );
1160                 }
1161                 fprintf( hFile, "%s", strSys.GetBuffer() );
1162                 fclose( hFile );
1163 #endif
1164
1165                 Pointfile_Delete();
1166
1167 #if defined ( __linux__ ) || defined ( __APPLE__ )
1168
1169                 pid_t pid;
1170
1171                 pid = fork();
1172                 switch ( pid )
1173                 {
1174                 case -1:
1175                         Error( "CreateProcess failed" );
1176                         break;
1177                 case 0:
1178                         execlp( batpath, batpath, NULL );
1179                         printf( "execlp error !" );
1180                         _exit( 0 );
1181                         break;
1182                 default:
1183                         break;
1184                 }
1185 #endif
1186
1187 #ifdef _WIN32
1188                 Sys_Printf( "Running bsp command...\n" );
1189                 Sys_Printf( "\n%s\n", strSys.GetBuffer() );
1190
1191                 WinExec( batpath, SW_SHOWNORMAL );
1192 #endif
1193         }
1194 #ifdef _DEBUG
1195         // yeah, do it .. but not now right before 1.1-TA-beta release
1196         Sys_Printf( "TODO: erase GPtrArray\n" );
1197 #endif
1198 }
1199
1200 #if 0
1201
1202 #ifdef _WIN32
1203
1204 int WINAPI QEW_SetupPixelFormat( HDC hDC, qboolean zbuffer ){
1205         static PIXELFORMATDESCRIPTOR pfd = {
1206                 sizeof( PIXELFORMATDESCRIPTOR ), // size of this pfd
1207                 1,                          // version number
1208                 PFD_DRAW_TO_WINDOW |        // support window
1209                 PFD_SUPPORT_OPENGL |        // support OpenGL
1210                 PFD_DOUBLEBUFFER,           // double buffered
1211                 PFD_TYPE_RGBA,              // RGBA type
1212                 24,                         // 24-bit color depth
1213                 0, 0, 0, 0, 0, 0,           // color bits ignored
1214                 0,                          // no alpha buffer
1215                 0,                          // shift bit ignored
1216                 0,                          // no accumulation buffer
1217                 0, 0, 0, 0,                 // accum bits ignored
1218                 32,                         // depth bits
1219                 0,                          // no stencil buffer
1220                 0,                          // no auxiliary buffer
1221                 PFD_MAIN_PLANE,             // main layer
1222                 0,                          // reserved
1223                 0, 0, 0                     // layer masks ignored
1224         };                            //
1225         int pixelformat = 0;
1226
1227         zbuffer = true;
1228         if ( !zbuffer ) {
1229                 pfd.cDepthBits = 0;
1230         }
1231
1232         if ( ( pixelformat = ChoosePixelFormat( hDC, &pfd ) ) == 0 ) {
1233                 LPVOID lpMsgBuf;
1234                 FormatMessage(
1235                         FORMAT_MESSAGE_ALLOCATE_BUFFER |
1236                         FORMAT_MESSAGE_FROM_SYSTEM |
1237                         FORMAT_MESSAGE_IGNORE_INSERTS,
1238                         NULL,
1239                         GetLastError(),
1240                         MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),    // Default language
1241                         (LPTSTR) &lpMsgBuf,
1242                         0,
1243                         NULL
1244                         );
1245                 Sys_FPrintf( SYS_WRN, "GetLastError: %s", lpMsgBuf );
1246                 Error( "ChoosePixelFormat failed" );
1247         }
1248
1249         if ( !SetPixelFormat( hDC, pixelformat, &pfd ) ) {
1250                 Error( "SetPixelFormat failed" );
1251         }
1252
1253         return pixelformat;
1254 }
1255
1256 #endif
1257
1258 #endif