radiant/preferences.cpp

   1 /*
   2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3    For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 //
  23 // User preferences
  24 //
  25 // Leonardo Zide (leo@lokigames.com)
  26 //
  27
  28 #include "preferences.h"
  29 #include "globaldefs.h"
  30
  31 #include <gtk/gtk.h>
  32 #include "environment.h"
  33
  34 #include "debugging/debugging.h"
  35
  36 #include "generic/callback.h"
  37 #include "math/vector.h"
  38 #include "string/string.h"
  39 #include "stream/stringstream.h"
  40 #include "os/file.h"
  41 #include "os/path.h"
  42 #include "os/dir.h"
  43 #include "gtkutil/filechooser.h"
  44 #include "gtkutil/messagebox.h"
  45 #include "cmdlib.h"
  46
  47 #include "error.h"
  48 #include "console.h"
  49 #include "xywindow.h"
  50 #include "mainframe.h"
  51 #include "qe3.h"
  52 #include "gtkdlgs.h"
  53
  54
  55
  56 void Global_constructPreferences( PreferencesPage& page ){
  57         page.appendCheckBox( "Console", "Enable Logging", g_Console_enableLogging );
  58 }
  59
  60 void Interface_constructPreferences( PreferencesPage& page ){
  61 #if GDEF_OS_WINDOWS
  62         page.appendCheckBox( "", "Default Text Editor", g_TextEditor_useWin32Editor );
  63 #else
  64         {
  65                 ui::CheckButton use_custom = page.appendCheckBox( "Text Editor", "Custom", g_TextEditor_useCustomEditor );
  66                 ui::Widget custom_editor = page.appendPathEntry( "Text Editor Command", g_TextEditor_editorCommand, true );
  67                 Widget_connectToggleDependency( custom_editor, use_custom );
  68         }
  69 #endif
  70 }
  71
  72 void Mouse_constructPreferences( PreferencesPage& page ){
  73         {
  74                 const char* buttons[] = { "2 button", "3 button", };
  75                 page.appendRadio( "Mouse Type",  g_glwindow_globals.m_nMouseType, STRING_ARRAY_RANGE( buttons ) );
  76         }
  77         page.appendCheckBox( "Right Button", "Activates Context Menu", g_xywindow_globals.m_bRightClick );
  78 }
  79 void Mouse_constructPage( PreferenceGroup& group ){
  80         PreferencesPage page( group.createPage( "Mouse", "Mouse Preferences" ) );
  81         Mouse_constructPreferences( page );
  82 }
  83 void Mouse_registerPreferencesPage(){
  84         PreferencesDialog_addInterfacePage( makeCallbackF(Mouse_constructPage) );
  85 }
  86
  87
  88 /*!
  89    =========================================================
  90    Games selection dialog
  91    =========================================================
  92  */
  93
  94 #include <map>
  95 #include <uilib/uilib.h>
  96
  97 inline const char* xmlAttr_getName( xmlAttrPtr attr ){
  98         return reinterpret_cast<const char*>( attr->name );
  99 }
 100
 101 inline const char* xmlAttr_getValue( xmlAttrPtr attr ){
 102         return reinterpret_cast<const char*>( attr->children->content );
 103 }
 104
 105 CGameDescription::CGameDescription( xmlDocPtr pDoc, const CopiedString& gameFile ){
 106         // read the user-friendly game name
 107         xmlNodePtr pNode = pDoc->children;
 108
 109         while ( strcmp( (const char*)pNode->name, "game" ) && pNode != 0 )
 110         {
 111                 pNode = pNode->next;
 112         }
 113         if ( !pNode ) {
 114                 Error( "Didn't find 'game' node in the game description file '%s'\n", pDoc->URL );
 115         }
 116
 117         for ( xmlAttrPtr attr = pNode->properties; attr != 0; attr = attr->next )
 118         {
 119                 m_gameDescription.insert( GameDescription::value_type( xmlAttr_getName( attr ), xmlAttr_getValue( attr ) ) );
 120         }
 121
 122         {
 123                 StringOutputStream path( 256 );
 124                 path << DataPath_get() << "gamepacks/" << gameFile.c_str() << "/";
 125                 mGameToolsPath = path.c_str();
 126         }
 127
 128         ASSERT_MESSAGE( file_exists( mGameToolsPath.c_str() ), "game directory not found: " << makeQuoted( mGameToolsPath.c_str() ) );
 129
 130         mGameFile = gameFile;
 131
 132         {
 133                 GameDescription::iterator i = m_gameDescription.find( "type" );
 134                 if ( i == m_gameDescription.end() ) {
 135                         globalErrorStream() << "Warning, 'type' attribute not found in '" << reinterpret_cast<const char*>( pDoc->URL ) << "'\n";
 136                         // default
 137                         mGameType = "q3";
 138                 }
 139                 else
 140                 {
 141                         mGameType = ( *i ).second.c_str();
 142                 }
 143         }
 144 }
 145
 146 void CGameDescription::Dump(){
 147         globalOutputStream() << "game description file: " << makeQuoted( mGameFile.c_str() ) << "\n";
 148         for ( GameDescription::iterator i = m_gameDescription.begin(); i != m_gameDescription.end(); ++i )
 149         {
 150                 globalOutputStream() << ( *i ).first.c_str() << " = " << makeQuoted( ( *i ).second.c_str() ) << "\n";
 151         }
 152 }
 153
 154 CGameDescription *g_pGameDescription; ///< shortcut to g_GamesDialog.m_pCurrentDescription
 155
 156
 157 #include "warnings.h"
 158 #include "stream/textfilestream.h"
 159 #include "container/array.h"
 160 #include "xml/ixml.h"
 161 #include "xml/xmlparser.h"
 162 #include "xml/xmlwriter.h"
 163
 164 #include "preferencedictionary.h"
 165 #include "stringio.h"
 166
 167 const char* const PREFERENCES_VERSION = "1.0";
 168
 169 bool Preferences_Load( PreferenceDictionary& preferences, const char* filename, const char *cmdline_prefix ){
 170         bool ret = false;
 171         TextFileInputStream file( filename );
 172         if ( !file.failed() ) {
 173                 XMLStreamParser parser( file );
 174                 XMLPreferenceDictionaryImporter importer( preferences, PREFERENCES_VERSION );
 175                 parser.exportXML( importer );
 176                 ret = true;
 177         }
 178
 179         int l = strlen( cmdline_prefix );
 180         for ( int i = 1; i < g_argc - 1; ++i )
 181         {
 182                 if ( g_argv[i][0] == '-' ) {
 183                         if ( !strncmp( g_argv[i] + 1, cmdline_prefix, l ) ) {
 184                                 if ( g_argv[i][l + 1] == '-' ) {
 185                                         preferences.importPref( g_argv[i] + l + 2, g_argv[i + 1] );
 186                                 }
 187                         }
 188                         ++i;
 189                 }
 190         }
 191
 192         return ret;
 193 }
 194
 195 bool Preferences_Save( PreferenceDictionary& preferences, const char* filename ){
 196         TextFileOutputStream file( filename );
 197         if ( !file.failed() ) {
 198                 XMLStreamWriter writer( file );
 199                 XMLPreferenceDictionaryExporter exporter( preferences, PREFERENCES_VERSION );
 200                 exporter.exportXML( writer );
 201                 return true;
 202         }
 203         return false;
 204 }
 205
 206 bool Preferences_Save_Safe( PreferenceDictionary& preferences, const char* filename ){
 207         Array<char> tmpName( filename, filename + strlen( filename ) + 1 + 3 );
 208         *( tmpName.end() - 4 ) = 'T';
 209         *( tmpName.end() - 3 ) = 'M';
 210         *( tmpName.end() - 2 ) = 'P';
 211         *( tmpName.end() - 1 ) = '\0';
 212
 213         return Preferences_Save( preferences, tmpName.data() )
 214                    && ( !file_exists( filename ) || file_remove( filename ) )
 215                    && file_move( tmpName.data(), filename );
 216 }
 217
 218
 219 struct LogConsole {
 220         static void Export(const Callback<void(bool)> &returnz) {
 221                 returnz(g_Console_enableLogging);
 222         }
 223
 224         static void Import(bool value) {
 225                 g_Console_enableLogging = value;
 226                 Sys_LogFile(g_Console_enableLogging);
 227         }
 228 };
 229
 230
 231 void RegisterGlobalPreferences( PreferenceSystem& preferences ){
 232         preferences.registerPreference( "gamefile", make_property_string( g_GamesDialog.m_sGameFile ) );
 233         preferences.registerPreference( "gamePrompt", make_property_string( g_GamesDialog.m_bGamePrompt ) );
 234         preferences.registerPreference( "skipGamePromptOnce", make_property_string( g_GamesDialog.m_bSkipGamePromptOnce ) );
 235         preferences.registerPreference( "log console", make_property_string<LogConsole>() );
 236 }
 237
 238
 239 PreferenceDictionary g_global_preferences;
 240
 241 void GlobalPreferences_Init(){
 242         RegisterGlobalPreferences( g_global_preferences );
 243 }
 244
 245 void CGameDialog::LoadPrefs(){
 246         // load global .pref file
 247         StringOutputStream strGlobalPref( 256 );
 248         strGlobalPref << g_Preferences.m_global_rc_path->str << "global.pref";
 249
 250         globalOutputStream() << "loading global preferences from " << makeQuoted( strGlobalPref.c_str() ) << "\n";
 251
 252         if ( !Preferences_Load( g_global_preferences, strGlobalPref.c_str(), "global" ) ) {
 253                 globalOutputStream() << "failed to load global preferences from " << strGlobalPref.c_str() << "\n";
 254         }
 255 }
 256
 257 void CGameDialog::SavePrefs(){
 258         StringOutputStream strGlobalPref( 256 );
 259         strGlobalPref << g_Preferences.m_global_rc_path->str << "global.pref";
 260
 261         globalOutputStream() << "saving global preferences to " << strGlobalPref.c_str() << "\n";
 262
 263         if ( !Preferences_Save_Safe( g_global_preferences, strGlobalPref.c_str() ) ) {
 264                 globalOutputStream() << "failed to save global preferences to " << strGlobalPref.c_str() << "\n";
 265         }
 266 }
 267
 268 void CGameDialog::DoGameDialog(){
 269         // show the UI
 270         DoModal();
 271
 272         // we save the prefs file
 273         SavePrefs();
 274 }
 275
 276 void CGameDialog::GameFileImport( int value ){
 277         m_nComboSelect = value;
 278         // use value to set m_sGameFile
 279         std::list<CGameDescription *>::iterator iGame = mGames.begin();
 280         int i;
 281         for ( i = 0; i < value; i++ )
 282         {
 283                 ++iGame;
 284         }
 285
 286         if ( ( *iGame )->mGameFile != m_sGameFile ) {
 287                 m_sGameFile = ( *iGame )->mGameFile;
 288
 289                 // do not trigger radiant restart when switching game on startup using Global Preferences dialog
 290                 if ( !onStartup ) {
 291                         PreferencesDialog_restartRequired( "Selected Game" );
 292                 }
 293         }
 294
 295         // onStartup can only be true once, when Global Preferences are displayed at startup
 296         onStartup = false;
 297 }
 298
 299 void CGameDialog::GameFileExport( const Callback<void(int)> & importCallback ) const {
 300         // use m_sGameFile to set value
 301         std::list<CGameDescription *>::const_iterator iGame;
 302         int i = 0;
 303         for ( iGame = mGames.begin(); iGame != mGames.end(); ++iGame )
 304         {
 305                 if ( ( *iGame )->mGameFile == m_sGameFile ) {
 306                         m_nComboSelect = i;
 307                         break;
 308                 }
 309                 i++;
 310         }
 311         importCallback( m_nComboSelect );
 312 }
 313
 314 struct CGameDialog_GameFile {
 315         static void Export(const CGameDialog &self, const Callback<void(int)> &returnz) {
 316                 self.GameFileExport(returnz);
 317         }
 318
 319         static void Import(CGameDialog &self, int value) {
 320                 self.GameFileImport(value);
 321         }
 322 };
 323
 324 void CGameDialog::CreateGlobalFrame( PreferencesPage& page ){
 325         std::vector<const char*> games;
 326         games.reserve( mGames.size() );
 327         for ( std::list<CGameDescription *>::iterator i = mGames.begin(); i != mGames.end(); ++i )
 328         {
 329                 games.push_back( ( *i )->getRequiredKeyValue( "name" ) );
 330         }
 331         page.appendCombo(
 332                 "Select the game",
 333                 StringArrayRange( &( *games.begin() ), &( *games.end() ) ),
 334                 make_property<CGameDialog_GameFile>(*this)
 335                 );
 336         page.appendCheckBox( "Startup", "Show Global Preferences", m_bGamePrompt );
 337 }
 338
 339 ui::Window CGameDialog::BuildDialog(){
 340         auto frame = create_dialog_frame( "Game settings", ui::Shadow::ETCHED_IN );
 341
 342         auto vbox2 = create_dialog_vbox( 0, 4 );
 343         frame.add(vbox2);
 344
 345         {
 346                 PreferencesPage preferencesPage( *this, vbox2 );
 347                 Global_constructPreferences( preferencesPage );
 348                 CreateGlobalFrame( preferencesPage );
 349         }
 350
 351         return create_simple_modal_dialog_window( "Global Preferences", m_modal, frame );
 352 }
 353
 354 void CGameDialog::ScanForGames(){
 355         StringOutputStream strGamesPath( 256 );
 356         strGamesPath << DataPath_get() << "gamepacks/games/";
 357         const char *path = strGamesPath.c_str();
 358
 359         globalOutputStream() << "Scanning for game description files: " << path << '\n';
 360
 361         /*!
 362            \todo FIXME LINUX:
 363            do we put game description files below AppPath, or in ~/.radiant
 364            i.e. read only or read/write?
 365            my guess .. readonly cause it's an install
 366            we will probably want to add ~/.radiant/<version>/games/ scanning on top of that for developers
 367            (if that's really needed)
 368          */
 369
 370         Directory_forEach(path, [&](const char *name) {
 371                 if (!extension_equal(path_get_extension(name), "game")) {
 372                         return;
 373                 }
 374                 StringOutputStream strPath(256);
 375                 strPath << path << name;
 376                 globalOutputStream() << strPath.c_str() << '\n';
 377
 378                 xmlDocPtr pDoc = xmlParseFile(strPath.c_str());
 379                 if (pDoc) {
 380                         mGames.push_front(new CGameDescription(pDoc, name));
 381                         xmlFreeDoc(pDoc);
 382                 } else {
 383                         globalErrorStream() << "XML parser failed on '" << strPath.c_str() << "'\n";
 384                 }
 385         });
 386 }
 387
 388 CGameDescription* CGameDialog::GameDescriptionForComboItem(){
 389         std::list<CGameDescription *>::iterator iGame;
 390         int i = 0;
 391         for ( iGame = mGames.begin(); iGame != mGames.end(); ++iGame,i++ )
 392         {
 393                 if ( i == m_nComboSelect ) {
 394                         return ( *iGame );
 395                 }
 396         }
 397         return 0; // not found
 398 }
 399
 400 void CGameDialog::InitGlobalPrefPath(){
 401         g_Preferences.m_global_rc_path = g_string_new( SettingsPath_get() );
 402 }
 403
 404 void CGameDialog::Reset(){
 405         if ( !g_Preferences.m_global_rc_path ) {
 406                 InitGlobalPrefPath();
 407         }
 408         StringOutputStream strGlobalPref( 256 );
 409         strGlobalPref << g_Preferences.m_global_rc_path->str << "global.pref";
 410         file_remove( strGlobalPref.c_str() );
 411 }
 412
 413 void CGameDialog::Init(){
 414         bool gamePrompt = false;
 415
 416         InitGlobalPrefPath();
 417         LoadPrefs();
 418         ScanForGames();
 419
 420         if ( mGames.empty() ) {
 421                 Error( "Didn't find any valid game file descriptions, aborting\n" );
 422         }
 423         else
 424         {
 425                 std::list<CGameDescription *>::iterator iGame, iPrevGame;
 426                 for ( iGame = mGames.begin(), iPrevGame = mGames.end(); iGame != mGames.end(); iPrevGame = iGame, ++iGame )
 427                 {
 428                         if ( iPrevGame != mGames.end() ) {
 429                                 if ( strcmp( ( *iGame )->getRequiredKeyValue( "name" ), ( *iPrevGame )->getRequiredKeyValue( "name" ) ) < 0 ) {
 430                                         CGameDescription *h = *iGame;
 431                                         *iGame = *iPrevGame;
 432                                         *iPrevGame = h;
 433                                 }
 434                         }
 435                 }
 436         }
 437
 438         CGameDescription* currentGameDescription = 0;
 439
 440         // m_bSkipGamePromptOnce is used to not prompt for game on restart, only on fresh startup
 441         if ( m_bGamePrompt && !m_bSkipGamePromptOnce ) {
 442                 gamePrompt = true;
 443         }
 444
 445         m_bSkipGamePromptOnce = false;
 446         g_GamesDialog.SavePrefs();
 447
 448         if ( !gamePrompt ) {
 449                 // search by .game name
 450                 std::list<CGameDescription *>::iterator iGame;
 451                 for ( iGame = mGames.begin(); iGame != mGames.end(); ++iGame )
 452                 {
 453                         if ( ( *iGame )->mGameFile == m_sGameFile ) {
 454                                 currentGameDescription = ( *iGame );
 455                                 break;
 456                         }
 457                 }
 458         }
 459
 460         if ( gamePrompt || !currentGameDescription ) {
 461                 onStartup = true;
 462                 Create();
 463                 DoGameDialog();
 464                 // use m_nComboSelect to identify the game to run as and set the globals
 465                 currentGameDescription = GameDescriptionForComboItem();
 466                 ASSERT_NOTNULL( currentGameDescription );
 467         }
 468         else {
 469                 onStartup = false;
 470         }
 471
 472         g_pGameDescription = currentGameDescription;
 473
 474         g_pGameDescription->Dump();
 475 }
 476
 477 CGameDialog::~CGameDialog(){
 478         // free all the game descriptions
 479         std::list<CGameDescription *>::iterator iGame;
 480         for ( iGame = mGames.begin(); iGame != mGames.end(); ++iGame )
 481         {
 482                 delete ( *iGame );
 483                 *iGame = 0;
 484         }
 485         if ( GetWidget() ) {
 486                 Destroy();
 487         }
 488 }
 489
 490 inline const char* GameDescription_getIdentifier( const CGameDescription& gameDescription ){
 491         const char* identifier = gameDescription.getKeyValue( "index" );
 492         if ( string_empty( identifier ) ) {
 493                 identifier = "1";
 494         }
 495         return identifier;
 496 }
 497
 498
 499 CGameDialog g_GamesDialog;
 500
 501
 502 // =============================================================================
 503 // Widget callbacks for PrefsDlg
 504
 505 static void OnButtonClean( ui::Widget widget, gpointer data ){
 506         // make sure this is what the user wants
 507         if ( ui::alert( g_Preferences.GetWidget(), "This will close " RADIANT_NAME " and clean the corresponding registry entries.\n"
 508                                                                                                                                   "Next time you start " RADIANT_NAME " it will be good as new. Do you wish to continue?",
 509                                                  "Reset Registry", ui::alert_type::YESNO, ui::alert_icon::Asterisk ) == ui::alert_response::YES ) {
 510                 PrefsDlg *dlg = (PrefsDlg*)data;
 511                 dlg->EndModal( eIDCANCEL );
 512
 513                 g_preferences_globals.disable_ini = true;
 514                 Preferences_Reset();
 515                 gtk_main_quit();
 516         }
 517 }
 518
 519 // =============================================================================
 520 // PrefsDlg class
 521
 522 /*
 523    ========
 524
 525    very first prefs init deals with selecting the game and the game tools path
 526    then we can load .ini stuff
 527
 528    using prefs / ini settings:
 529    those are per-game
 530
 531    look in ~/.radiant/<version>/gamename
 532    ========
 533  */
 534
 535 const char *PREFS_LOCAL_FILENAME = "local.pref";
 536
 537 void PrefsDlg::Init(){
 538         // m_global_rc_path has been set above
 539         // m_rc_path is for game specific preferences
 540         // takes the form: global-pref-path/gamename/prefs-file
 541
 542         // this is common to win32 and Linux init now
 543         m_rc_path = g_string_new( m_global_rc_path->str );
 544
 545         // game sub-dir
 546         g_string_append( m_rc_path, g_pGameDescription->mGameFile.c_str() );
 547         g_string_append( m_rc_path, "/" );
 548         Q_mkdir( m_rc_path->str );
 549
 550         // then the ini file
 551         m_inipath = g_string_new( m_rc_path->str );
 552         g_string_append( m_inipath, PREFS_LOCAL_FILENAME );
 553 }
 554
 555 void notebook_set_page( ui::Widget notebook, ui::Widget page ){
 556         int pagenum = gtk_notebook_page_num( GTK_NOTEBOOK( notebook ), page );
 557         if ( gtk_notebook_get_current_page( GTK_NOTEBOOK( notebook ) ) != pagenum ) {
 558                 gtk_notebook_set_current_page( GTK_NOTEBOOK( notebook ), pagenum );
 559         }
 560 }
 561
 562 void PrefsDlg::showPrefPage( ui::Widget prefpage ){
 563         notebook_set_page( m_notebook, prefpage );
 564         return;
 565 }
 566
 567 static void treeSelection( ui::TreeSelection selection, gpointer data ){
 568         PrefsDlg *dlg = (PrefsDlg*)data;
 569
 570         GtkTreeModel* model;
 571         GtkTreeIter selected;
 572         if ( gtk_tree_selection_get_selected( selection, &model, &selected ) ) {
 573                 ui::Widget prefpage{ui::null};
 574                 gtk_tree_model_get( model, &selected, 1, (gpointer*)&prefpage, -1 );
 575                 dlg->showPrefPage( prefpage );
 576         }
 577 }
 578
 579 typedef std::list<PreferenceGroupCallback> PreferenceGroupCallbacks;
 580
 581 inline void PreferenceGroupCallbacks_constructGroup( const PreferenceGroupCallbacks& callbacks, PreferenceGroup& group ){
 582         for ( PreferenceGroupCallbacks::const_iterator i = callbacks.begin(); i != callbacks.end(); ++i )
 583         {
 584                 ( *i )( group );
 585         }
 586 }
 587
 588
 589 inline void PreferenceGroupCallbacks_pushBack( PreferenceGroupCallbacks& callbacks, const PreferenceGroupCallback& callback ){
 590         callbacks.push_back( callback );
 591 }
 592
 593 typedef std::list<PreferencesPageCallback> PreferencesPageCallbacks;
 594
 595 inline void PreferencesPageCallbacks_constructPage( const PreferencesPageCallbacks& callbacks, PreferencesPage& page ){
 596         for ( PreferencesPageCallbacks::const_iterator i = callbacks.begin(); i != callbacks.end(); ++i )
 597         {
 598                 ( *i )( page );
 599         }
 600 }
 601
 602 inline void PreferencesPageCallbacks_pushBack( PreferencesPageCallbacks& callbacks, const PreferencesPageCallback& callback ){
 603         callbacks.push_back( callback );
 604 }
 605
 606 PreferencesPageCallbacks g_interfacePreferences;
 607 void PreferencesDialog_addInterfacePreferences( const PreferencesPageCallback& callback ){
 608         PreferencesPageCallbacks_pushBack( g_interfacePreferences, callback );
 609 }
 610 PreferenceGroupCallbacks g_interfaceCallbacks;
 611 void PreferencesDialog_addInterfacePage( const PreferenceGroupCallback& callback ){
 612         PreferenceGroupCallbacks_pushBack( g_interfaceCallbacks, callback );
 613 }
 614
 615 PreferencesPageCallbacks g_displayPreferences;
 616 void PreferencesDialog_addDisplayPreferences( const PreferencesPageCallback& callback ){
 617         PreferencesPageCallbacks_pushBack( g_displayPreferences, callback );
 618 }
 619 PreferenceGroupCallbacks g_displayCallbacks;
 620 void PreferencesDialog_addDisplayPage( const PreferenceGroupCallback& callback ){
 621         PreferenceGroupCallbacks_pushBack( g_displayCallbacks, callback );
 622 }
 623
 624 PreferencesPageCallbacks g_settingsPreferences;
 625 void PreferencesDialog_addSettingsPreferences( const PreferencesPageCallback& callback ){
 626         PreferencesPageCallbacks_pushBack( g_settingsPreferences, callback );
 627 }
 628 PreferenceGroupCallbacks g_settingsCallbacks;
 629 void PreferencesDialog_addSettingsPage( const PreferenceGroupCallback& callback ){
 630         PreferenceGroupCallbacks_pushBack( g_settingsCallbacks, callback );
 631 }
 632
 633 void Widget_updateDependency( ui::Widget self, ui::Widget toggleButton ){
 634         gtk_widget_set_sensitive( self, gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( toggleButton ) ) && gtk_widget_is_sensitive( toggleButton ) );
 635 }
 636
 637 void ToggleButton_toggled_Widget_updateDependency( ui::Widget toggleButton, ui::Widget self ){
 638         Widget_updateDependency( self, toggleButton );
 639 }
 640
 641 void ToggleButton_state_changed_Widget_updateDependency( ui::Widget toggleButton, GtkStateType state, ui::Widget self ){
 642         if ( state == GTK_STATE_INSENSITIVE ) {
 643                 Widget_updateDependency( self, toggleButton );
 644         }
 645 }
 646
 647 void Widget_connectToggleDependency( ui::Widget self, ui::Widget toggleButton ){
 648         toggleButton.connect( "state_changed", G_CALLBACK( ToggleButton_state_changed_Widget_updateDependency ), self );
 649         toggleButton.connect( "toggled", G_CALLBACK( ToggleButton_toggled_Widget_updateDependency ), self );
 650         Widget_updateDependency( self, toggleButton );
 651 }
 652
 653
 654 inline ui::VBox getVBox( ui::Bin page ){
 655         return ui::VBox::from(gtk_bin_get_child(page));
 656 }
 657
 658 GtkTreeIter PreferenceTree_appendPage( ui::TreeStore store, GtkTreeIter* parent, const char* name, ui::Widget page ){
 659         GtkTreeIter group;
 660         gtk_tree_store_append( store, &group, parent );
 661         gtk_tree_store_set( store, &group, 0, name, 1, page, -1 );
 662         return group;
 663 }
 664
 665 ui::Bin PreferencePages_addPage( ui::Widget notebook, const char* name ){
 666         ui::Widget preflabel = ui::Label( name );
 667         preflabel.show();
 668
 669         auto pageframe = ui::Frame( name );
 670         gtk_container_set_border_width( GTK_CONTAINER( pageframe ), 4 );
 671         pageframe.show();
 672
 673         ui::Widget vbox = ui::VBox( FALSE, 4 );
 674         vbox.show();
 675         gtk_container_set_border_width( GTK_CONTAINER( vbox ), 4 );
 676         pageframe.add(vbox);
 677
 678         // Add the page to the notebook
 679         gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), pageframe, preflabel );
 680
 681         return pageframe;
 682 }
 683
 684 class PreferenceTreeGroup : public PreferenceGroup
 685 {
 686 Dialog& m_dialog;
 687 ui::Widget m_notebook;
 688 ui::TreeStore m_store;
 689 GtkTreeIter m_group;
 690 public:
 691 PreferenceTreeGroup( Dialog& dialog, ui::Widget notebook, ui::TreeStore store, GtkTreeIter group ) :
 692         m_dialog( dialog ),
 693         m_notebook( notebook ),
 694         m_store( store ),
 695         m_group( group ){
 696 }
 697 PreferencesPage createPage( const char* treeName, const char* frameName ){
 698         auto page = PreferencePages_addPage( m_notebook, frameName );
 699         PreferenceTree_appendPage( m_store, &m_group, treeName, page );
 700         return PreferencesPage( m_dialog, getVBox( page ) );
 701 }
 702 };
 703
 704 ui::Window PrefsDlg::BuildDialog(){
 705         PreferencesDialog_addInterfacePreferences( makeCallbackF(Interface_constructPreferences) );
 706         Mouse_registerPreferencesPage();
 707
 708         ui::Window main_window = MainFrame_getWindow();
 709
 710         ui::Window dialog = ui::Window(create_floating_window( RADIANT_NAME " Preferences", m_parent ));
 711
 712         gtk_window_set_transient_for( dialog, m_parent );
 713         gtk_window_set_position( dialog, GTK_WIN_POS_CENTER_ON_PARENT );
 714
 715         {
 716                 auto mainvbox = ui::VBox( FALSE, 5 );
 717                 dialog.add(mainvbox);
 718                 gtk_container_set_border_width( GTK_CONTAINER( mainvbox ), 5 );
 719                 mainvbox.show();
 720
 721                 {
 722                         auto hbox = ui::HBox( FALSE, 5 );
 723                         hbox.show();
 724                         mainvbox.pack_end(hbox, FALSE, TRUE, 0);
 725
 726                         {
 727                                 auto button = create_dialog_button( "OK", G_CALLBACK( dialog_button_ok ), &m_modal );
 728                                 hbox.pack_end(button, FALSE, FALSE, 0);
 729                         }
 730                         {
 731                                 auto button = create_dialog_button( "Cancel", G_CALLBACK( dialog_button_cancel ), &m_modal );
 732                                 hbox.pack_end(button, FALSE, FALSE, 0);
 733                         }
 734                         {
 735                                 auto button = create_dialog_button( "Clean", G_CALLBACK( OnButtonClean ), this );
 736                                 hbox.pack_end(button, FALSE, FALSE, 0);
 737                         }
 738                 }
 739
 740                 {
 741                         auto hbox = ui::HBox( FALSE, 5 );
 742                         mainvbox.pack_start( hbox, TRUE, TRUE, 0 );
 743                         hbox.show();
 744
 745                         {
 746                                 auto sc_win = ui::ScrolledWindow(ui::New);
 747                                 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sc_win ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
 748                                 hbox.pack_start( sc_win, FALSE, FALSE, 0 );
 749                                 sc_win.show();
 750                                 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( sc_win ), GTK_SHADOW_IN );
 751
 752                                 // prefs pages notebook
 753                                 m_notebook = ui::Widget::from(gtk_notebook_new());
 754                                 // hide the notebook tabs since its not supposed to look like a notebook
 755                                 gtk_notebook_set_show_tabs( GTK_NOTEBOOK( m_notebook ), FALSE );
 756                                 hbox.pack_start( m_notebook, TRUE, TRUE, 0 );
 757                                 m_notebook.show();
 758
 759
 760                                 {
 761                                         auto store = ui::TreeStore::from(gtk_tree_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
 762
 763                                         auto view = ui::TreeView(ui::TreeModel::from(store._handle));
 764                                         gtk_tree_view_set_headers_visible(view, FALSE );
 765
 766                                         {
 767                                                 auto renderer = ui::CellRendererText(ui::New);
 768                         auto column = ui::TreeViewColumn( "Preferences", renderer, {{"text", 0}} );
 769                                                 gtk_tree_view_append_column(view, column );
 770                                         }
 771
 772                                         {
 773                                                 auto selection = ui::TreeSelection::from(gtk_tree_view_get_selection(view));
 774                                                 selection.connect( "changed", G_CALLBACK( treeSelection ), this );
 775                                         }
 776
 777                                         view.show();
 778
 779                                         sc_win.add(view);
 780
 781                                         {
 782                                                 /********************************************************************/
 783                                                 /* Add preference tree options                                      */
 784                                                 /********************************************************************/
 785                                                 // Front page...
 786                                                 //GtkWidget* front =
 787                                                 PreferencePages_addPage( m_notebook, "Front Page" );
 788
 789                                                 {
 790                                                         auto global = PreferencePages_addPage( m_notebook, "Global Preferences" );
 791                                                         {
 792                                                                 PreferencesPage preferencesPage( *this, getVBox( global ) );
 793                                                                 Global_constructPreferences( preferencesPage );
 794                                                         }
 795                             auto group = PreferenceTree_appendPage( store, 0, "Global", global );
 796                                                         {
 797                                                                 auto game = PreferencePages_addPage( m_notebook, "Game" );
 798                                                                 PreferencesPage preferencesPage( *this, getVBox( game ) );
 799                                                                 g_GamesDialog.CreateGlobalFrame( preferencesPage );
 800
 801                                                                 PreferenceTree_appendPage( store, &group, "Game", game );
 802                                                         }
 803                                                 }
 804
 805                                                 {
 806                                                         auto interfacePage = PreferencePages_addPage( m_notebook, "Interface Preferences" );
 807                                                         {
 808                                                                 PreferencesPage preferencesPage( *this, getVBox( interfacePage ) );
 809                                                                 PreferencesPageCallbacks_constructPage( g_interfacePreferences, preferencesPage );
 810                                                         }
 811
 812                             auto group = PreferenceTree_appendPage( store, 0, "Interface", interfacePage );
 813                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
 814
 815                                                         PreferenceGroupCallbacks_constructGroup( g_interfaceCallbacks, preferenceGroup );
 816                                                 }
 817
 818                                                 {
 819                                                         auto display = PreferencePages_addPage( m_notebook, "Display Preferences" );
 820                                                         {
 821                                                                 PreferencesPage preferencesPage( *this, getVBox( display ) );
 822                                                                 PreferencesPageCallbacks_constructPage( g_displayPreferences, preferencesPage );
 823                                                         }
 824                             auto group = PreferenceTree_appendPage( store, 0, "Display", display );
 825                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
 826
 827                                                         PreferenceGroupCallbacks_constructGroup( g_displayCallbacks, preferenceGroup );
 828                                                 }
 829
 830                                                 {
 831                                                         auto settings = PreferencePages_addPage( m_notebook, "General Settings" );
 832                                                         {
 833                                                                 PreferencesPage preferencesPage( *this, getVBox( settings ) );
 834                                                                 PreferencesPageCallbacks_constructPage( g_settingsPreferences, preferencesPage );
 835                                                         }
 836
 837                             auto group = PreferenceTree_appendPage( store, 0, "Settings", settings );
 838                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
 839
 840                                                         PreferenceGroupCallbacks_constructGroup( g_settingsCallbacks, preferenceGroup );
 841                                                 }
 842                                         }
 843
 844                                         gtk_tree_view_expand_all(view );
 845
 846                                         g_object_unref( G_OBJECT( store ) );
 847                                 }
 848                         }
 849                 }
 850         }
 851
 852         gtk_notebook_set_current_page( GTK_NOTEBOOK( m_notebook ), 0 );
 853
 854         return dialog;
 855 }
 856
 857 preferences_globals_t g_preferences_globals;
 858
 859 PrefsDlg g_Preferences;               // global prefs instance
 860
 861
 862 void PreferencesDialog_constructWindow( ui::Window main_window ){
 863         g_Preferences.m_parent = main_window;
 864         g_Preferences.Create();
 865 }
 866 void PreferencesDialog_destroyWindow(){
 867         g_Preferences.Destroy();
 868 }
 869
 870
 871 PreferenceDictionary g_preferences;
 872
 873 PreferenceSystem& GetPreferenceSystem(){
 874         return g_preferences;
 875 }
 876
 877 class PreferenceSystemAPI
 878 {
 879 PreferenceSystem* m_preferencesystem;
 880 public:
 881 typedef PreferenceSystem Type;
 882 STRING_CONSTANT( Name, "*" );
 883
 884 PreferenceSystemAPI(){
 885         m_preferencesystem = &GetPreferenceSystem();
 886 }
 887 PreferenceSystem* getTable(){
 888         return m_preferencesystem;
 889 }
 890 };
 891
 892 #include "modulesystem/singletonmodule.h"
 893 #include "modulesystem/moduleregistry.h"
 894
 895 typedef SingletonModule<PreferenceSystemAPI> PreferenceSystemModule;
 896 typedef Static<PreferenceSystemModule> StaticPreferenceSystemModule;
 897 StaticRegisterModule staticRegisterPreferenceSystem( StaticPreferenceSystemModule::instance() );
 898
 899 void Preferences_Load(){
 900         g_GamesDialog.LoadPrefs();
 901
 902         globalOutputStream() << "loading local preferences from " << g_Preferences.m_inipath->str << "\n";
 903
 904         if ( !Preferences_Load( g_preferences, g_Preferences.m_inipath->str, g_GamesDialog.m_sGameFile.c_str() ) ) {
 905                 globalOutputStream() << "failed to load local preferences from " << g_Preferences.m_inipath->str << "\n";
 906         }
 907 }
 908
 909 void Preferences_Save(){
 910         if ( g_preferences_globals.disable_ini ) {
 911                 return;
 912         }
 913
 914         // save global preferences
 915         g_GamesDialog.SavePrefs();
 916
 917         globalOutputStream() << "saving local preferences to " << g_Preferences.m_inipath->str << "\n";
 918
 919         if ( !Preferences_Save_Safe( g_preferences, g_Preferences.m_inipath->str ) ) {
 920                 globalOutputStream() << "failed to save local preferences to " << g_Preferences.m_inipath->str << "\n";
 921         }
 922 }
 923
 924 void Preferences_Reset(){
 925         file_remove( g_Preferences.m_inipath->str );
 926 }
 927
 928
 929 void PrefsDlg::PostModal( EMessageBoxReturn code ){
 930         if ( code == eIDOK ) {
 931                 Preferences_Save();
 932                 UpdateAllWindows();
 933         }
 934 }
 935
 936 std::vector<const char*> g_restart_required;
 937
 938 void PreferencesDialog_restartRequired( const char* staticName ){
 939         g_restart_required.push_back( staticName );
 940 }
 941
 942 void PreferencesDialog_showDialog(){
 943         if ( ConfirmModified( "Edit Preferences" ) && g_Preferences.DoModal() == eIDOK ) {
 944                 if ( !g_restart_required.empty() ) {
 945                         StringOutputStream message( 256 );
 946                         message << "Preference changes require a restart:\n\n";
 947
 948                         for ( std::vector<const char*>::iterator i = g_restart_required.begin(); i != g_restart_required.end(); ++i )
 949                         {
 950                                 message << ( *i ) << '\n';
 951                         }
 952
 953                         message << "\nRestart now?";
 954
 955                         auto ret = ui::alert( MainFrame_getWindow(), message.c_str(), "Restart " RADIANT_NAME "?", ui::alert_type::YESNO, ui::alert_icon::Question );
 956
 957                         g_restart_required.clear();
 958
 959                         if ( ret == ui::alert_response::YES ) {
 960                                 g_GamesDialog.m_bSkipGamePromptOnce = true;
 961                                 Radiant_Restart();
 962                         }
 963                 }
 964         }
 965 }
 966
 967 struct GameName {
 968         static void Export(const Callback<void(const char *)> &returnz) {
 969                 returnz(gamename_get());
 970         }
 971
 972         static void Import(const char *value) {
 973                 gamename_set(value);
 974         }
 975 };
 976
 977 struct GameMode {
 978         static void Export(const Callback<void(const char *)> &returnz) {
 979                 returnz(gamemode_get());
 980         }
 981
 982         static void Import(const char *value) {
 983                 gamemode_set(value);
 984         }
 985 };
 986
 987 void RegisterPreferences( PreferenceSystem& preferences ){
 988 #if GDEF_OS_WINDOWS
 989         preferences.registerPreference( "UseCustomShaderEditor", make_property_string( g_TextEditor_useWin32Editor ) );
 990 #else
 991         preferences.registerPreference( "UseCustomShaderEditor", make_property_string( g_TextEditor_useCustomEditor ) );
 992         preferences.registerPreference( "CustomShaderEditorCommand", make_property_string( g_TextEditor_editorCommand ) );
 993 #endif
 994
 995         preferences.registerPreference( "GameName", make_property<GameName>() );
 996         preferences.registerPreference( "GameMode", make_property<GameMode>() );
 997 }
 998
 999 void Preferences_Init(){
1000         RegisterPreferences( GetPreferenceSystem() );
1001 }