radiant/qe3.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 //
  23 // Linux stuff
  24 //
  25 // Leonardo Zide (leo@lokigames.com)
  26 //
  27
  28 #include "stdafx.h"
  29 #include <gtk/gtk.h>
  30 #include <sys/stat.h>
  31 #include "gtkmisc.h"
  32 #include <glib/gi18n.h>
  33 #if defined (__linux__) || defined (__APPLE__)
  34 #include <unistd.h>
  35 #include <X11/keysym.h>
  36 #include <gdk/gdkx.h>
  37 #include <gdk/gdkprivate.h>
  38 #endif
  39 // for the logging part
  40 #include <fcntl.h>
  41 #include <sys/types.h>
  42
  43 QEGlobals_t  g_qeglobals;
  44 QEGlobals_GUI_t g_qeglobals_gui;
  45
  46 // leo: Track memory allocations for debugging
  47 // NOTE TTimo this was never used and probably not relevant
  48 //   there are tools to do that
  49 #ifdef MEM_DEBUG
  50
  51 static GList *memblocks;
  52
  53 void* debug_malloc (size_t size, const char* file, int line)
  54 {
  55   void *buf = g_malloc (size + 8);
  56
  57   *((const char**)buf) = file;
  58   buf = (char*)buf + 4;
  59   *((int*)buf) = line;
  60   buf = (char*)buf + 4;
  61
  62   memblocks = g_list_append (memblocks, buf);
  63
  64   return buf;
  65 }
  66
  67 void debug_free (void *buf, const char* file, int line)
  68 {
  69   const char *f;
  70   int l;
  71
  72   if (g_list_find (memblocks, buf))
  73   {
  74     memblocks = g_list_remove (memblocks, buf);
  75
  76     buf = (char*)buf - 4;
  77     l = *((int*)buf);
  78     buf = (char*)buf - 4;
  79     f = *((const char**)buf);
  80
  81     Sys_FPrintf (SYS_DBG, "free: %s %d", file, line);
  82     Sys_FPrintf (SYS_DBG, " allocated: %s %d\n", f, l);
  83
  84     g_free (buf);
  85   }
  86 //  else
  87 //    free (buf); // from qmalloc, will leak unless we add this same hack to cmdlib
  88 }
  89
  90 #endif
  91
  92 vec_t Rad_rint (vec_t in)
  93 {
  94   if (g_PrefsDlg.m_bNoClamp)
  95     return in;
  96   else
  97     return (float)floor (in + 0.5);
  98 }
  99
 100 void WINAPI QE_CheckOpenGLForErrors(void)
 101 {
 102   char strMsg[1024];
 103   int i = qglGetError();
 104   if (i != GL_NO_ERROR)
 105   {
 106     if (i == GL_OUT_OF_MEMORY)
 107     {
 108       sprintf(strMsg, "OpenGL out of memory error %s\nDo you wish to save before exiting?", qgluErrorString((GLenum)i));
 109       if (gtk_MessageBox(g_pParentWnd->m_pWidget, strMsg, "Radiant Error", MB_YESNO) == IDYES)
 110       {
 111         Map_SaveFile(NULL, false);
 112       }
 113       _exit(1);
 114     }
 115     else
 116     {
 117       Sys_Printf ("Warning: OpenGL Error %s\n", qgluErrorString((GLenum)i));
 118     }
 119   }
 120 }
 121
 122 // NOTE: don't this function, use VFS instead
 123 char *ExpandReletivePath (char *p)
 124 {
 125         static char     temp[1024];
 126         const char      *base;
 127
 128         if (!p || !p[0])
 129                 return NULL;
 130         if (p[0] == '/' || p[0] == '\\')
 131                 return p;
 132
 133         base = ValueForKey(g_qeglobals.d_project_entity, "basepath");
 134         sprintf (temp, "%s/%s", base, p);
 135         return temp;
 136 }
 137
 138 char *copystring (char *s)
 139 {
 140         char    *b;
 141         b = (char*)malloc(strlen(s)+1);
 142         strcpy (b,s);
 143         return b;
 144 }
 145
 146
 147 bool DoesFileExist(const char* pBuff, long& lSize)
 148 {
 149   FileStream file;
 150   if (file.Open(pBuff, "r"))
 151   {
 152     lSize += file.GetLength();
 153     file.Close();
 154     return true;
 155   }
 156   return false;
 157 }
 158
 159
 160 void Map_Snapshot()
 161 {
 162   CString strMsg;
 163
 164   // I hope the modified flag is kept correctly up to date
 165   if (!modified)
 166     return;
 167
 168   // we need to do the following
 169   // 1. make sure the snapshot directory exists (create it if it doesn't)
 170   // 2. find out what the lastest save is based on number
 171   // 3. inc that and save the map
 172   CString strOrgPath, strOrgFile;
 173   ExtractPath_and_Filename(currentmap, strOrgPath, strOrgFile);
 174   AddSlash(strOrgPath);
 175   strOrgPath += "snapshots";
 176   bool bGo = true;
 177   struct stat Stat;
 178   if (stat(strOrgPath, &Stat) == -1)
 179   {
 180 #ifdef _WIN32
 181     bGo = (_mkdir(strOrgPath) != -1);
 182 #endif
 183
 184 #if defined (__linux__) || defined (__APPLE__)
 185     bGo = (mkdir(strOrgPath,0755) != -1);
 186 #endif
 187   }
 188   AddSlash(strOrgPath);
 189   if (bGo)
 190   {
 191     int nCount = 0;
 192     long lSize = 0;
 193     CString strNewPath;
 194     strNewPath = strOrgPath;
 195     strNewPath += strOrgFile;
 196     CString strFile;
 197     while (bGo)
 198     {
 199       char buf[PATH_MAX];
 200       sprintf( buf, "%s.%i", strNewPath.GetBuffer(), nCount );
 201       strFile = buf;
 202       bGo = DoesFileExist(strFile, lSize);
 203       nCount++;
 204     }
 205     // strFile has the next available slot
 206     Map_SaveFile(strFile, false);
 207     // it is still a modified map (we enter this only if this is a modified map)
 208     Sys_SetTitle (currentmap);
 209     Sys_MarkMapModified();
 210     if (lSize > 12 * 1024 * 1024) // total size of saves > 4 mb
 211     {
 212       Sys_Printf("The snapshot files in %s total more than 4 megabytes. You might consider cleaning up.", strOrgPath.GetBuffer());
 213     }
 214   }
 215   else
 216   {
 217     strMsg.Format("Snapshot save failed.. unabled to create directory\n%s", strOrgPath.GetBuffer());
 218     gtk_MessageBox(g_pParentWnd->m_pWidget, strMsg);
 219   }
 220   strOrgPath = "";
 221   strOrgFile = "";
 222 }
 223 /*
 224 ===============
 225 QE_CheckAutoSave
 226
 227 If five minutes have passed since making a change
 228 and the map hasn't been saved, save it out.
 229 ===============
 230 */
 231
 232
 233 void QE_CheckAutoSave( void )
 234 {
 235   static time_t s_start;
 236   time_t now;
 237   time (&now);
 238
 239   if (modified != 1 || !s_start)
 240   {
 241     s_start = now;
 242     return;
 243   }
 244
 245   if ((now - s_start) > (60 * g_PrefsDlg.m_nAutoSave))
 246   {
 247     if (g_PrefsDlg.m_bAutoSave)
 248     {
 249       CString strMsg;
 250       strMsg = g_PrefsDlg.m_bSnapShots ? "Autosaving snapshot..." : "Autosaving...";
 251       Sys_Printf(strMsg);
 252       Sys_Printf("\n");
 253       Sys_Status (strMsg,0);
 254
 255       // only snapshot if not working on a default map
 256       if (g_PrefsDlg.m_bSnapShots && stricmp(currentmap, "unnamed.map") != 0)
 257       {
 258         Map_Snapshot();
 259       }
 260       else
 261       {
 262         Map_SaveFile (ValueForKey(g_qeglobals.d_project_entity, "autosave"), false);
 263       }
 264
 265       Sys_Status ("Autosaving...Saved.", 0 );
 266       modified = 2;
 267     }
 268     else
 269     {
 270       Sys_Printf ("Autosave skipped...\n");
 271       Sys_Status ("Autosave skipped...", 0 );
 272     }
 273     s_start = now;
 274   }
 275 }
 276
 277
 278 // NOTE TTimo we don't like that BuildShortPathName too much
 279 //   the VFS provides a vfsCleanFileName which should perform the cleanup tasks
 280 //   in the long run I'd like to completely get rid of this
 281
 282 // used to be disabled, but caused problems
 283
 284 // can't work with long win32 names until the BSP commands are not working differently
 285 #ifdef _WIN32
 286 int BuildShortPathName(const char* pPath, char* pBuffer, int nBufferLen)
 287 {
 288   char *pFile = NULL;
 289   int nResult = GetFullPathName(pPath, nBufferLen, pBuffer, &pFile);
 290   nResult = GetShortPathName(pPath, pBuffer, nBufferLen);
 291   if (nResult == 0)
 292     strcpy(pBuffer, pPath);                     // Use long filename
 293   return nResult;
 294 }
 295 #endif
 296
 297 #if defined (__linux__) || defined (__APPLE__)
 298 int BuildShortPathName(const char* pPath, char* pBuffer, int nBufferLen)
 299 {
 300   // remove /../ from directories
 301   const char *scr = pPath; char *dst = pBuffer;
 302   for (int i = 0; (i < nBufferLen) && (*scr != 0); i++)
 303   {
 304     if (*scr == '/' && *(scr+1) == '.' && *(scr+2) == '.')
 305     {
 306       scr += 3;
 307       while (dst != pBuffer && *(--dst) != '/')
 308       {
 309         i--;
 310       }
 311     }
 312
 313     *dst = *scr;
 314
 315     scr++; dst++;
 316   }
 317   *dst = 0;
 318
 319   return strlen (pBuffer);
 320 }
 321 #endif
 322
 323 /*
 324 const char *g_pPathFixups[]=
 325 {
 326   "basepath",
 327   "autosave",
 328 };
 329
 330 const int g_nPathFixupCount = sizeof(g_pPathFixups) / sizeof(const char*);
 331
 332 void QE_CheckProjectEntity()
 333 {
 334   char *pFile;
 335   char pBuff[PATH_MAX];
 336   char pNewPath[PATH_MAX];
 337   for (int i = 0; i < g_nPathFixupCount; i++)
 338   {
 339     char *pPath = ValueForKey (g_qeglobals.d_project_entity, g_pPathFixups[i]);
 340
 341     strcpy (pNewPath, pPath);
 342     if (pPath[0] != '\\' && pPath[0] != '/')
 343       if (GetFullPathName(pPath, PATH_MAX, pBuff, &pFile))
 344               strcpy (pNewPath, pBuff);
 345
 346     BuildShortPathName (pNewPath, pBuff, PATH_MAX);
 347
 348     // check it's not ending with a filename seperator
 349     if (pBuff[strlen(pBuff)-1] == '/' || pBuff[strlen(pBuff)-1] == '\\')
 350     {
 351       Sys_FPrintf(SYS_WRN, "WARNING: \"%s\" path in the project file has an ending file seperator, fixing.\n", g_pPathFixups[i]);
 352       pBuff[strlen(pBuff)-1]=0;
 353     }
 354
 355     SetKeyValue(g_qeglobals.d_project_entity, g_pPathFixups[i], pBuff);
 356   }
 357 }
 358 */
 359
 360 void HandleXMLError( void* ctxt, const char* text, ... )
 361 {
 362   va_list argptr;
 363   static char buf[32768];
 364
 365   va_start (argptr,text);
 366   vsprintf (buf, text, argptr);
 367   Sys_FPrintf (SYS_ERR, "XML %s\n", buf);
 368   va_end (argptr);
 369 }
 370
 371 #define DTD_BUFFER_LENGTH 1024
 372 xmlDocPtr ParseXMLStream(IDataStream *stream, bool validate = false)
 373 {
 374   xmlDocPtr doc = NULL;
 375   bool wellFormed = false, valid = false;
 376   int res, size = 1024;
 377   char chars[1024];
 378   xmlParserCtxtPtr ctxt;
 379
 380   //if(validate)
 381   //  xmlDoValidityCheckingDefaultValue = 1;
 382   //else
 383     xmlDoValidityCheckingDefaultValue = 0;
 384   xmlSetGenericErrorFunc(NULL, HandleXMLError);
 385
 386   // SPoG
 387   // HACK: use AppPath to resolve DTD location
 388   // do a buffer-safe string copy and concatenate
 389   int i;
 390   char* w;
 391   const char* r;
 392   char buf[DTD_BUFFER_LENGTH];
 393
 394   w = buf;
 395   i = 0;
 396   // copy
 397   //assert(g_strAppPath.GetBuffer() != NULL);
 398   for(r = g_strAppPath.GetBuffer(); i<DTD_BUFFER_LENGTH && *r != '\0'; i++, r++)  w[i] = *r;
 399   // concatenate
 400   for(r = "dtds/"; i<DTD_BUFFER_LENGTH && *r != '\0'; i++, r++)  w[i] = *r;
 401   // terminate
 402   w[i] = '\0';
 403
 404   if(i == DTD_BUFFER_LENGTH)
 405   {
 406     HandleXMLError(NULL, "ERROR: buffer overflow: DTD path length too large\n");
 407     return NULL;
 408   }
 409
 410   res = stream->Read(chars, 4);
 411   if (res > 0)
 412   {
 413     ctxt = xmlCreatePushParserCtxt(NULL, NULL, chars, res, buf);
 414
 415     while ((res = stream->Read(chars, size)) > 0)
 416     {
 417       xmlParseChunk(ctxt, chars, res, 0);
 418     }
 419     xmlParseChunk(ctxt, chars, 0, 1);
 420     doc = ctxt->myDoc;
 421
 422     wellFormed = (ctxt->wellFormed == 1);
 423     valid = (ctxt->valid == 1);
 424
 425     xmlFreeParserCtxt(ctxt);
 426   }
 427
 428   if(wellFormed && (!validate || (validate && valid)))
 429     return doc;
 430
 431   if(doc != NULL)
 432     xmlFreeDoc(doc);
 433
 434   return NULL;
 435 }
 436
 437 xmlDocPtr ParseXMLFile(const char* filename, bool validate = false)
 438 {
 439   FileStream stream;
 440   if (stream.Open(filename, "r"))
 441     return ParseXMLStream(&stream, validate);
 442
 443   Sys_FPrintf(SYS_ERR, "Failed to open file: %s\n",filename);
 444   return NULL;
 445 }
 446
 447 // copy a string r to a buffer w
 448 // replace $string as appropriate
 449 void ReplaceTemplates(char* w, const char* r)
 450 {
 451   const char *p;
 452   const char *__ENGINEPATH = "TEMPLATEenginepath";
 453   const char *__USERHOMEPATH = "TEMPLATEuserhomepath";
 454   const char *__TOOLSPATH = "TEMPLATEtoolspath";
 455   const char *__BASEDIR = "TEMPLATEbasedir";
 456   const char *__APPPATH = "TEMPLATEapppath";
 457
 458   // iterate through string r
 459   while(*r!='\0')
 460   {
 461     // check for special character
 462     if(*r=='$')
 463     {
 464       if(strncmp(r+1, __ENGINEPATH, strlen(__ENGINEPATH)) == 0)
 465       {
 466         r+=strlen(__ENGINEPATH)+1;
 467         p = g_pGameDescription->mEnginePath.GetBuffer();
 468       }
 469       else if(strncmp(r+1, __USERHOMEPATH, strlen(__USERHOMEPATH)) == 0)
 470       {
 471         r+=strlen(__USERHOMEPATH)+1;
 472         p = g_qeglobals.m_strHomeGame.GetBuffer();
 473       }
 474       else if(strncmp(r+1, __BASEDIR, strlen(__BASEDIR)) == 0)
 475       {
 476         r+=strlen(__BASEDIR)+1;
 477         p = g_pGameDescription->mBaseGame;
 478       }
 479       else if(strncmp(r+1, __TOOLSPATH, strlen(__TOOLSPATH)) == 0)
 480       {
 481         r+=strlen(__TOOLSPATH)+1;
 482         p = g_strGameToolsPath.GetBuffer();
 483       }
 484       else if(strncmp(r+1, __APPPATH, strlen(__APPPATH)) == 0)
 485       {
 486         r+=strlen(__APPPATH)+1;
 487         p = g_strAppPath.GetBuffer();
 488       }
 489       else
 490       {
 491         r++;
 492         p = "$";
 493       }
 494
 495       while(*p!='\0') *w++ = *p++;
 496     }
 497     else *w++ = *r++;
 498   }
 499   *w = '\0';
 500 }
 501
 502 /*
 503 ===========
 504 QE_LoadProject
 505 TODO TODO TODO (don't think this got fully merged in)
 506 TTimo: added project file "version", version 2 adds '#' chars to the BSP command strings
 507 version 3 was .. I don't remember .. version 4 adds q3map2 commands
 508 TTimo: when QE_LoadProject is called, the prefs are updated with path to the latest project and saved on disk
 509 ===========
 510 */
 511 /*\todo decide on a sensible location/name for project files.*/
 512 bool QE_LoadProject (const char *projectfile)
 513 {
 514   char buf[1024];
 515   xmlDocPtr doc;
 516   xmlNodePtr node, project;
 517
 518   Sys_Printf("Loading project file: \"%s\"\n", projectfile);
 519   doc = ParseXMLFile(projectfile, true);
 520
 521   if(doc == NULL) return false;
 522
 523   node=doc->children;
 524   while(node != NULL && node->type != XML_DTD_NODE) node=node->next;
 525   if(node == NULL || strcmp((char*)node->name, "project") != 0)
 526   {
 527     Sys_FPrintf(SYS_ERR, "ERROR: invalid file type\n");
 528     return false;
 529   }
 530
 531   while(node->type != XML_ELEMENT_NODE) node=node->next;
 532   // <project>
 533   project = node;
 534
 535   if(g_qeglobals.d_project_entity != NULL) Entity_Free(g_qeglobals.d_project_entity);
 536   g_qeglobals.d_project_entity = Entity_Alloc();
 537
 538   for(node = project->children; node != NULL; node=node->next)
 539   {
 540     if(node->type != XML_ELEMENT_NODE) continue;
 541
 542     // <key>
 543     ReplaceTemplates(buf, (char*)node->properties->next->children->content);
 544
 545     SetKeyValue(g_qeglobals.d_project_entity, (char*)node->properties->children->content, buf);
 546   }
 547
 548   xmlFreeDoc(doc);
 549
 550   // project file version checking
 551   // add a version checking to avoid people loading later versions of the project file and bitching
 552   int ver = IntForKey( g_qeglobals.d_project_entity, "version" );
 553   if (ver > PROJECT_VERSION)
 554   {
 555     char strMsg[1024];
 556     sprintf (strMsg, "This is a version %d project file. This build only supports <=%d project files.\n"
 557       "Please choose another project file or upgrade your version of Radiant.", ver, PROJECT_VERSION);
 558     gtk_MessageBox (g_pParentWnd->m_pWidget, strMsg, "Can't load project file", MB_ICONERROR | MB_OK);
 559                 // set the project file to nothing so we are sure we'll ask next time?
 560                 g_PrefsDlg.m_strLastProject = "";
 561                 g_PrefsDlg.SavePrefs();
 562     return false;
 563   }
 564
 565   // set here some default project settings you need
 566   if ( strlen( ValueForKey( g_qeglobals.d_project_entity, "brush_primit" ) ) == 0 )
 567   {
 568     SetKeyValue( g_qeglobals.d_project_entity, "brush_primit", "0" );
 569   }
 570
 571   g_qeglobals.m_bBrushPrimitMode = IntForKey( g_qeglobals.d_project_entity, "brush_primit" );
 572
 573   g_qeglobals.m_strHomeMaps = g_qeglobals.m_strHomeGame;
 574   const char* str = ValueForKey(g_qeglobals.d_project_entity, "gamename");
 575   if(str[0] == '\0') str = g_pGameDescription->mBaseGame.GetBuffer();
 576   g_qeglobals.m_strHomeMaps += str;
 577   g_qeglobals.m_strHomeMaps += '/';
 578
 579   // don't forget to create the dirs
 580   Q_mkdir(g_qeglobals.m_strHomeGame.GetBuffer(), 0775);
 581   Q_mkdir(g_qeglobals.m_strHomeMaps.GetBuffer(), 0775);
 582
 583   // usefull for the log file and debuggin fucked up configurations from users:
 584   // output the basic information of the .qe4 project file
 585   // SPoG
 586   // all these paths should be unix format, with a trailing slash at the end
 587   // if not.. to debug, check that the project file paths are set up correctly
 588   Sys_Printf("basepath    : %s\n", ValueForKey( g_qeglobals.d_project_entity, "basepath") );
 589   Sys_Printf("entitypath  : %s\n", ValueForKey( g_qeglobals.d_project_entity, "entitypath" ) );
 590
 591
 592   // check whether user_project key exists..
 593   // if not, save the current project under a new name
 594   if (ValueForKey(g_qeglobals.d_project_entity, "user_project")[0] == '\0')
 595   {
 596     Sys_Printf("Loaded a template project file\n");
 597
 598     // create the user_project key
 599     SetKeyValue( g_qeglobals.d_project_entity, "user_project", "1" );
 600
 601     if (IntForKey( g_qeglobals.d_project_entity, "version" ) != PROJECT_VERSION)
 602     {
 603       char strMsg[2048];
 604       sprintf(strMsg,
 605         "The template project '%s' has version %d. The editor binary is configured for version %d.\n"
 606         "This indicates a problem in your setup.\n"
 607         "I will keep going with this project till you fix this",
 608         projectfile, IntForKey( g_qeglobals.d_project_entity, "version" ), PROJECT_VERSION);
 609       gtk_MessageBox (g_pParentWnd->m_pWidget, strMsg, "Can't load project file", MB_ICONERROR | MB_OK);
 610     }
 611
 612     // create the writable project file path
 613     strcpy(buf, g_qeglobals.m_strHomeGame.GetBuffer());
 614     strcat(buf, g_pGameDescription->mBaseGame.GetBuffer());
 615     strcat(buf, "/scripts/");
 616     // while the filename is already in use, increment the number we add to the end
 617     int counter = 0;
 618     char pUser[PATH_MAX];
 619     while (1)
 620     {
 621       sprintf( pUser, "%suser%d." PROJECT_FILETYPE, buf, counter );
 622       counter++;
 623       if (access( pUser, R_OK) != 0)
 624       {
 625         // this is the one
 626         strcpy( buf, pUser );
 627         break;
 628       }
 629     }
 630     // saving project will cause a save prefs
 631     g_PrefsDlg.m_strLastProject = buf;
 632     g_PrefsDlg.m_nLastProjectVer = IntForKey( g_qeglobals.d_project_entity, "version" );
 633     QE_SaveProject(buf);
 634   }
 635   else
 636   {
 637     // update preferences::LastProject with path of this successfully-loaded project
 638     // save preferences
 639     Sys_Printf("Setting current project in prefs to \"%s\"\n", g_PrefsDlg.m_strLastProject.GetBuffer() );
 640     g_PrefsDlg.m_strLastProject = projectfile;
 641     g_PrefsDlg.SavePrefs();
 642   }
 643
 644   return true;
 645 }
 646
 647 /*
 648 ===========
 649 QE_SaveProject
 650 TTimo: whenever QE_SaveProject is called, prefs are updated and saved with the path to the project
 651 ===========
 652 */
 653 qboolean QE_SaveProject (const char* filename)
 654 {
 655   Sys_Printf("Save project file '%s'\n", filename);
 656
 657   xmlNodePtr node;
 658   xmlDocPtr doc = xmlNewDoc((xmlChar *)"1.0");
 659   // create DTD node
 660   xmlCreateIntSubset(doc, (xmlChar *)"project", NULL, (xmlChar *)"project.dtd");
 661   // create project node
 662   doc->children->next = xmlNewDocNode(doc, NULL, (xmlChar *)"project", NULL);
 663
 664   for(epair_t* epair = g_qeglobals.d_project_entity->epairs; epair != NULL; epair = epair->next)
 665   {
 666     node = xmlNewChild(doc->children->next, NULL, (xmlChar *)"key", NULL);
 667     xmlSetProp(node, (xmlChar*)"name", (xmlChar*)epair->key);
 668     xmlSetProp(node, (xmlChar*)"value", (xmlChar*)epair->value);
 669   }
 670
 671   CreateDirectoryPath(filename);
 672   if (xmlSaveFormatFile(filename, doc, 1) != -1)
 673   {
 674     xmlFreeDoc(doc);
 675     Sys_Printf("Setting current project in prefs to \"%s\"\n", filename );
 676     g_PrefsDlg.m_strLastProject = filename;
 677     g_PrefsDlg.SavePrefs();
 678     return TRUE;
 679   }
 680   else
 681   {
 682     xmlFreeDoc(doc);
 683     Sys_FPrintf(SYS_ERR, "failed to save project file: \"%s\"\n", filename);
 684     return FALSE;
 685   }
 686 }
 687
 688
 689
 690 /*
 691 ===========
 692 QE_KeyDown
 693 ===========
 694 */
 695 #define SPEED_MOVE      32
 696 #define SPEED_TURN      22.5
 697
 698
 699 /*
 700 ===============
 701 ConnectEntities
 702
 703 Sets target / targetname on the two entities selected
 704 from the first selected to the secon
 705 ===============
 706 */
 707 void ConnectEntities (void)
 708 {
 709         entity_t        *e1, *e2;
 710         const char              *target;
 711         char            *newtarg = NULL;
 712
 713         if (g_qeglobals.d_select_count != 2)
 714         {
 715                 Sys_Status ("Must have two brushes selected", 0);
 716                 Sys_Beep ();
 717                 return;
 718         }
 719
 720         e1 = g_qeglobals.d_select_order[0]->owner;
 721         e2 = g_qeglobals.d_select_order[1]->owner;
 722
 723         if (e1 == world_entity || e2 == world_entity)
 724         {
 725                 Sys_Status ("Can't connect to the world", 0);
 726                 Sys_Beep ();
 727                 return;
 728         }
 729
 730         if (e1 == e2)
 731         {
 732                 Sys_Status ("Brushes are from same entity", 0);
 733                 Sys_Beep ();
 734                 return;
 735         }
 736
 737   target = ValueForKey (e1, "target");
 738   if (target && target[0])
 739     newtarg = g_strdup(target);
 740   else
 741   {
 742     target = ValueForKey(e2, "targetname");
 743     if(target && target[0])
 744       newtarg = g_strdup(target);
 745     else
 746       Entity_Connect(e1, e2);
 747   }
 748
 749   if(newtarg != NULL)
 750   {
 751     SetKeyValue(e1, "target", newtarg);
 752     SetKeyValue(e2, "targetname", newtarg);
 753     g_free(newtarg);
 754   }
 755
 756         Sys_UpdateWindows (W_XY | W_CAMERA);
 757
 758         Select_Deselect();
 759         Select_Brush (g_qeglobals.d_select_order[1]);
 760 }
 761
 762 qboolean QE_SingleBrush (bool bQuiet)
 763 {
 764         if ( (selected_brushes.next == &selected_brushes)
 765                 || (selected_brushes.next->next != &selected_brushes) )
 766         {
 767           if (!bQuiet)
 768     {
 769                 Sys_Printf ("Error: you must have a single brush selected\n");
 770           }
 771                 return false;
 772         }
 773         if (selected_brushes.next->owner->eclass->fixedsize)
 774         {
 775           if (!bQuiet)
 776           {
 777                   Sys_Printf ("Error: you cannot manipulate fixed size entities\n");
 778           }
 779                 return false;
 780         }
 781
 782         return true;
 783 }
 784
 785 void QE_InitVFS (void)
 786 {
 787   // VFS initialization -----------------------
 788   // we will call vfsInitDirectory, giving the directories to look in (for files in pk3's and for standalone files)
 789   // we need to call in order, the mod ones first, then the base ones .. they will be searched in this order
 790   // *nix systems have a dual filesystem in ~/.q3a, which is searched first .. so we need to add that too
 791   Str directory,prefabs;
 792
 793   // TTimo: let's leave this to HL mode for now
 794   if (g_pGameDescription->mGameFile == "hl.game")
 795   {
 796     // Hydra: we search the "gametools" path first so that we can provide editor
 797     // specific pk3's wads and misc files for use by the editor.
 798     // the relevant map compiler tools will NOT use this directory, so this helps
 799     // to ensure that editor files are not used/required in release versions of maps
 800     // it also helps keep your editor files all in once place, with the editor modules,
 801     // plugins, scripts and config files.
 802     // it also helps when testing maps, as you'll know your files won't/can't be used
 803     // by the game engine itself.
 804
 805     // <gametools>
 806     directory = g_pGameDescription->mGameToolsPath;
 807     vfsInitDirectory(directory.GetBuffer());
 808   }
 809
 810   // NOTE TTimo about the mymkdir calls .. this is a bit dirty, but a safe thing on *nix
 811
 812   // if we have a mod dir
 813   if (*ValueForKey(g_qeglobals.d_project_entity, "gamename") != '\0')
 814   {
 815
 816 #if defined (__linux__) || defined (__APPLE__)
 817     // ~/.<gameprefix>/<fs_game>
 818     directory = g_qeglobals.m_strHomeGame.GetBuffer();
 819     Q_mkdir (directory.GetBuffer (), 0775);
 820     directory += ValueForKey(g_qeglobals.d_project_entity, "gamename");
 821     Q_mkdir (directory.GetBuffer (), 0775);
 822     vfsInitDirectory(directory.GetBuffer());
 823     AddSlash (directory);
 824     prefabs = directory;
 825     // also create the maps dir, it will be used as prompt for load/save
 826     directory += "/maps";
 827     Q_mkdir (directory, 0775);
 828     // and the prefabs dir
 829     prefabs += "/prefabs";
 830     Q_mkdir (prefabs, 0775);
 831
 832 #endif
 833
 834     // <fs_basepath>/<fs_game>
 835     directory = g_pGameDescription->mEnginePath;
 836     directory += ValueForKey(g_qeglobals.d_project_entity, "gamename");
 837     Q_mkdir (directory.GetBuffer (), 0775);
 838     vfsInitDirectory(directory.GetBuffer());
 839     AddSlash(directory);
 840     prefabs = directory;
 841     // also create the maps dir, it will be used as prompt for load/save
 842     directory += "/maps";
 843     Q_mkdir (directory.GetBuffer (), 0775);
 844     // and the prefabs dir
 845     prefabs += "/prefabs";
 846     Q_mkdir (prefabs, 0775);
 847   }
 848
 849 #if defined (__linux__) || defined (__APPLE__)
 850   // ~/.<gameprefix>/<fs_main>
 851   directory = g_qeglobals.m_strHomeGame.GetBuffer();
 852   directory += g_pGameDescription->mBaseGame;
 853   vfsInitDirectory (directory.GetBuffer ());
 854 #endif
 855
 856   // <fs_basepath>/<fs_main>
 857   directory = g_pGameDescription->mEnginePath;
 858   directory += g_pGameDescription->mBaseGame;
 859   vfsInitDirectory(directory.GetBuffer());
 860 }
 861
 862 void QE_Init (void)
 863 {
 864         /*
 865         ** initialize variables
 866         */
 867         g_qeglobals.d_gridsize = 8;
 868         g_qeglobals.d_showgrid = true;
 869
 870   QE_InitVFS();
 871
 872   Eclass_Init();
 873   FillClassList();              // list in entity window
 874   Map_Init();
 875
 876   FillTextureMenu();
 877   FillBSPMenu();
 878
 879         /*
 880         ** other stuff
 881         */
 882         Z_Init ();
 883 }
 884
 885 void WINAPI QE_ConvertDOSToUnixName( char *dst, const char *src )
 886 {
 887         while ( *src )
 888         {
 889                 if ( *src == '\\' )
 890                         *dst = '/';
 891                 else
 892                         *dst = *src;
 893                 dst++; src++;
 894         }
 895         *dst = 0;
 896 }
 897
 898 int g_numbrushes, g_numentities;
 899
 900 void QE_CountBrushesAndUpdateStatusBar( void )
 901 {
 902         static int      s_lastbrushcount, s_lastentitycount;
 903         static qboolean s_didonce;
 904
 905         //entity_t   *e;
 906         brush_t    *b, *next;
 907
 908         g_numbrushes = 0;
 909         g_numentities = 0;
 910
 911         if ( active_brushes.next != NULL )
 912         {
 913                 for ( b = active_brushes.next ; b != NULL && b != &active_brushes ; b=next)
 914                 {
 915                         next = b->next;
 916                         if (b->brush_faces )
 917                         {
 918                                 if ( !b->owner->eclass->fixedsize)
 919                                         g_numbrushes++;
 920                                 else
 921                                         g_numentities++;
 922                         }
 923                 }
 924         }
 925 /*
 926         if ( entities.next != NULL )
 927         {
 928                 for ( e = entities.next ; e != &entities && g_numentities != MAX_MAP_ENTITIES ; e = e->next)
 929                 {
 930                         g_numentities++;
 931                 }
 932         }
 933 */
 934         if ( ( ( g_numbrushes != s_lastbrushcount ) || ( g_numentities != s_lastentitycount ) ) || ( !s_didonce ) )
 935         {
 936                 Sys_UpdateStatusBar();
 937
 938                 s_lastbrushcount = g_numbrushes;
 939                 s_lastentitycount = g_numentities;
 940                 s_didonce = true;
 941         }
 942 }
 943
 944 char            com_token[1024];
 945 qboolean        com_eof;
 946
 947 /*
 948 ================
 949 I_FloatTime
 950 ================
 951 */
 952 double I_FloatTime (void)
 953 {
 954         time_t  t;
 955
 956         time (&t);
 957
 958         return t;
 959 #if 0
 960 // more precise, less portable
 961         struct timeval tp;
 962         struct timezone tzp;
 963         static int              secbase;
 964
 965         gettimeofday(&tp, &tzp);
 966
 967         if (!secbase)
 968         {
 969                 secbase = tp.tv_sec;
 970                 return tp.tv_usec/1000000.0;
 971         }
 972
 973         return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
 974 #endif
 975 }
 976
 977
 978 /*
 979 ==============
 980 COM_Parse
 981
 982 Parse a token out of a string
 983 ==============
 984 */
 985 char *COM_Parse (char *data)
 986 {
 987         int             c;
 988         int             len;
 989
 990         len = 0;
 991         com_token[0] = 0;
 992
 993         if (!data)
 994                 return NULL;
 995
 996 // skip whitespace
 997 skipwhite:
 998         while ( (c = *data) <= ' ')
 999         {
1000                 if (c == 0)
1001                 {
1002                         com_eof = true;
1003                         return NULL;                    // end of file;
1004                 }
1005                 data++;
1006         }
1007
1008 // skip // comments
1009         if (c=='/' && data[1] == '/')
1010         {
1011                 while (*data && *data != '\n')
1012                         data++;
1013                 goto skipwhite;
1014         }
1015
1016
1017 // handle quoted strings specially
1018         if (c == '\"')
1019         {
1020                 data++;
1021                 do
1022                 {
1023                         c = *data++;
1024                         if (c=='\"')
1025                         {
1026                                 com_token[len] = 0;
1027                                 return data;
1028                         }
1029                         com_token[len] = c;
1030                         len++;
1031                 } while (1);
1032         }
1033
1034 // parse single characters
1035         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1036         {
1037                 com_token[len] = c;
1038                 len++;
1039                 com_token[len] = 0;
1040                 return data+1;
1041         }
1042
1043 // parse a regular word
1044         do
1045         {
1046                 com_token[len] = c;
1047                 data++;
1048                 len++;
1049                 c = *data;
1050         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1051                         break;
1052         } while (c>32);
1053
1054         com_token[len] = 0;
1055         return data;
1056 }
1057
1058 char* Get_COM_Token()
1059 {
1060   return com_token;
1061 }
1062
1063 /*
1064 =============================================================================
1065
1066                                                 MISC FUNCTIONS
1067
1068 =============================================================================
1069 */
1070
1071
1072 int             argc;
1073 char    *argv[MAX_NUM_ARGVS];
1074
1075 /*
1076 ============
1077 ParseCommandLine
1078 ============
1079 */
1080 void ParseCommandLine (char *lpCmdLine)
1081 {
1082         argc = 1;
1083         argv[0] = "programname";
1084
1085         while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
1086         {
1087                 while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
1088                         lpCmdLine++;
1089
1090                 if (*lpCmdLine)
1091                 {
1092                         argv[argc] = lpCmdLine;
1093                         argc++;
1094
1095                         while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
1096                                 lpCmdLine++;
1097
1098                         if (*lpCmdLine)
1099                         {
1100                                 *lpCmdLine = 0;
1101                                 lpCmdLine++;
1102                         }
1103
1104                 }
1105         }
1106 }
1107
1108
1109
1110 /*
1111 =================
1112 CheckParm
1113
1114 Checks for the given parameter in the program's command line arguments
1115 Returns the argument number (1 to argc-1) or 0 if not present
1116 =================
1117 */
1118 int CheckParm (const char *check)
1119 {
1120         int             i;
1121
1122         for (i = 1;i<argc;i++)
1123         {
1124                 if ( stricmp(check, argv[i]) )
1125                         return i;
1126         }
1127
1128         return 0;
1129 }
1130
1131
1132
1133
1134 /*
1135 ==============
1136 ParseNum / ParseHex
1137 ==============
1138 */
1139 int ParseHex (const char *hex)
1140 {
1141         const char    *str;
1142         int    num;
1143
1144         num = 0;
1145         str = hex;
1146
1147         while (*str)
1148         {
1149                 num <<= 4;
1150                 if (*str >= '0' && *str <= '9')
1151                         num += *str-'0';
1152                 else if (*str >= 'a' && *str <= 'f')
1153                         num += 10 + *str-'a';
1154                 else if (*str >= 'A' && *str <= 'F')
1155                         num += 10 + *str-'A';
1156                 else
1157                         Error ("Bad hex number: %s",hex);
1158                 str++;
1159         }
1160
1161         return num;
1162 }
1163
1164
1165 int ParseNum (const char *str)
1166 {
1167         if (str[0] == '$')
1168                 return ParseHex (str+1);
1169         if (str[0] == '0' && str[1] == 'x')
1170                 return ParseHex (str+2);
1171         return atol (str);
1172 }
1173
1174 // BSP frontend plugin
1175 // global flag for BSP frontend plugin is g_qeglobals.bBSPFrontendPlugin
1176 _QERPlugBSPFrontendTable g_BSPFrontendTable;
1177
1178 // =============================================================================
1179 // Sys_ functions
1180
1181 bool Sys_AltDown ()
1182 {
1183 #ifdef _WIN32
1184   return (GetKeyState(VK_MENU) & 0x8000) != 0;
1185 #endif
1186
1187 #if defined (__linux__) || defined (__APPLE__)
1188   char keys[32];
1189   int x;
1190
1191   XQueryKeymap(GDK_DISPLAY(), keys);
1192
1193   x = XKeysymToKeycode (GDK_DISPLAY(), XK_Alt_L);
1194   if (keys[x/8] & (1 << (x % 8)))
1195     return true;
1196
1197   x = XKeysymToKeycode (GDK_DISPLAY(), XK_Alt_R);
1198   if (keys[x/8] & (1 << (x % 8)))
1199     return true;
1200
1201   return false;
1202 #endif
1203 }
1204
1205 bool Sys_ShiftDown ()
1206 {
1207 #ifdef _WIN32
1208   return (GetKeyState(VK_SHIFT) & 0x8000) != 0;
1209 #endif
1210
1211 #if defined (__linux__) || defined (__APPLE__)
1212   char keys[32];
1213   int x;
1214
1215   XQueryKeymap(GDK_DISPLAY(), keys);
1216
1217   x = XKeysymToKeycode (GDK_DISPLAY(), XK_Shift_L);
1218   if (keys[x/8] & (1 << (x % 8)))
1219     return true;
1220
1221   x = XKeysymToKeycode (GDK_DISPLAY(), XK_Shift_R);
1222   if (keys[x/8] & (1 << (x % 8)))
1223     return true;
1224
1225   return false;
1226 #endif
1227 }
1228
1229 void Sys_MarkMapModified (void)
1230 {
1231   char title[PATH_MAX];
1232
1233   if (modified != 1)
1234   {
1235     modified = true;    // mark the map as changed
1236     sprintf (title, "%s *", currentmap);
1237
1238     QE_ConvertDOSToUnixName( title, title );
1239     Sys_SetTitle (title);
1240   }
1241 }
1242
1243 void Sys_SetTitle (const char *text)
1244 {
1245   gtk_window_set_title (GTK_WINDOW (g_qeglobals_gui.d_main_window), text);
1246 }
1247
1248 bool g_bWaitCursor = false;
1249
1250 void WINAPI Sys_BeginWait (void)
1251 {
1252   GdkCursor *cursor = gdk_cursor_new (GDK_WATCH);
1253   gdk_window_set_cursor (g_pParentWnd->m_pWidget->window, cursor);
1254   gdk_cursor_unref (cursor);
1255   g_bWaitCursor = true;
1256 }
1257
1258 void WINAPI Sys_EndWait (void)
1259 {
1260   GdkCursor *cursor = gdk_cursor_new (GDK_LEFT_PTR);
1261   gdk_window_set_cursor (g_pParentWnd->m_pWidget->window, cursor);
1262   gdk_cursor_unref (cursor);
1263   g_bWaitCursor = false;
1264 }
1265
1266 void Sys_GetCursorPos (int *x, int *y)
1267 {
1268   // FIXME: not multihead safe
1269   gdk_window_get_pointer (NULL, x, y, NULL);
1270 }
1271
1272 void Sys_SetCursorPos (int x, int y)
1273 {
1274   // NOTE: coordinates are in GDK space, not OS space
1275 #ifdef _WIN32
1276   int sys_x = x - g_pParentWnd->GetGDKOffsetX();
1277   int sys_y = y - g_pParentWnd->GetGDKOffsetY();
1278
1279   SetCursorPos (sys_x, sys_y);
1280 #endif
1281
1282 #if defined (__linux__) || defined (__APPLE__)
1283   XWarpPointer (GDK_DISPLAY(), None, GDK_ROOT_WINDOW(), 0, 0, 0, 0, x, y);
1284 #endif
1285 }
1286
1287 void Sys_Beep (void)
1288 {
1289 #if defined (__linux__) || defined (__APPLE__)
1290   gdk_beep ();
1291 #else
1292         MessageBeep (MB_ICONASTERISK);
1293 #endif
1294 }
1295
1296 double Sys_DoubleTime (void)
1297 {
1298   return clock()/ 1000.0;
1299 }
1300
1301 /*
1302 ===============================================================
1303
1304   STATUS WINDOW
1305
1306 ===============================================================
1307 */
1308
1309 void Sys_UpdateStatusBar( void )
1310 {
1311   extern int   g_numbrushes, g_numentities;
1312
1313   char numbrushbuffer[100]="";
1314
1315   sprintf( numbrushbuffer, "Brushes: %d Entities: %d", g_numbrushes, g_numentities );
1316   g_pParentWnd->SetStatusText(2, numbrushbuffer);
1317   //Sys_Status( numbrushbuffer, 2 );
1318 }
1319
1320 void Sys_Status(const char *psz, int part )
1321 {
1322   g_pParentWnd->SetStatusText (part, psz);
1323 }
1324
1325 // =============================================================================
1326 // MRU
1327
1328 #define MRU_MAX 4
1329 static GtkWidget *MRU_items[MRU_MAX];
1330 static int MRU_used;
1331 typedef char MRU_filename_t[PATH_MAX];
1332 MRU_filename_t MRU_filenames[MRU_MAX];
1333
1334 static char* MRU_GetText (int index)
1335 {
1336   return MRU_filenames[index];
1337 }
1338
1339 void buffer_write_escaped_mnemonic(char* buffer, const char* string)
1340 {
1341   while(*string != '\0')
1342   {
1343     if(*string == '_')
1344     {
1345       *buffer++ = '_';
1346     }
1347
1348     *buffer++ = *string++;
1349   }
1350   *buffer = '\0';
1351 }
1352
1353 static void MRU_SetText (int index, const char *filename)
1354 {
1355   strcpy(MRU_filenames[index], filename);
1356
1357   char mnemonic[PATH_MAX * 2 + 4];
1358   mnemonic[0] = '_';
1359   sprintf(mnemonic+1, "%d", index+1);
1360   mnemonic[2] = '-';
1361   mnemonic[3] = ' ';
1362   buffer_write_escaped_mnemonic(mnemonic+4, filename);
1363   gtk_label_set_text_with_mnemonic(GTK_LABEL (GTK_BIN (MRU_items[index])->child), mnemonic);
1364 }
1365
1366 void MRU_Load ()
1367 {
1368   int i = g_PrefsDlg.m_nMRUCount;
1369
1370   if(i > 4)
1371     i = 4; //FIXME: make this a define
1372
1373   for (; i > 0; i--)
1374     MRU_AddFile (g_PrefsDlg.m_strMRUFiles[i-1].GetBuffer());
1375 }
1376
1377 void MRU_Save ()
1378 {
1379   g_PrefsDlg.m_nMRUCount = MRU_used;
1380
1381   for (int i = 0; i < MRU_used; i++)
1382     g_PrefsDlg.m_strMRUFiles[i] = MRU_GetText (i);
1383 }
1384
1385 void MRU_AddWidget (GtkWidget *widget, int pos)
1386 {
1387   if (pos < MRU_MAX)
1388     MRU_items[pos] = widget;
1389 }
1390
1391 void MRU_AddFile (const char *str)
1392 {
1393   int i;
1394   char* text;
1395
1396   // check if file is already in our list
1397   for (i = 0; i < MRU_used; i++)
1398   {
1399     text = MRU_GetText (i);
1400
1401     if (strcmp (text, str) == 0)
1402     {
1403       // reorder menu
1404       for (; i > 0; i--)
1405         MRU_SetText (i, MRU_GetText (i-1));
1406
1407       MRU_SetText (0, str);
1408
1409       return;
1410     }
1411   }
1412
1413   if (MRU_used < MRU_MAX)
1414     MRU_used++;
1415
1416   // move items down
1417   for (i = MRU_used-1; i > 0; i--)
1418     MRU_SetText (i, MRU_GetText (i-1));
1419
1420   MRU_SetText (0, str);
1421   gtk_widget_set_sensitive (MRU_items[0], TRUE);
1422   gtk_widget_show (MRU_items[MRU_used-1]);
1423 }
1424
1425 void MRU_Activate (int index)
1426 {
1427   char *text = MRU_GetText (index);
1428
1429   if (access (text, R_OK) == 0)
1430   {
1431     text = strdup (text);
1432     MRU_AddFile (text);
1433     Map_LoadFile (text);
1434     free (text);
1435   }
1436   else
1437   {
1438     MRU_used--;
1439
1440     for (int i = index; i < MRU_used; i++)
1441       MRU_SetText (i, MRU_GetText (i+1));
1442
1443     if (MRU_used == 0)
1444     {
1445       gtk_label_set_text (GTK_LABEL (GTK_BIN (MRU_items[0])->child), "Recent Files");
1446       gtk_widget_set_sensitive (MRU_items[0], FALSE);
1447     }
1448     else
1449     {
1450       gtk_widget_hide (MRU_items[MRU_used]);
1451     }
1452   }
1453 }
1454
1455 /*
1456 ======================================================================
1457
1458 FILE DIALOGS
1459
1460 ======================================================================
1461 */
1462
1463 qboolean ConfirmModified ()
1464 {
1465   if (!modified)
1466     return true;
1467
1468   if (gtk_MessageBox (g_pParentWnd->m_pWidget, "This will lose changes to the map", "warning", MB_OKCANCEL) == IDCANCEL)
1469     return false;
1470   return true;
1471 }
1472
1473 void ProjectDialog ()
1474 {
1475   const char *filename;
1476   char buffer[NAME_MAX];
1477
1478   /*
1479    * Obtain the system directory name and
1480    * store it in buffer.
1481    */
1482
1483   strcpy(buffer, g_qeglobals.m_strHomeGame.GetBuffer());
1484   strcat(buffer, g_pGameDescription->mBaseGame.GetBuffer());
1485   strcat (buffer, "/scripts/");
1486
1487   // Display the Open dialog box
1488   filename = file_dialog (NULL, TRUE, _("Open File"), buffer, "project");
1489
1490   if (filename == NULL)
1491     return;     // canceled
1492
1493   // Open the file.
1494   // NOTE: QE_LoadProject takes care of saving prefs with new path to the project file
1495   if (!QE_LoadProject(filename))
1496     Sys_Printf ("Failed to load project from file: %s\n", filename);
1497   else
1498     // FIXME TTimo QE_Init is probably broken if you don't call it during startup right now ..
1499     QE_Init();
1500 }
1501
1502 /*
1503 =======================================================
1504
1505 Menu modifications
1506
1507 =======================================================
1508 */
1509
1510 /*
1511 ==================
1512 FillBSPMenu
1513
1514 ==================
1515 */
1516 char *bsp_commands[256];
1517
1518 void FillBSPMenu ()
1519 {
1520   GtkWidget *item, *menu; // menu points to a GtkMenu (not an item)
1521   epair_t *ep;
1522   GList *lst;
1523   int i;
1524
1525   menu = GTK_WIDGET (g_object_get_data (G_OBJECT (g_qeglobals_gui.d_main_window), "menu_bsp"));
1526
1527   while ((lst = gtk_container_children (GTK_CONTAINER (menu))) != NULL)
1528     gtk_container_remove (GTK_CONTAINER (menu), GTK_WIDGET (lst->data));
1529
1530   if (g_PrefsDlg.m_bDetachableMenus) {
1531     item = gtk_tearoff_menu_item_new ();
1532     gtk_menu_append (GTK_MENU (menu), item);
1533     gtk_widget_set_sensitive (item, TRUE);
1534     gtk_widget_show (item);
1535   }
1536
1537   if (g_qeglobals.bBSPFrontendPlugin)
1538   {
1539     CString str = g_BSPFrontendTable.m_pfnGetBSPMenu();
1540     char cTemp[1024];
1541     strcpy(cTemp, str);
1542     char* token = strtok(cTemp, ",;");
1543     if (token && *token == ' ')
1544     {
1545       while (*token == ' ')
1546         token++;
1547     }
1548     i = 0;
1549
1550     // first token is menu name
1551     item = gtk_menu_get_attach_widget (GTK_MENU (menu));
1552     gtk_label_set_text (GTK_LABEL (GTK_BIN (item)->child), token);
1553
1554     token = strtok(NULL, ",;");
1555     while (token != NULL)
1556     {
1557       g_BSPFrontendCommands = g_slist_append (g_BSPFrontendCommands, g_strdup (token));
1558       item = gtk_menu_item_new_with_label (token);
1559       gtk_widget_show (item);
1560       gtk_container_add (GTK_CONTAINER (menu), item);
1561       gtk_signal_connect (GTK_OBJECT (item), "activate",
1562                           GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (CMD_BSPCOMMAND+i));
1563       token = strtok(NULL, ",;");
1564       i++;
1565     }
1566   }
1567   else
1568   {
1569     i = 0;
1570     for (ep = g_qeglobals.d_project_entity->epairs; ep; ep = ep->next)
1571     {
1572       if (strncmp(ep->key, "bsp_", 4)==0)
1573       {
1574         bsp_commands[i] = ep->key;
1575         item = gtk_menu_item_new_with_label (ep->key+4);
1576         gtk_widget_show (item);
1577         gtk_container_add (GTK_CONTAINER (menu), item);
1578         gtk_signal_connect (GTK_OBJECT (item), "activate",
1579           GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (CMD_BSPCOMMAND+i));
1580         i++;
1581       }
1582     }
1583   }
1584 }
1585
1586 //==============================================
1587
1588 void AddSlash(CString& strPath)
1589 {
1590   if (strPath.GetLength() > 0)
1591   {
1592     if ((strPath.GetAt(strPath.GetLength()-1) != '/') &&
1593         (strPath.GetAt(strPath.GetLength()-1) != '\\'))
1594       strPath += '/';
1595   }
1596 }
1597
1598 bool ExtractPath_and_Filename(const char* pPath, CString& strPath, CString& strFilename)
1599 {
1600   CString strPathName;
1601   strPathName = pPath;
1602   int nSlash = strPathName.ReverseFind('\\');
1603   if (nSlash == -1)
1604     // TTimo: try forward slash, some are using forward
1605     nSlash = strPathName.ReverseFind('/');
1606   if (nSlash >= 0)
1607   {
1608     strPath = strPathName.Left(nSlash+1);
1609     strFilename = strPathName.Right(strPathName.GetLength() - nSlash - 1);
1610   }
1611   // TTimo: try forward slash, some are using forward
1612   else
1613     strFilename = pPath;
1614   return true;
1615 }
1616
1617 //===========================================
1618
1619 //++timo FIXME: no longer used .. remove!
1620 char *TranslateString (char *buf)
1621 {
1622   static char   buf2[32768];
1623   int           i, l;
1624   char          *out;
1625
1626   l = strlen(buf);
1627   out = buf2;
1628   for (i=0 ; i<l ; i++)
1629   {
1630     if (buf[i] == '\n')
1631     {
1632       *out++ = '\r';
1633       *out++ = '\n';
1634     }
1635     else
1636       *out++ = buf[i];
1637   }
1638   *out++ = 0;
1639
1640   return buf2;
1641 }
1642
1643 // called whenever we need to open/close/check the console log file
1644 void Sys_LogFile (void)
1645 {
1646   if (g_PrefsDlg.mGamesDialog.m_bLogConsole && !g_qeglobals.hLogFile)
1647   {
1648         // settings say we should be logging and we don't have a log file .. so create it
1649     // open a file to log the console (if user prefs say so)
1650     // the file handle is g_qeglobals.hLogFile
1651     // the log file is erased
1652     Str name;
1653     name = g_strTempPath;
1654     name += "radiant.log";
1655 #if defined (__linux__) || defined (__APPLE__)
1656     g_qeglobals.hLogFile = open( name.GetBuffer(), O_TRUNC | O_CREAT | O_WRONLY, S_IREAD | S_IWRITE );
1657 #endif
1658 #ifdef _WIN32
1659     g_qeglobals.hLogFile = _open( name.GetBuffer(), _O_TRUNC | _O_CREAT | _O_WRONLY, _S_IREAD | _S_IWRITE );
1660 #endif
1661     if (g_qeglobals.hLogFile)
1662     {
1663       Sys_Printf("Started logging to %s\n", name.GetBuffer());
1664       time_t localtime;
1665       time(&localtime);
1666       Sys_Printf( "Today is: %s", ctime(&localtime));
1667       Sys_Printf( "This is radiant '" RADIANT_VERSION "' compiled " __DATE__ "\n");
1668       Sys_Printf( RADIANT_ABOUTMSG "\n");
1669     }
1670     else
1671       gtk_MessageBox (NULL, "Failed to create log file, check write permissions in Radiant directory.\n",
1672                       "Console logging", MB_OK );
1673   }
1674   else if (!g_PrefsDlg.mGamesDialog.m_bLogConsole && g_qeglobals.hLogFile)
1675   {
1676         // settings say we should not be logging but still we have an active logfile .. close it
1677     time_t localtime;
1678     time(&localtime);
1679     Sys_Printf("Closing log file at %s\n", ctime(&localtime));
1680                 #ifdef _WIN32
1681     _close( g_qeglobals.hLogFile );
1682                 #endif
1683                 #if defined (__linux__) || defined (__APPLE__)
1684                 close( g_qeglobals.hLogFile );
1685                 #endif
1686     g_qeglobals.hLogFile = 0;
1687   }
1688 }
1689
1690 void Sys_ClearPrintf (void)
1691 {
1692   GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_qeglobals_gui.d_edit));
1693   gtk_text_buffer_set_text(buffer, "", -1);
1694 }
1695
1696 // used to be around 32000, that should be way enough already
1697 #define BUFFER_SIZE 4096
1698
1699 extern "C" void Sys_FPrintf_VA( int level, const char *text, va_list args ) {
1700   char buf[BUFFER_SIZE];
1701
1702   buf[0] = 0;
1703   vsnprintf( buf, BUFFER_SIZE, text, args );
1704   buf[BUFFER_SIZE-1] = 0;
1705   const unsigned int length = strlen(buf);
1706
1707   if ( g_qeglobals.hLogFile ) {
1708 #ifdef _WIN32
1709     _write( g_qeglobals.hLogFile, buf, length );
1710     _commit( g_qeglobals.hLogFile );
1711 #endif
1712 #if defined (__linux__) || defined (__APPLE__)
1713     write( g_qeglobals.hLogFile, buf, length );
1714 #endif
1715   }
1716
1717   if ( level != SYS_NOCON ) {
1718     // TTimo: FIXME: killed the console to avoid GDI leak fuckup
1719     if ( g_qeglobals_gui.d_edit != NULL ) {
1720       GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_qeglobals_gui.d_edit));
1721
1722       GtkTextIter iter;
1723       gtk_text_buffer_get_end_iter(buffer, &iter);
1724
1725       static GtkTextMark* end = gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
1726
1727       const GdkColor yellow = { 0, 0xb0ff, 0xb0ff, 0x0000 };
1728       const GdkColor red = { 0, 0xffff, 0x0000, 0x0000 };
1729       const GdkColor black = { 0, 0x0000, 0x0000, 0x0000 };
1730
1731       static GtkTextTag* error_tag = gtk_text_buffer_create_tag (buffer, "red_foreground", "foreground-gdk", &red, NULL);
1732       static GtkTextTag* warning_tag = gtk_text_buffer_create_tag (buffer, "yellow_foreground", "foreground-gdk", &yellow, NULL);
1733       static GtkTextTag* standard_tag = gtk_text_buffer_create_tag (buffer, "black_foreground", "foreground-gdk", &black, NULL);
1734       GtkTextTag* tag;
1735       switch (level)
1736       {
1737       case SYS_WRN:
1738         tag = warning_tag;
1739         break;
1740       case SYS_ERR:
1741         tag = error_tag;
1742         break;
1743       case SYS_STD:
1744       case SYS_VRB:
1745       default:
1746         tag = standard_tag;
1747         break;
1748       }
1749       gtk_text_buffer_insert_with_tags(buffer, &iter, buf, length, tag, NULL);
1750
1751       gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(g_qeglobals_gui.d_edit), end);
1752
1753       // update console widget immediatly if we're doing something time-consuming
1754       if( !g_bScreenUpdates && GTK_WIDGET_REALIZED( g_qeglobals_gui.d_edit ) )
1755       {
1756         gtk_grab_add(g_qeglobals_gui.d_edit);
1757
1758         while(gtk_events_pending())
1759           gtk_main_iteration();
1760
1761         gtk_grab_remove(g_qeglobals_gui.d_edit);
1762       }
1763     }
1764   }
1765 }
1766
1767 // NOTE: this is the handler sent to synapse
1768 // must match PFN_SYN_PRINTF_VA
1769 extern "C" void Sys_Printf_VA (const char *text, va_list args)
1770 {
1771   Sys_FPrintf_VA (SYS_STD, text, args);
1772 }
1773
1774 extern "C" void Sys_Printf( const char *text, ... ) {
1775   va_list args;
1776
1777   va_start( args, text );
1778   Sys_FPrintf_VA( SYS_STD, text, args );
1779   va_end( args );
1780 }
1781
1782 extern "C" void Sys_FPrintf (int level, const char *text, ...)
1783 {
1784   va_list args;
1785
1786   va_start (args, text);
1787   Sys_FPrintf_VA (level, text, args);
1788   va_end (args);
1789 }