6fca8c12d4152fce787c79a40b2303115fd4f5ee
[xonotic/netradiant.git] / 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 dialog = ui::Window(create_floating_window( RADIANT_NAME " Preferences", m_parent ));
709
710         gtk_window_set_transient_for( dialog, m_parent );
711         gtk_window_set_position( dialog, GTK_WIN_POS_CENTER_ON_PARENT );
712
713         {
714                 auto mainvbox = ui::VBox( FALSE, 5 );
715                 dialog.add(mainvbox);
716                 gtk_container_set_border_width( GTK_CONTAINER( mainvbox ), 5 );
717                 mainvbox.show();
718
719                 {
720                         auto hbox = ui::HBox( FALSE, 5 );
721                         hbox.show();
722                         mainvbox.pack_end(hbox, FALSE, TRUE, 0);
723
724                         {
725                                 auto button = create_dialog_button( "OK", G_CALLBACK( dialog_button_ok ), &m_modal );
726                                 hbox.pack_end(button, FALSE, FALSE, 0);
727                         }
728                         {
729                                 auto button = create_dialog_button( "Cancel", G_CALLBACK( dialog_button_cancel ), &m_modal );
730                                 hbox.pack_end(button, FALSE, FALSE, 0);
731                         }
732                         {
733                                 auto button = create_dialog_button( "Clean", G_CALLBACK( OnButtonClean ), this );
734                                 hbox.pack_end(button, FALSE, FALSE, 0);
735                         }
736                 }
737
738                 {
739                         auto hbox = ui::HBox( FALSE, 5 );
740                         mainvbox.pack_start( hbox, TRUE, TRUE, 0 );
741                         hbox.show();
742
743                         {
744                                 auto sc_win = ui::ScrolledWindow(ui::New);
745                                 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sc_win ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
746                                 hbox.pack_start( sc_win, FALSE, FALSE, 0 );
747                                 sc_win.show();
748                                 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( sc_win ), GTK_SHADOW_IN );
749
750                                 // prefs pages notebook
751                                 m_notebook = ui::Widget::from(gtk_notebook_new());
752                                 // hide the notebook tabs since its not supposed to look like a notebook
753                                 gtk_notebook_set_show_tabs( GTK_NOTEBOOK( m_notebook ), FALSE );
754                                 hbox.pack_start( m_notebook, TRUE, TRUE, 0 );
755                                 m_notebook.show();
756
757
758                                 {
759                                         auto store = ui::TreeStore::from(gtk_tree_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
760
761                                         auto view = ui::TreeView(ui::TreeModel::from(store._handle));
762                                         gtk_tree_view_set_headers_visible(view, FALSE );
763
764                                         {
765                                                 auto renderer = ui::CellRendererText(ui::New);
766                         auto column = ui::TreeViewColumn( "Preferences", renderer, {{"text", 0}} );
767                                                 gtk_tree_view_append_column(view, column );
768                                         }
769
770                                         {
771                                                 auto selection = ui::TreeSelection::from(gtk_tree_view_get_selection(view));
772                                                 selection.connect( "changed", G_CALLBACK( treeSelection ), this );
773                                         }
774
775                                         view.show();
776
777                                         sc_win.add(view);
778
779                                         {
780                                                 /********************************************************************/
781                                                 /* Add preference tree options                                      */
782                                                 /********************************************************************/
783                                                 // Front page...
784                                                 //GtkWidget* front =
785                                                 PreferencePages_addPage( m_notebook, "Front Page" );
786
787                                                 {
788                                                         auto global = PreferencePages_addPage( m_notebook, "Global Preferences" );
789                                                         {
790                                                                 PreferencesPage preferencesPage( *this, getVBox( global ) );
791                                                                 Global_constructPreferences( preferencesPage );
792                                                         }
793                             auto group = PreferenceTree_appendPage( store, 0, "Global", global );
794                                                         {
795                                                                 auto game = PreferencePages_addPage( m_notebook, "Game" );
796                                                                 PreferencesPage preferencesPage( *this, getVBox( game ) );
797                                                                 g_GamesDialog.CreateGlobalFrame( preferencesPage );
798
799                                                                 PreferenceTree_appendPage( store, &group, "Game", game );
800                                                         }
801                                                 }
802
803                                                 {
804                                                         auto interfacePage = PreferencePages_addPage( m_notebook, "Interface Preferences" );
805                                                         {
806                                                                 PreferencesPage preferencesPage( *this, getVBox( interfacePage ) );
807                                                                 PreferencesPageCallbacks_constructPage( g_interfacePreferences, preferencesPage );
808                                                         }
809
810                             auto group = PreferenceTree_appendPage( store, 0, "Interface", interfacePage );
811                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
812
813                                                         PreferenceGroupCallbacks_constructGroup( g_interfaceCallbacks, preferenceGroup );
814                                                 }
815
816                                                 {
817                                                         auto display = PreferencePages_addPage( m_notebook, "Display Preferences" );
818                                                         {
819                                                                 PreferencesPage preferencesPage( *this, getVBox( display ) );
820                                                                 PreferencesPageCallbacks_constructPage( g_displayPreferences, preferencesPage );
821                                                         }
822                             auto group = PreferenceTree_appendPage( store, 0, "Display", display );
823                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
824
825                                                         PreferenceGroupCallbacks_constructGroup( g_displayCallbacks, preferenceGroup );
826                                                 }
827
828                                                 {
829                                                         auto settings = PreferencePages_addPage( m_notebook, "General Settings" );
830                                                         {
831                                                                 PreferencesPage preferencesPage( *this, getVBox( settings ) );
832                                                                 PreferencesPageCallbacks_constructPage( g_settingsPreferences, preferencesPage );
833                                                         }
834
835                             auto group = PreferenceTree_appendPage( store, 0, "Settings", settings );
836                                                         PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
837
838                                                         PreferenceGroupCallbacks_constructGroup( g_settingsCallbacks, preferenceGroup );
839                                                 }
840                                         }
841
842                                         gtk_tree_view_expand_all(view );
843
844                                         g_object_unref( G_OBJECT( store ) );
845                                 }
846                         }
847                 }
848         }
849
850         gtk_notebook_set_current_page( GTK_NOTEBOOK( m_notebook ), 0 );
851
852         return dialog;
853 }
854
855 preferences_globals_t g_preferences_globals;
856
857 PrefsDlg g_Preferences;               // global prefs instance
858
859
860 void PreferencesDialog_constructWindow( ui::Window main_window ){
861         g_Preferences.m_parent = main_window;
862         g_Preferences.Create();
863 }
864 void PreferencesDialog_destroyWindow(){
865         g_Preferences.Destroy();
866 }
867
868
869 PreferenceDictionary g_preferences;
870
871 PreferenceSystem& GetPreferenceSystem(){
872         return g_preferences;
873 }
874
875 class PreferenceSystemAPI
876 {
877 PreferenceSystem* m_preferencesystem;
878 public:
879 typedef PreferenceSystem Type;
880 STRING_CONSTANT( Name, "*" );
881
882 PreferenceSystemAPI(){
883         m_preferencesystem = &GetPreferenceSystem();
884 }
885 PreferenceSystem* getTable(){
886         return m_preferencesystem;
887 }
888 };
889
890 #include "modulesystem/singletonmodule.h"
891 #include "modulesystem/moduleregistry.h"
892
893 typedef SingletonModule<PreferenceSystemAPI> PreferenceSystemModule;
894 typedef Static<PreferenceSystemModule> StaticPreferenceSystemModule;
895 StaticRegisterModule staticRegisterPreferenceSystem( StaticPreferenceSystemModule::instance() );
896
897 void Preferences_Load(){
898         g_GamesDialog.LoadPrefs();
899
900         globalOutputStream() << "loading local preferences from " << g_Preferences.m_inipath->str << "\n";
901
902         if ( !Preferences_Load( g_preferences, g_Preferences.m_inipath->str, g_GamesDialog.m_sGameFile.c_str() ) ) {
903                 globalOutputStream() << "failed to load local preferences from " << g_Preferences.m_inipath->str << "\n";
904         }
905 }
906
907 void Preferences_Save(){
908         if ( g_preferences_globals.disable_ini ) {
909                 return;
910         }
911
912         // save global preferences
913         g_GamesDialog.SavePrefs();
914
915         globalOutputStream() << "saving local preferences to " << g_Preferences.m_inipath->str << "\n";
916
917         if ( !Preferences_Save_Safe( g_preferences, g_Preferences.m_inipath->str ) ) {
918                 globalOutputStream() << "failed to save local preferences to " << g_Preferences.m_inipath->str << "\n";
919         }
920 }
921
922 void Preferences_Reset(){
923         file_remove( g_Preferences.m_inipath->str );
924 }
925
926
927 void PrefsDlg::PostModal( EMessageBoxReturn code ){
928         if ( code == eIDOK ) {
929                 Preferences_Save();
930                 UpdateAllWindows();
931         }
932 }
933
934 std::vector<const char*> g_restart_required;
935
936 void PreferencesDialog_restartRequired( const char* staticName ){
937         g_restart_required.push_back( staticName );
938 }
939
940 void PreferencesDialog_showDialog(){
941         if ( ConfirmModified( "Edit Preferences" ) && g_Preferences.DoModal() == eIDOK ) {
942                 if ( !g_restart_required.empty() ) {
943                         StringOutputStream message( 256 );
944                         message << "Preference changes require a restart:\n\n";
945
946                         for ( std::vector<const char*>::iterator i = g_restart_required.begin(); i != g_restart_required.end(); ++i )
947                         {
948                                 message << ( *i ) << '\n';
949                         }
950
951                         message << "\nRestart now?";
952
953                         auto ret = ui::alert( MainFrame_getWindow(), message.c_str(), "Restart " RADIANT_NAME "?", ui::alert_type::YESNO, ui::alert_icon::Question );
954
955                         g_restart_required.clear();
956
957                         if ( ret == ui::alert_response::YES ) {
958                                 g_GamesDialog.m_bSkipGamePromptOnce = true;
959                                 Radiant_Restart();
960                         }
961                 }
962         }
963 }
964
965 struct GameName {
966         static void Export(const Callback<void(const char *)> &returnz) {
967                 returnz(gamename_get());
968         }
969
970         static void Import(const char *value) {
971                 gamename_set(value);
972         }
973 };
974
975 struct GameMode {
976         static void Export(const Callback<void(const char *)> &returnz) {
977                 returnz(gamemode_get());
978         }
979
980         static void Import(const char *value) {
981                 gamemode_set(value);
982         }
983 };
984
985 void RegisterPreferences( PreferenceSystem& preferences ){
986 #if GDEF_OS_WINDOWS
987         preferences.registerPreference( "UseCustomShaderEditor", make_property_string( g_TextEditor_useWin32Editor ) );
988 #else
989         preferences.registerPreference( "UseCustomShaderEditor", make_property_string( g_TextEditor_useCustomEditor ) );
990         preferences.registerPreference( "CustomShaderEditorCommand", make_property_string( g_TextEditor_editorCommand ) );
991 #endif
992
993         preferences.registerPreference( "GameName", make_property<GameName>() );
994         preferences.registerPreference( "GameMode", make_property<GameMode>() );
995 }
996
997 void Preferences_Init(){
998         RegisterPreferences( GetPreferenceSystem() );
999 }